Add in the twa(4) driver. This adds in support for the 3Ware
authorDavid Rhodus <drhodus@dragonflybsd.org>
Fri, 16 Apr 2004 20:13:17 +0000 (20:13 +0000)
committerDavid Rhodus <drhodus@dragonflybsd.org>
Fri, 16 Apr 2004 20:13:17 +0000 (20:13 +0000)
Escalade 9000 series storage controllers. The driver is a
port of the work done by Vinod Kashyap in FreeBSD.

16 files changed:
sys/config/GENERIC
sys/config/LINT
sys/dev/raid/Makefile
sys/dev/raid/twa/Makefile [new file with mode: 0644]
sys/dev/raid/twa/twa.c [new file with mode: 0644]
sys/dev/raid/twa/twa.h [new file with mode: 0644]
sys/dev/raid/twa/twa_cam.c [new file with mode: 0644]
sys/dev/raid/twa/twa_externs.h [new file with mode: 0644]
sys/dev/raid/twa/twa_freebsd.c [new file with mode: 0644]
sys/dev/raid/twa/twa_fwimg.c [new file with mode: 0644]
sys/dev/raid/twa/twa_globals.c [new file with mode: 0644]
sys/dev/raid/twa/twa_includes.h [new file with mode: 0644]
sys/dev/raid/twa/twa_ioctl.h [new file with mode: 0644]
sys/dev/raid/twa/twa_reg.h [new file with mode: 0644]
sys/i386/conf/GENERIC
sys/i386/conf/LINT

index f2cf1f7..6b6b13a 100644 (file)
@@ -11,7 +11,7 @@
 # in doubt as to the purpose or necessity of a line, check first in LINT.
 #
 # $FreeBSD: src/sys/i386/conf/GENERIC,v 1.246.2.54 2003/04/28 03:41:46 simokawa Exp $
-# $DragonFly: src/sys/config/GENERIC,v 1.11 2004/04/05 13:44:40 eirikn Exp $
+# $DragonFly: src/sys/config/GENERIC,v 1.12 2004/04/16 20:13:17 drhodus Exp $
 
 machine                i386
 cpu            I386_CPU
@@ -134,7 +134,8 @@ device              aac             # Adaptec FSA RAID, Dell PERC2/PERC3
 device         ida             # Compaq Smart RAID
 device         amr             # AMI MegaRAID
 device         mlx             # Mylex DAC960 family
-device         twe             # 3ware Escalade
+device         twe             # 3ware Escalade 8000's
+device         twa             # 3ware Escalade 9000's
 device         pst             # Promise Supertrack
 
 # atkbdc0 controls both the keyboard and the PS/2 mouse
index 6ed6917..cdd6bf5 100644 (file)
@@ -3,7 +3,7 @@
 #      as much of the source tree as it can.
 #
 # $FreeBSD: src/sys/i386/conf/LINT,v 1.749.2.144 2003/06/04 17:56:59 sam Exp $
-# $DragonFly: src/sys/config/LINT,v 1.26 2004/04/16 19:49:09 drhodus Exp $
+# $DragonFly: src/sys/config/LINT,v 1.27 2004/04/16 20:13:17 drhodus Exp $
 #
 # NB: You probably don't want to try running a kernel built from this
 # file.  Instead, you should start from GENERIC, and add options from
@@ -1253,6 +1253,7 @@ device            amr             # AMI MegaRAID
 # 3ware ATA RAID
 #
 device         twe             # 3ware ATA RAID
+device         twa             # 3ware SATA RAID
 
 #
 # Promise Supertrack SX6000
index 2b39f5b..d5ef567 100644 (file)
@@ -1,6 +1,6 @@
-# $DragonFly: src/sys/dev/raid/Makefile,v 1.4 2004/01/15 15:42:51 drhodus Exp $
+# $DragonFly: src/sys/dev/raid/Makefile,v 1.5 2004/04/16 20:13:16 drhodus Exp $
 #
 
-SUBDIR=aac amr asr ciss iir ips mlx mly pst twe vinum
+SUBDIR=aac amr asr ciss iir ips mlx mly pst twa twe vinum
 
 .include <bsd.subdir.mk>
diff --git a/sys/dev/raid/twa/Makefile b/sys/dev/raid/twa/Makefile
new file mode 100644 (file)
index 0000000..9e89c9c
--- /dev/null
@@ -0,0 +1,25 @@
+# $FreeBSD$
+# $DragonFly: src/sys/dev/raid/twa/Makefile,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+
+#
+# Uncomment the following line to bundle firmware with the driver,
+# which may be flashed onto the controller, if the firmware on the
+# controller is older than the one bundled, and needs to be upgraded.
+# The size of the driver will increase significantly (to over 500KB)
+# if this option is selected.
+#
+FLASH_FIRMWARE=1
+
+KMOD = twa
+.PATH: ${.CURDIR}
+SRCS = twa_freebsd.c twa_cam.c twa.c twa_globals.c \
+      bus_if.h device_if.h pci_if.h opt_scsi.h opt_cam.h opt_twa.h
+
+.if defined(FLASH_FIRMWARE)
+CFLAGS+=-DTWA_FLASH_FIRMWARE
+SRCS += twa_fwimg.c
+.endif
+
+#CFLAGS+=-DTWA_DEBUG=0
+
+.include <bsd.kmod.mk>
diff --git a/sys/dev/raid/twa/twa.c b/sys/dev/raid/twa/twa.c
new file mode 100644 (file)
index 0000000..174827f
--- /dev/null
@@ -0,0 +1,2400 @@
+/*-
+ * Copyright (c) 2003-04 3ware, Inc.
+ * Copyright (c) 2000 Michael Smith
+ * Copyright (c) 2000 BSDi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     $FreeBSD$
+ * $DragonFly: src/sys/dev/raid/twa/twa.c,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+ */
+
+/*
+ * 3ware driver for 9000 series storage controllers.
+ *
+ * Author: Vinod Kashyap
+ */
+
+
+#include "twa_includes.h"
+
+#ifdef TWA_FLASH_FIRMWARE
+static int     twa_flash_firmware(struct twa_softc *sc);
+static int     twa_hard_reset(struct twa_softc *sc);
+#endif /* TWA_FLASH_FIRMWARE */
+
+static int     twa_init_ctlr(struct twa_softc *sc);
+static void    *twa_get_param(struct twa_softc *sc, int table_id,
+                                       int parameter_id, size_t size,
+                                       void (* callback)(struct twa_request *tr));
+static int     twa_set_param(struct twa_softc *sc, int table_id, int param_id,
+                                       int param_size, void *data,
+                                       void (* callback)(struct twa_request *tr));
+static int     twa_init_connection(struct twa_softc *sc, u_int16_t message_credits,
+                               u_int32_t set_features, u_int16_t current_fw_srl,
+                               u_int16_t current_fw_arch_id, u_int16_t current_fw_branch,
+                               u_int16_t current_fw_build, u_int16_t *fw_on_ctlr_srl,
+                               u_int16_t *fw_on_ctlr_arch_id, u_int16_t *fw_on_ctlr_branch,
+                               u_int16_t *fw_on_ctlr_build, u_int32_t *init_connect_result);
+
+static int     twa_wait_request(struct twa_request *req, u_int32_t timeout);
+static int     twa_immediate_request(struct twa_request *req, u_int32_t timeout);
+
+static int     twa_done(struct twa_softc *sc);
+static int     twa_drain_pending_queue(struct twa_softc *sc);
+static void    twa_drain_complete_queue(struct twa_softc *sc);
+static int     twa_wait_status(struct twa_softc *sc, u_int32_t status, u_int32_t timeout);
+static int     twa_drain_response_queue(struct twa_softc *sc);
+static int     twa_check_ctlr_state(struct twa_softc *sc, u_int32_t status_reg);
+static int     twa_soft_reset(struct twa_softc *sc);
+
+static void    twa_host_intr(struct twa_softc *sc);
+static void    twa_attention_intr(struct twa_softc *sc);
+static void    twa_command_intr(struct twa_softc *sc);
+
+static int     twa_fetch_aen(struct twa_softc *sc);
+static void    twa_aen_callback(struct twa_request *tr);
+static void    twa_enqueue_aen(struct twa_softc *sc, struct twa_command_header *cmd_hdr);
+static int     twa_drain_aen_queue(struct twa_softc *sc);
+static int     twa_find_aen(struct twa_softc *sc, u_int16_t aen_code);
+
+static void    twa_panic(struct twa_softc *sc, int8_t *reason);
+
+/*
+ * Function name:      twa_setup
+ * Description:                Initializes driver data structures for the controller.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_setup(struct twa_softc *sc)
+{
+       struct twa_event_packet *aen_queue;
+       int                     error = 0;
+       int                     i;
+
+       twa_dbg_dprint_enter(3, sc);
+
+       /* Initialize request queues. */
+       twa_initq_free(sc);
+       twa_initq_busy(sc);
+       twa_initq_pending(sc);
+       twa_initq_complete(sc);
+
+       if (twa_alloc_req_pkts(sc, TWA_Q_LENGTH)) {
+               twa_printf(sc, "Failed to allocate request packets.\n");
+               return(ENOMEM);
+       }
+
+       /* Allocate memory for the AEN queue. */
+       if ((aen_queue = malloc(sizeof(struct twa_event_packet) * TWA_Q_LENGTH,
+                                       M_DEVBUF, M_WAITOK)) == NULL) {
+               /* 
+                * This should not cause us to return error.  We will only be
+                * unable to support AEN's.  But then, we will have to check
+                * time and again to see if we can support AEN's, if we
+                * continue.  So, we will just return error.
+                */
+               twa_printf(sc, "Could not allocate memory for AEN queue.\n");
+               return(ENOMEM); /* any unfreed memory will be freed by twa_free */
+       }
+       /* Initialize the aen queue. */
+       bzero(aen_queue, sizeof(struct twa_event_packet) * TWA_Q_LENGTH);
+       for (i = 0; i < TWA_Q_LENGTH; i++)
+               sc->twa_aen_queue[i] = &(aen_queue[i]);
+
+       /*
+        * Disable interrupts from the card.
+        * Interrupts will be enabled back in twa_intrhook.
+        */
+       twa_disable_interrupts(sc);
+
+       /* Initialize the controller. */
+       if ((error = twa_init_ctlr(sc))) {
+               /* Soft reset the controller, and try one more time. */
+               twa_printf(sc, "Controller initialization failed. Retrying...\n");
+               if ((error = twa_soft_reset(sc)))
+                       twa_printf(sc, "Controller soft reset failed.\n");
+               else
+                       error = twa_init_ctlr(sc);
+       }
+       return(error);
+}
+
+#ifdef TWA_FLASH_FIRMWARE
+/*
+ * Function name:      twa_flash_firmware
+ * Description:                Flashes bundled firmware image onto controller.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_flash_firmware(struct twa_softc *sc)
+{
+       struct twa_request                      *tr;
+       struct twa_command_download_firmware    *cmd;
+       u_int32_t                               fw_img_chunk_size;
+       u_int32_t                               this_chunk_size = 0;
+       u_int32_t                               remaining_img_size = 0;
+       int                                     error;
+       int                                     i;
+
+       if ((tr = twa_get_request(sc)) == NULL) {
+               /* No free request packets available.  Can't proceed. */
+               error = EIO;
+               goto out;
+       }
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+       /* Allocate sufficient memory to hold a chunk of the firmware image. */
+       fw_img_chunk_size = ((twa_fw_img_size/NUM_FW_IMAGE_CHUNKS) + 511) & ~511;
+       if ((tr->tr_data = malloc(fw_img_chunk_size, M_DEVBUF, M_WAITOK)) == NULL) {
+               twa_printf (sc, "Could not allocate memory for firmware image.\n"); 
+               error = ENOMEM;
+               goto out;
+       }
+       remaining_img_size = twa_fw_img_size;
+       cmd = &(tr->tr_command->command.cmd_pkt_7k.download_fw);
+
+       for (i = 0; i < NUM_FW_IMAGE_CHUNKS; i++) {
+               /* Build a cmd pkt for downloading firmware. */
+               bzero(tr->tr_command, sizeof(struct twa_command_packet));
+
+               tr->tr_command->cmd_hdr.header_desc.size_header = 128;
+       
+               cmd->opcode = TWA_OP_DOWNLOAD_FIRMWARE;
+               cmd->sgl_offset = 2;/* offset in dwords, to the beginning of sg list */
+               cmd->size = 2;  /* this field will be updated at data map time */
+               cmd->request_id = tr->tr_request_id;
+               cmd->unit = 0;
+               cmd->status = 0;
+               cmd->flags = 0;
+               cmd->param = 8; /* prom image */
+
+               if (i != (NUM_FW_IMAGE_CHUNKS - 1))
+                       this_chunk_size = fw_img_chunk_size;
+               else     /* last chunk */
+                       this_chunk_size = remaining_img_size;
+       
+               remaining_img_size -= this_chunk_size;
+               bcopy(twa_fw_img + (i * fw_img_chunk_size),
+                                       tr->tr_data, this_chunk_size);
+
+               /*
+                * The next line will effect only the last chunk.
+                */
+               tr->tr_length = (this_chunk_size + 511) & ~511;
+
+               tr->tr_flags |= TWA_CMD_DATA_OUT;
+
+               error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
+               if (error) {
+                       twa_printf(sc, "Firmware flash request could not be posted. error = 0x%x\n",
+                                                                       error);
+                       if (error == ETIMEDOUT)
+                               return(error); /* clean-up done by twa_immediate_request */
+                       break;
+               }
+               error = cmd->status;
+               if (i != (NUM_FW_IMAGE_CHUNKS - 1)) {
+                       if ((error = tr->tr_command->cmd_hdr.status_block.error) != TWA_ERROR_MORE_DATA) {
+                               twa_printf(sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                       cmd->opcode,
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       error,
+                                       twa_find_msg_string(twa_error_table, error),
+                                       tr->tr_command->cmd_hdr.err_specific_desc);
+                               twa_printf(sc, "Firmware flash request failed. Intermediate error = 0x%x, i = %x\n",
+                                                       cmd->status, i);
+                               /* Hard reset the controller, so that it doesn't wait for the remaining chunks. */
+                               twa_hard_reset(sc);
+                               break;
+                       }
+               } else   /* last chunk */
+                       if (error) {
+                               twa_printf(sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                       cmd->opcode,
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       tr->tr_command->cmd_hdr.status_block.error,
+                                       twa_find_msg_string(twa_error_table,
+                                               tr->tr_command->cmd_hdr.status_block.error),
+                                       tr->tr_command->cmd_hdr.err_specific_desc);
+                               twa_printf(sc, "Firmware flash request failed. error = 0x%x\n", error);
+                               /* Hard reset the controller, so that it doesn't wait for more chunks. */
+                               twa_hard_reset(sc);
+                       }
+       } /* for */
+
+       if (tr->tr_data)
+               free(tr->tr_data, M_DEVBUF);
+out:
+       if (tr)
+               twa_release_request(tr);
+       return(error);
+}
+
+
+/*
+ * Function name:      twa_hard_reset
+ * Description:                Hard reset the controller.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_hard_reset(struct twa_softc *sc)
+{
+       struct twa_request                      *tr;
+       struct twa_command_reset_firmware       *cmd;
+       int                                     error;
+
+       if ((tr = twa_get_request(sc)) == NULL)
+               return(EIO);
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+       /* Build a cmd pkt for sending down the hard reset command. */
+       tr->tr_command->cmd_hdr.header_desc.size_header = 128;
+       
+       cmd = &(tr->tr_command->command.cmd_pkt_7k.reset_fw);
+       cmd->opcode = TWA_OP_RESET_FIRMWARE;
+       cmd->size = 2;  /* this field will be updated at data map time */
+       cmd->request_id = tr->tr_request_id;
+       cmd->unit = 0;
+       cmd->status = 0;
+       cmd->flags = 0;
+       cmd->param = 0; /* don't reload FPGA logic */
+
+       tr->tr_data = NULL;
+       tr->tr_length = 0;
+
+       error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
+       if (error) {
+               twa_printf(sc, "Hard reset request could not be posted. error = 0x%x\n",
+                                                               error);
+               if (error == ETIMEDOUT)
+                       return(error); /* clean-up done by twa_immediate_request */
+               goto out;
+       }
+       if ((error = cmd->status)) {
+               twa_printf(sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                       cmd->opcode,
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       tr->tr_command->cmd_hdr.status_block.error,
+                                       twa_find_msg_string(twa_error_table,
+                                               tr->tr_command->cmd_hdr.status_block.error),
+                                       tr->tr_command->cmd_hdr.err_specific_desc);
+               twa_printf(sc, "Hard reset request failed. error = 0x%x\n", error);
+       }
+
+out:
+       if (tr)
+               twa_release_request(tr);
+       return(error);
+}
+
+#endif /* TWA_FLASH_FIRMWARE */
+
+/*
+ * Function name:      twa_init_ctlr
+ * Description:                Establishes a logical connection with the controller.
+ *                     If bundled with firmware, determines whether or not
+ *                     to flash firmware, based on arch_id, fw SRL (Spec.
+ *                     Revision Level), branch & build #'s.  Also determines
+ *                     whether or not the driver is compatible with the
+ *                     firmware on the controller, before proceeding to work
+ *                     with it.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_init_ctlr(struct twa_softc *sc)
+{
+       u_int16_t       fw_on_ctlr_srl = 0;
+       u_int16_t       fw_on_ctlr_arch_id = 0;
+       u_int16_t       fw_on_ctlr_branch = 0;
+       u_int16_t       fw_on_ctlr_build = 0;
+       u_int32_t       init_connect_result = 0;
+       int             error = 0;
+#ifdef TWA_FLASH_FIRMWARE
+       int8_t          fw_flashed = FALSE;
+       int8_t          fw_flash_failed = FALSE;
+#endif /* TWA_FLASH_FIRMWARE */
+
+       twa_dbg_dprint_enter(3, sc);
+
+       /* Wait for the controller to become ready. */
+       if (twa_wait_status(sc, TWA_STATUS_MICROCONTROLLER_READY,
+                                       TWA_REQUEST_TIMEOUT_PERIOD)) {
+               twa_printf(sc, "Microcontroller not ready.\n");
+               return(ENXIO);
+       }
+       /* Drain the response queue. */
+       if (twa_drain_response_queue(sc)) {
+               twa_printf(sc, "Can't drain response queue.\n");
+               return(1);
+       }
+       /* Establish a logical connection with the controller. */
+       if ((error = twa_init_connection(sc, TWA_INIT_MESSAGE_CREDITS,
+                       TWA_EXTENDED_INIT_CONNECT, TWA_CURRENT_FW_SRL,
+                       TWA_9000_ARCH_ID, TWA_CURRENT_FW_BRANCH,
+                       TWA_CURRENT_FW_BUILD, &fw_on_ctlr_srl,
+                       &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
+                       &fw_on_ctlr_build, &init_connect_result))) {
+               twa_printf(sc, "Can't initialize connection in current mode.\n");
+               return(error);
+       }
+
+#ifdef TWA_FLASH_FIRMWARE
+
+       if ((init_connect_result & TWA_BUNDLED_FW_SAFE_TO_FLASH) &&
+               (init_connect_result & TWA_CTLR_FW_RECOMMENDS_FLASH)) {
+               /*
+                * The bundled firmware is safe to flash, and the firmware
+                * on the controller recommends a flash.  So, flash!
+                */
+               twa_printf(sc, "Flashing bundled firmware...\n");
+               if ((error = twa_flash_firmware(sc))) {
+                       fw_flash_failed = TRUE;
+                       twa_printf(sc, "Unable to flash bundled firmware.\n");
+                       twa_printf(sc, "Will see if possible to work with firmware on controller...\n");
+               } else {
+                       twa_printf(sc, "Successfully flashed bundled firmware.\n");
+                       fw_flashed = TRUE;
+               }
+       }
+
+       if (fw_flashed) {
+               /* The firmware was flashed.  Have the new image loaded */
+               error = twa_hard_reset(sc);
+               if (error)
+                       twa_printf(sc, "Could not reset controller after flash!\n");
+               else    /* Go through initialization again. */
+                       error = twa_init_ctlr(sc);
+               /*
+                * If hard reset of controller failed, we need to return.
+                * Otherwise, the above recursive call to twa_init_ctlr will
+                * have completed the rest of the initialization (starting
+                * from twa_drain_aen_queue below).  Don't do it again.
+                * Just return.
+                */
+               return(error);
+       } else
+#endif /* TWA_FLASH_FIRMWARE */
+       {
+               /*
+                * Either we are not bundled with a firmware image, or
+                * the bundled firmware is not safe to flash,
+                * or flash failed for some reason.  See if we can at
+                * least work with the firmware on the controller in the
+                * current mode.
+                */
+               if (init_connect_result & TWA_CTLR_FW_COMPATIBLE) {
+                       /* Yes, we can.  Make note of the operating mode. */
+                       sc->working_srl = TWA_CURRENT_FW_SRL;
+                       sc->working_branch = TWA_CURRENT_FW_BRANCH;
+                       sc->working_build = TWA_CURRENT_FW_BUILD;
+               } else {
+                       /*
+                        * No, we can't.  See if we can at least work with
+                        * it in the base mode.  We should never come here
+                        * if firmware has just been flashed.
+                        */
+                       twa_printf(sc, "Driver/Firmware mismatch.  Negotiating for base level...\n");
+                       if ((error = twa_init_connection(sc, TWA_INIT_MESSAGE_CREDITS,
+                                       TWA_EXTENDED_INIT_CONNECT, TWA_BASE_FW_SRL,
+                                       TWA_9000_ARCH_ID, TWA_BASE_FW_BRANCH,
+                                       TWA_BASE_FW_BUILD, &fw_on_ctlr_srl,
+                                       &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
+                                       &fw_on_ctlr_build, &init_connect_result))) {
+                               twa_printf(sc, "Can't initialize connection in base mode.\n");
+                               return(error);
+                       }
+                       if (!(init_connect_result & TWA_CTLR_FW_COMPATIBLE)) {
+                               /*
+                                * The firmware on the controller is not even
+                                * compatible with our base mode.  We cannot
+                                * work with it.  Bail...
+                                */
+                               twa_printf(sc, "Incompatible firmware on controller\n");
+#ifdef TWA_FLASH_FIRMWARE
+                               if (fw_flash_failed)
+                                       twa_printf(sc, "...and could not flash bundled firmware.\n");
+                               else
+                                       twa_printf(sc, "...and bundled firmware not safe to flash.\n");
+#endif /* TWA_FLASH_FIRMWARE */
+                               return(1);
+                       }
+                       /* We can work with this firmware, but only in base mode. */
+                       sc->working_srl = TWA_BASE_FW_SRL;
+                       sc->working_branch = TWA_BASE_FW_BRANCH;
+                       sc->working_build = TWA_BASE_FW_BUILD;
+                       sc->twa_operating_mode = TWA_BASE_MODE;
+               }
+       }
+
+       /* Drain the AEN queue */
+       if (twa_drain_aen_queue(sc)) {
+               /* 
+                * We will just print that we couldn't drain the AEN queue.
+                * There's no need to bail out.
+                */
+               twa_printf(sc, "Can't drain AEN queue.\n");
+       }
+
+       /* Set controller state to initialized. */
+       sc->twa_state &= ~TWA_STATE_SHUTDOWN;
+
+       twa_dbg_dprint_exit(3, sc);
+       return(0);
+}
+
+
+/*
+ * Function name:      twa_deinit_ctlr
+ * Description:                Close logical connection with the controller.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_deinit_ctlr(struct twa_softc *sc)
+{
+       /*
+        * Mark the controller as shutting down,
+        * and disable any further interrupts.
+        */
+       sc->twa_state |= TWA_STATE_SHUTDOWN;
+       twa_disable_interrupts(sc);
+
+       /* Let the controller know that we are going down. */
+       return(twa_init_connection(sc, TWA_SHUTDOWN_MESSAGE_CREDITS,
+                                       0, 0, 0, 0, 0,
+                                       NULL, NULL, NULL, NULL, NULL));
+}
+
+
+/*
+ * Function name:      twa_interrupt
+ * Description:                Interrupt handler.  Determines the kind of interrupt,
+ *                     and calls the appropriate handler.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_interrupt(struct twa_softc *sc)
+{
+       u_int32_t       status_reg;
+
+       twa_dbg_dprint_enter(5, sc);
+
+       /* Collect current interrupt status. */
+       status_reg = TWA_READ_STATUS_REGISTER(sc);
+       if (twa_check_ctlr_state(sc, status_reg))
+               return;
+
+       /* Dispatch based on the kind of interrupt. */
+       if (status_reg & TWA_STATUS_HOST_INTERRUPT)
+               twa_host_intr(sc);
+       if (status_reg & TWA_STATUS_ATTENTION_INTERRUPT)
+               twa_attention_intr(sc);
+       if (status_reg & TWA_STATUS_COMMAND_INTERRUPT)
+               twa_command_intr(sc);
+       if (status_reg & TWA_STATUS_RESPONSE_INTERRUPT)
+               twa_done(sc);
+}
+
+
+/*
+ * Function name:      twa_ioctl
+ * Description:                ioctl handler.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     cmd     -- ioctl cmd
+ *                     buf     -- ptr to buffer in kernel memory, which is
+ *                                a copy of the input buffer in user-space
+ * Output:             buf     -- ptr to buffer in kernel memory, which will
+ *                                be copied of the output buffer in user-space
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_ioctl(struct twa_softc *sc, int cmd, void *buf)
+{
+       struct twa_ioctl_9k     *user_buf = (struct twa_ioctl_9k *)buf;
+       struct twa_event_packet event_buf;
+       int32_t                 event_index;
+       int32_t                 start_index;
+       int                     s;
+       int                     error = 0;
+               
+       switch (cmd) {
+       case TWA_IOCTL_FIRMWARE_PASS_THROUGH:
+       {
+               struct twa_command_packet       *cmdpkt;
+               struct twa_request              *tr;
+               u_int32_t                       data_buf_size_adjusted;
+
+
+               twa_dbg_dprint(2, sc, "Firmware PassThru");
+
+               /* Get a request packet */
+               while ((tr = twa_get_request(sc)) == NULL)
+                       /*
+                        * No free request packets available.  Sleep until
+                        * one becomes available.
+                        */
+                       tsleep(&(sc->twa_wait_timeout), PPAUSE, "twioctl", hz);
+
+               /*
+                * Make sure that the data buffer sent to firmware is a 
+                * 512 byte multiple in size.
+                */
+               data_buf_size_adjusted = (user_buf->twa_drvr_pkt.buffer_length + 511) & ~511;
+               if ((tr->tr_length = data_buf_size_adjusted)) {
+                       if ((tr->tr_data = malloc(data_buf_size_adjusted, M_DEVBUF, M_WAITOK)) == NULL) {
+                               twa_printf(sc, "Could not alloc mem for fw_passthru data_buf.\n");
+                               error = ENOMEM;
+                               goto fw_passthru_done;
+                       }
+                       /* Copy the payload. */
+                       if ((error = copyin((void *) (user_buf->pdata), 
+                                       (void *) (tr->tr_data),
+                                       user_buf->twa_drvr_pkt.buffer_length)) != 0) {
+                               twa_printf (sc, "Could not copyin fw_passthru data_buf.\n"); 
+                               goto fw_passthru_done;
+                       }
+                       tr->tr_flags |= TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
+               }
+               tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_IOCTL;
+               cmdpkt = tr->tr_command;
+
+               /* Copy the command packet. */
+               bcopy(&(user_buf->twa_cmd_pkt), cmdpkt,
+                                       sizeof(struct twa_command_packet));
+               cmdpkt->command.cmd_pkt_7k.generic.request_id = tr->tr_request_id;
+
+               twa_dbg_dprint(3, sc, "cmd_pkt_7k = %x %x %x %x %x %x %x",
+                                       cmdpkt->command.cmd_pkt_7k.generic.opcode,
+                                       cmdpkt->command.cmd_pkt_7k.generic.sgl_offset,
+                                       cmdpkt->command.cmd_pkt_7k.generic.size,
+                                       cmdpkt->command.cmd_pkt_7k.generic.request_id,
+                                       cmdpkt->command.cmd_pkt_7k.generic.unit,
+                                       cmdpkt->command.cmd_pkt_7k.generic.status,
+                                       cmdpkt->command.cmd_pkt_7k.generic.flags);
+
+               /* Send down the request, and wait for it to complete. */
+               if ((error = twa_wait_request(tr, TWA_REQUEST_TIMEOUT_PERIOD))) {
+                       twa_printf(sc, "fw_passthru request failed. error = 0x%x\n", error);
+                       if (error == ETIMEDOUT)
+                               break; /* clean-up done by twa_wait_request */
+                       goto fw_passthru_done;
+               }
+
+               /* Copy the command packet back into user space. */
+               bcopy(cmdpkt, &(user_buf->twa_cmd_pkt),
+                                       sizeof(struct twa_command_packet));
+       
+               /* If there was a payload, copy it back too. */
+               if (tr->tr_length)
+                       error = copyout(tr->tr_data, user_buf->pdata,
+                                       user_buf->twa_drvr_pkt.buffer_length);
+
+fw_passthru_done:
+               /* Free resources. */
+               if (tr->tr_data)
+                       free(tr->tr_data, M_DEVBUF);
+               if (tr)
+                       twa_release_request(tr);
+               break;
+       }
+
+
+       case TWA_IOCTL_SCAN_BUS:
+               /* Request CAM for a bus scan. */
+               twa_request_bus_scan(sc);
+               break;
+
+
+       case TWA_IOCTL_GET_FIRST_EVENT:
+               twa_dbg_dprint(3, sc, "Get First Event");
+
+               if (sc->twa_aen_queue_wrapped) {
+                       if (sc->twa_aen_queue_overflow) {
+                               /*
+                                * The aen queue has wrapped, even before some
+                                * events have been retrieved.  Let the caller
+                                * know that he missed out on some AEN's.
+                                */
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_OVERFLOW;
+                               sc->twa_aen_queue_overflow = FALSE;
+                       } else
+                               user_buf->twa_drvr_pkt.status = 0;
+                       event_index = sc->twa_aen_head;
+               } else {
+                       if (sc->twa_aen_head == sc->twa_aen_tail) {
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
+                               break;
+                       }
+                       user_buf->twa_drvr_pkt.status = 0;
+                       event_index = sc->twa_aen_tail; /* = 0 */
+               }
+               if ((error = copyout(sc->twa_aen_queue[event_index], user_buf->pdata,
+                                       sizeof(struct twa_event_packet))) != 0)
+                       twa_printf(sc, "get_first: Could not copyout to event_buf. error = %x\n", error);
+               (sc->twa_aen_queue[event_index])->retrieved = TWA_AEN_RETRIEVED;
+               break;
+
+
+       case TWA_IOCTL_GET_LAST_EVENT:
+               twa_dbg_dprint(3, sc, "Get Last Event");
+
+               if (sc->twa_aen_queue_wrapped) {
+                       if (sc->twa_aen_queue_overflow) {
+                               /*
+                                * The aen queue has wrapped, even before some
+                                * events have been retrieved.  Let the caller
+                                * know that he missed out on some AEN's.
+                                */
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_OVERFLOW;
+                               sc->twa_aen_queue_overflow = FALSE;
+                       } else
+                               user_buf->twa_drvr_pkt.status = 0;
+               } else {
+                       if (sc->twa_aen_head == sc->twa_aen_tail) {
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
+                               break;
+                       }
+                       user_buf->twa_drvr_pkt.status = 0;
+               }
+               event_index = (sc->twa_aen_head - 1 + TWA_Q_LENGTH) % TWA_Q_LENGTH;
+               if ((error = copyout(sc->twa_aen_queue[event_index], user_buf->pdata,
+                                       sizeof(struct twa_event_packet))) != 0)
+                       twa_printf(sc, "get_last: Could not copyout to event_buf. error = %x\n", error);
+               (sc->twa_aen_queue[event_index])->retrieved = TWA_AEN_RETRIEVED;
+               break;
+
+
+       case TWA_IOCTL_GET_NEXT_EVENT:
+               twa_dbg_dprint(3, sc, "Get Next Event");
+
+               user_buf->twa_drvr_pkt.status = 0;
+               if (sc->twa_aen_queue_wrapped) {
+                       twa_dbg_dprint(3, sc, "Get Next Event: wrapped");
+                       if (sc->twa_aen_queue_overflow) {
+                               /*
+                                * The aen queue has wrapped, even before some
+                                * events have been retrieved.  Let the caller
+                                * know that he missed out on some AEN's.
+                                */
+                               twa_dbg_dprint(2, sc, "Get Next Event: overflow");
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_OVERFLOW;
+                               sc->twa_aen_queue_overflow = FALSE;
+                       }
+                       start_index = sc->twa_aen_head;
+               } else {
+                       if (sc->twa_aen_head == sc->twa_aen_tail) {
+                               twa_dbg_dprint(3, sc, "Get Next Event: empty queue");
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
+                               break;
+                       }
+                       start_index = sc->twa_aen_tail; /* = 0 */
+               }
+               if ((error = copyin(user_buf->pdata, &event_buf,
+                               sizeof(struct twa_event_packet))) != 0)
+                       twa_printf(sc, "get_next: Could not copyin event_buf.\n");
+
+               event_index = (start_index + event_buf.sequence_id -
+                               (sc->twa_aen_queue[start_index])->sequence_id + 1)
+                               % TWA_Q_LENGTH;
+
+               twa_dbg_dprint(3, sc, "Get Next Event: si = %x, ei = %x, ebsi = %x, sisi = %x, eisi = %x",
+                               start_index, event_index, event_buf.sequence_id,
+                               (sc->twa_aen_queue[start_index])->sequence_id,
+                               (sc->twa_aen_queue[event_index])->sequence_id);
+
+               if (! ((sc->twa_aen_queue[event_index])->sequence_id >
+                                               event_buf.sequence_id)) {
+                       if (user_buf->twa_drvr_pkt.status == TWA_ERROR_AEN_OVERFLOW)
+                               sc->twa_aen_queue_overflow = TRUE; /* so we report the overflow next time */
+                       user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
+                       break;
+               }
+               if ((error = copyout(sc->twa_aen_queue[event_index], user_buf->pdata, 
+                                       sizeof(struct twa_event_packet))) != 0)
+                       twa_printf(sc, "get_next: Could not copyout to event_buf. error = %x\n", error);
+
+               (sc->twa_aen_queue[event_index])->retrieved = TWA_AEN_RETRIEVED;
+               break;
+
+
+       case TWA_IOCTL_GET_PREVIOUS_EVENT:
+               twa_dbg_dprint(3, sc, "Get Previous Event");
+
+               user_buf->twa_drvr_pkt.status = 0;
+               if (sc->twa_aen_queue_wrapped) {
+                       if (sc->twa_aen_queue_overflow) {
+                               /*
+                                * The aen queue has wrapped, even before some
+                                * events have been retrieved.  Let the caller
+                                * know that he missed out on some AEN's.
+                                */
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_OVERFLOW;
+                               sc->twa_aen_queue_overflow = FALSE;
+                       }
+                       start_index = sc->twa_aen_head;
+               } else {
+                       if (sc->twa_aen_head == sc->twa_aen_tail) {
+                               user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
+                               break;
+                       }
+                       start_index = sc->twa_aen_tail; /* = 0 */
+               }
+               if ((error = copyin(user_buf->pdata, &event_buf,
+                               sizeof(struct twa_event_packet))) != 0)
+                       twa_printf(sc, "get_previous: Could not copyin event_buf.\n");
+
+               event_index = (start_index + event_buf.sequence_id -
+                       (sc->twa_aen_queue[start_index])->sequence_id - 1) % TWA_Q_LENGTH;
+               if (! ((sc->twa_aen_queue[event_index])->sequence_id < event_buf.sequence_id)) {
+                       if (user_buf->twa_drvr_pkt.status == TWA_ERROR_AEN_OVERFLOW)
+                               sc->twa_aen_queue_overflow = TRUE; /* so we report the overflow next time */
+                       user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
+                       break;
+               }
+               if ((error = copyout(sc->twa_aen_queue [event_index], user_buf->pdata,
+                                       sizeof(struct twa_event_packet))) != 0)
+                       twa_printf(sc, "get_previous: Could not copyout to event_buf. error = %x\n", error);
+
+               (sc->twa_aen_queue[event_index])->retrieved = TWA_AEN_RETRIEVED;
+               break;
+
+
+       case TWA_IOCTL_GET_LOCK:
+       {
+               struct twa_lock_packet  twa_lock;
+               u_int32_t               cur_time;
+
+               cur_time = time_second - (tz.tz_minuteswest * 60) - 
+                                       (wall_cmos_clock ? adjkerntz : 0);
+               copyin(user_buf->pdata, &twa_lock,
+                               sizeof(struct twa_lock_packet));
+               s = splcam();
+               if ((sc->twa_ioctl_lock.lock == TWA_LOCK_FREE) ||
+                               (twa_lock.force_flag) ||
+                               (cur_time >= sc->twa_ioctl_lock.timeout)) {
+                       twa_dbg_dprint(3, sc, "GET_LOCK: Getting lock!");
+                       sc->twa_ioctl_lock.lock = TWA_LOCK_HELD;
+                       sc->twa_ioctl_lock.timeout = cur_time + (twa_lock.timeout_msec / 1000);
+                       twa_lock.time_remaining_msec = twa_lock.timeout_msec;
+                       user_buf->twa_drvr_pkt.status = 0;
+               } else {
+                       twa_dbg_dprint(2, sc, "GET_LOCK: Lock already held!");
+                       twa_lock.time_remaining_msec =
+                               (sc->twa_ioctl_lock.timeout - cur_time) * 1000;
+                       user_buf->twa_drvr_pkt.status =
+                                       TWA_ERROR_IOCTL_LOCK_ALREADY_HELD;
+               }
+               splx(s);
+               copyout(&twa_lock, user_buf->pdata,
+                               sizeof(struct twa_lock_packet));
+               break;
+       }
+
+
+       case TWA_IOCTL_RELEASE_LOCK:
+               s = splcam();
+               if (sc->twa_ioctl_lock.lock == TWA_LOCK_FREE) {
+                       twa_dbg_dprint(2, sc, "twa_ioctl: RELEASE_LOCK: Lock not held!");
+                       user_buf->twa_drvr_pkt.status = TWA_ERROR_IOCTL_LOCK_NOT_HELD;
+               } else {
+                       twa_dbg_dprint(3, sc, "RELEASE_LOCK: Releasing lock!");
+                       sc->twa_ioctl_lock.lock = TWA_LOCK_FREE;
+                       user_buf->twa_drvr_pkt.status = 0;
+               }
+               splx(s);
+               break;
+
+
+       case TWA_IOCTL_GET_COMPATIBILITY_INFO:
+       {
+               struct twa_compatibility_packet comp_pkt;
+
+               bcopy(TWA_DRIVER_VERSION_STRING, comp_pkt.driver_version,
+                                       sizeof(TWA_DRIVER_VERSION_STRING));
+               comp_pkt.working_srl = sc->working_srl;
+               comp_pkt.working_branch = sc->working_branch;
+               comp_pkt.working_build = sc->working_build;
+               user_buf->twa_drvr_pkt.status = 0;
+
+               /* Copy compatibility information to user space. */
+               copyout(&comp_pkt, user_buf->pdata,
+                               min(sizeof(struct twa_compatibility_packet),
+                                       user_buf->twa_drvr_pkt.buffer_length));
+               break;
+       }
+
+       default:        
+               /* Unknown opcode. */
+               error = ENOTTY;
+       }
+
+       return(error);
+}
+
+
+/*
+ * Function name:      twa_enable_interrupts
+ * Description:                Enables interrupts on the controller
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_enable_interrupts(struct twa_softc *sc)
+{
+       sc->twa_state |= TWA_STATE_INTR_ENABLED;
+       TWA_WRITE_CONTROL_REGISTER(sc,
+               TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT |
+               TWA_CONTROL_UNMASK_RESPONSE_INTERRUPT |
+               TWA_CONTROL_ENABLE_INTERRUPTS);
+}
+
+
+/*
+ * Function name:      twa_setup
+ * Description:                Disables interrupts on the controller
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_disable_interrupts(struct twa_softc *sc)
+{
+       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_DISABLE_INTERRUPTS);
+       sc->twa_state &= ~TWA_STATE_INTR_ENABLED;
+}
+
+
+
+/*
+ * Function name:      twa_get_param
+ * Description:                Get a firmware parameter.
+ *
+ * Input:              sc              -- ptr to per ctlr structure
+ *                     table_id        -- parameter table #
+ *                     param_id        -- index of the parameter in the table
+ *                     param_size      -- size of the parameter in bytes
+ *                     callback        -- ptr to function, if any, to be called
+ *                                     back on completion; NULL if no callback.
+ * Output:             None
+ * Return value:       ptr to param structure  -- success
+ *                     NULL                    -- failure
+ */
+static void *
+twa_get_param(struct twa_softc *sc, int table_id, int param_id,
+               size_t param_size, void (* callback)(struct twa_request *tr))
+{
+       struct twa_request      *tr;
+       union twa_command_7k    *cmd;
+       struct twa_param_9k     *param = NULL;
+       int                     error = ENOMEM;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       /* Get a request packet. */
+       if ((tr = twa_get_request(sc)) == NULL)
+               goto out;
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+
+       /* Allocate memory to read data into. */
+       if ((param = (struct twa_param_9k *)
+                       malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT)) == NULL)
+               goto out;
+       bzero(param, sizeof(struct twa_param_9k) - 1 + param_size);
+       tr->tr_data = param;
+       tr->tr_length = TWA_SECTOR_SIZE;
+       tr->tr_flags = TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
+
+       /* Build the cmd pkt. */
+       cmd = &(tr->tr_command->command.cmd_pkt_7k);
+
+       tr->tr_command->cmd_hdr.header_desc.size_header = 128;
+       
+       cmd->param.opcode = TWA_OP_GET_PARAM;
+       cmd->param.sgl_offset = 2;
+       cmd->param.size = 2;
+       cmd->param.request_id = tr->tr_request_id;
+       cmd->param.unit = 0;
+       cmd->param.param_count = 1;
+
+       /* Specify which parameter we need. */
+       param->table_id = table_id | TWA_9K_PARAM_DESCRIPTOR;
+       param->parameter_id = param_id;
+       param->parameter_size_bytes = param_size;
+
+       /* Submit the command. */
+       if (callback == NULL) {
+               /* There's no call back; wait till the command completes. */
+               error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
+               if (error == ETIMEDOUT)
+                       return(NULL); /* clean-up done by twa_immediate_request */
+               if (error)
+                       goto out;
+               if ((error = cmd->param.status)) {
+                       twa_printf(sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                       cmd->param.opcode,
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       tr->tr_command->cmd_hdr.status_block.error,
+                                       twa_find_msg_string(twa_error_table,
+                                               tr->tr_command->cmd_hdr.status_block.error),
+                                       tr->tr_command->cmd_hdr.err_specific_desc);
+                       goto out; /* twa_drain_complete_queue will have done the unmapping */
+               }
+               twa_release_request(tr);
+               return(param);
+       } else {
+               /* There's a call back.  Simply submit the command. */
+               tr->tr_callback = callback;
+               if ((error = twa_map_request(tr))) {
+                       twa_printf(tr->tr_sc, "%s: twa_map_request returned 0x%x\n",
+                                               __func__, error);
+                       goto out;
+               }
+               return(callback);
+       }
+
+out:
+       twa_printf(sc, "get_param failed. error = 0x%x\n", error);
+       if (param)
+               free(param, M_DEVBUF);
+       if (tr)
+               twa_release_request(tr);
+       return(NULL);
+}
+
+
+/*
+ * Function name:      twa_set_param
+ * Description:                Set a firmware parameter.
+ *
+ * Input:              sc              -- ptr to per ctlr structure
+ *                     table_id        -- parameter table #
+ *                     param_id        -- index of the parameter in the table
+ *                     param_size      -- size of the parameter in bytes
+ *                     callback        -- ptr to function, if any, to be called
+ *                                     back on completion; NULL if no callback.
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_set_param(struct twa_softc *sc, int table_id,
+                       int param_id, int param_size, void *data,
+                       void (* callback)(struct twa_request *tr))
+{
+       struct twa_request      *tr;
+       union twa_command_7k    *cmd;
+       struct twa_param_9k     *param = NULL;
+       int                     error = ENOMEM;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       /* Get a request packet. */
+       if ((tr = twa_get_request(sc)) == NULL)
+               goto out;
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+
+       /* Allocate memory to send data using. */
+       if ((param = (struct twa_param_9k *)
+                       malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT)) == NULL)
+               goto out;
+       bzero(param, sizeof(struct twa_param_9k) - 1 + param_size);
+       tr->tr_data = param;
+       tr->tr_length = TWA_SECTOR_SIZE;
+       tr->tr_flags = TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
+
+       /* Build the cmd pkt. */
+       cmd = &(tr->tr_command->command.cmd_pkt_7k);
+
+       tr->tr_command->cmd_hdr.header_desc.size_header = 128;
+
+       cmd->param.opcode = TWA_OP_SET_PARAM;
+       cmd->param.sgl_offset = 2;
+       cmd->param.size = 2;
+       cmd->param.request_id = tr->tr_request_id;
+       cmd->param.unit = 0;
+       cmd->param.param_count = 1;
+
+       /* Specify which parameter we want to set. */
+       param->table_id = table_id | TWA_9K_PARAM_DESCRIPTOR;
+       param->parameter_id = param_id;
+       param->parameter_size_bytes = param_size;
+       bcopy(data, param->data, param_size);
+
+       /* Submit the command. */
+       if (callback == NULL) {
+               /* There's no call back;  wait till the command completes. */
+               error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
+               if (error == ETIMEDOUT)
+                       return(error); /* clean-up done by twa_immediate_request */
+               if (error)
+                       goto out;
+               if ((error = cmd->param.status)) {
+                       twa_printf(sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                       cmd->param.opcode,
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       tr->tr_command->cmd_hdr.status_block.error,
+                                       twa_find_msg_string(twa_error_table,
+                                               tr->tr_command->cmd_hdr.status_block.error),
+                                       tr->tr_command->cmd_hdr.err_specific_desc);
+                       goto out; /* twa_drain_complete_queue will have done the unmapping */
+               }
+               free(param, M_DEVBUF);
+               twa_release_request(tr);
+               return(error);
+       } else {
+               /* There's a call back.  Simply submit the command. */
+               tr->tr_callback = callback;
+               if ((error = twa_map_request(tr))) {
+                       twa_printf(tr->tr_sc, "%s: twa_map_request returned 0x%x\n",
+                                               __func__, error);
+                       goto out;
+               }
+               return(0);
+       }
+
+out:
+       twa_printf(sc, "set_param failed. error = 0x%x\n", error);
+       if (param)
+               free(param, M_DEVBUF);
+       if (tr)
+               twa_release_request(tr);
+       return(error);
+}
+
+
+/*
+ * Function name:      twa_init_connection
+ * Description:                Send init_connection cmd to firmware
+ *
+ * Input:              sc              -- ptr to per ctlr structure
+ *                     message_credits -- max # of requests that we might send
+ *                                      down simultaneously.  This will be
+ *                                      typically set to 256 at init-time or
+ *                                     after a reset, and to 1 at shutdown-time
+ *                     set_features    -- indicates if we intend to use 64-bit
+ *                                     sg, also indicates if we want to do a
+ *                                     basic or an extended init_connection;
+ *
+ * Note: The following input/output parameters are valid, only in case of an
+ *             extended init_connection:
+ *
+ *                     current_fw_srl          -- srl of fw we are bundled
+ *                                             with, if any; 0 otherwise
+ *                     current_fw_arch_id      -- arch_id of fw we are bundled
+ *                                             with, if any; 0 otherwise
+ *                     current_fw_branch       -- branch # of fw we are bundled
+ *                                             with, if any; 0 otherwise
+ *                     current_fw_build        -- build # of fw we are bundled
+ *                                             with, if any; 0 otherwise
+ * Output:             fw_on_ctlr_srl          -- srl of fw on ctlr
+ *                     fw_on_ctlr_arch_id      -- arch_id of fw on ctlr
+ *                     fw_on_ctlr_branch       -- branch # of fw on ctlr
+ *                     fw_on_ctlr_build        -- build # of fw on ctlr
+ *                     init_connect_result     -- result bitmap of fw response
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_init_connection(struct twa_softc *sc, u_int16_t message_credits,
+                       u_int32_t set_features, u_int16_t current_fw_srl,
+                       u_int16_t current_fw_arch_id, u_int16_t current_fw_branch,
+                       u_int16_t current_fw_build, u_int16_t *fw_on_ctlr_srl,
+                       u_int16_t *fw_on_ctlr_arch_id, u_int16_t *fw_on_ctlr_branch,
+                       u_int16_t *fw_on_ctlr_build, u_int32_t *init_connect_result)
+{
+       struct twa_request              *tr;
+       struct twa_command_init_connect *init_connect;
+       int                             error = 1;
+    
+       twa_dbg_dprint_enter(3, sc);
+
+       /* Get a request packet. */
+       if ((tr = twa_get_request(sc)) == NULL)
+               goto out;
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+       /* Build the cmd pkt. */
+       init_connect = &(tr->tr_command->command.cmd_pkt_7k.init_connect);
+
+       tr->tr_command->cmd_hdr.header_desc.size_header = 128;
+
+       init_connect->opcode = TWA_OP_INIT_CONNECTION;
+       init_connect->request_id = tr->tr_request_id;
+       init_connect->message_credits = message_credits;
+       init_connect->features = set_features;
+       if (TWA_64BIT_ADDRESSES)
+               init_connect->features |= TWA_64BIT_SG_ADDRESSES;
+       if (set_features & TWA_EXTENDED_INIT_CONNECT) {
+               /* Fill in the extra fields needed for an extended init_connect. */
+               init_connect->size = 6;
+               init_connect->fw_srl = current_fw_srl;
+               init_connect->fw_arch_id = current_fw_arch_id;
+               init_connect->fw_branch = current_fw_branch;
+               init_connect->fw_build = current_fw_build;
+       } else
+               init_connect->size = 3;
+
+       /* Submit the command, and wait for it to complete. */
+       error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
+       if (error == ETIMEDOUT)
+               return(error); /* clean-up done by twa_immediate_request */
+       if (error)
+               goto out;
+       if ((error = init_connect->status)) {
+               twa_printf(sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                       init_connect->opcode,
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       tr->tr_command->cmd_hdr.status_block.error,
+                                       twa_find_msg_string(twa_error_table,
+                                               tr->tr_command->cmd_hdr.status_block.error),
+                                       tr->tr_command->cmd_hdr.err_specific_desc);
+               goto out; /* twa_drain_complete_queue will have done the unmapping */
+       }
+       if (set_features & TWA_EXTENDED_INIT_CONNECT) {
+               *fw_on_ctlr_srl = init_connect->fw_srl;
+               *fw_on_ctlr_arch_id = init_connect->fw_arch_id;
+               *fw_on_ctlr_branch = init_connect->fw_branch;
+               *fw_on_ctlr_build = init_connect->fw_build;
+               *init_connect_result = init_connect->result;
+       }
+       twa_release_request(tr);
+       return(error);
+
+out:
+       twa_printf(sc, "init_connection failed. error = 0x%x\n", error);
+       if (tr)
+               twa_release_request(tr);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_wait_request
+ * Description:                Sends down a firmware cmd, and waits for the completion,
+ *                     but NOT in a tight loop.
+ *
+ * Input:              tr      -- ptr to request pkt
+ *                     timeout -- max # of seconds to wait before giving up
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_wait_request(struct twa_request *tr, u_int32_t timeout)
+{
+       time_t  end_time;
+       int     error;
+
+       twa_dbg_dprint_enter(4, tr->tr_sc);
+
+       tr->tr_flags |= TWA_CMD_SLEEP_ON_REQUEST;
+       tr->tr_status = TWA_CMD_BUSY;
+       if ((error = twa_map_request(tr))) {
+               twa_printf(tr->tr_sc, "%s: twa_map_request returned 0x%x\n",
+                                               __func__, error);
+               return(error);
+       }
+
+       end_time = time_second + timeout;
+       while (tr->tr_status != TWA_CMD_COMPLETE) {
+               if ((error = tr->tr_error))
+                       return(error);
+               if ((error = tsleep(tr, 0, "twawait", timeout * hz)) == 0) {
+                       error = (tr->tr_status != TWA_CMD_COMPLETE);
+                       break;
+               }
+               if (error == EWOULDBLOCK) {
+                       /* Time out! */
+                       twa_printf(tr->tr_sc, "%s: Request %p timed out.\n",
+                                                               __func__, tr);
+                       /*
+                        * We will reset the controller only if the request has
+                        * already been submitted, so as to not lose the
+                        * request packet.  If a busy request timed out, the
+                        * reset will take care of freeing resources.  If a
+                        * pending request timed out, we will free resources
+                        * for that request, right here.  So, the caller is
+                        * expected to NOT cleanup when ETIMEDOUT is returned.
+                        */
+                       if (tr->tr_status != TWA_CMD_PENDING)
+                               twa_reset(tr->tr_sc);
+                       else {
+                               /* Request was never submitted.  Clean up. */
+                               twa_remove_pending(tr);
+                               twa_unmap_request(tr);
+                               if (tr->tr_data)
+                                       free(tr->tr_data, M_DEVBUF);
+                               twa_release_request(tr);
+                       }
+                       return(ETIMEDOUT);
+               }
+               /* 
+                * Either the request got completed, or we were woken up by a
+                * signal.  Calculate the new timeout, in case it was the latter.
+                */
+               timeout = (end_time - time_second);
+       }
+       twa_unmap_request(tr);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_immediate_request
+ * Description:                Sends down a firmware cmd, and waits for the completion
+ *                     in a tight loop.
+ *
+ * Input:              tr      -- ptr to request pkt
+ *                     timeout -- max # of seconds to wait before giving up
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_immediate_request(struct twa_request *tr, u_int32_t timeout)
+{
+       time_t  end_time;
+       int     error = 0;
+
+       twa_dbg_dprint_enter(4, tr->tr_sc);
+
+       if ((error = twa_map_request(tr))) {
+               twa_printf(tr->tr_sc, "%s: twa_map_request returned 0x%x\n",
+                                               __func__, error);
+               return(error);
+       }
+
+       end_time = time_second + timeout;
+       do {
+               if ((error = tr->tr_error))
+                       return(error);
+               twa_done(tr->tr_sc);
+               if ((tr->tr_status != TWA_CMD_BUSY) &&
+                       (tr->tr_status != TWA_CMD_PENDING)) {
+                       twa_unmap_request(tr);
+                       return(tr->tr_status != TWA_CMD_COMPLETE);
+               }
+       } while (time_second <= end_time);
+
+       /* Time out! */
+       twa_printf(tr->tr_sc, "%s: Request %p timed out.\n", __func__, tr);
+       /*
+        * We will reset the controller only if the request has
+        * already been submitted, so as to not lose the
+        * request packet.  If a busy request timed out, the
+        * reset will take care of freeing resources.  If a
+        * pending request timed out, we will free resources
+        * for that request, right here.  So, the caller is
+        * expected to NOT cleanup when ETIMEDOUT is returned.
+        */
+       if (tr->tr_status != TWA_CMD_PENDING)
+               twa_reset(tr->tr_sc);
+       else {
+               /* Request was never submitted.  Clean up. */
+               twa_remove_pending(tr);
+               twa_unmap_request(tr);
+               if (tr->tr_data)
+                       free(tr->tr_data, M_DEVBUF);
+               twa_release_request(tr);
+       }
+       return(ETIMEDOUT);
+}
+
+
+
+/*
+ * Function name:      twa_complete_io
+ * Description:                Callback on scsi requests to fw.
+ *
+ * Input:              tr      -- ptr to request pkt
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_complete_io(struct twa_request *tr)
+{
+       struct twa_softc        *sc = tr->tr_sc;
+
+       twa_dbg_dprint_enter(8, sc);
+
+       if (tr->tr_status != TWA_CMD_COMPLETE)
+               twa_panic(sc, "twa_complete_io on incomplete command");
+       if (tr->tr_private) /* This is a scsi cmd.  Complete it. */
+               twa_scsi_complete(tr);
+       twa_release_request(tr);
+}
+
+
+/*
+ * Function name:      twa_reset
+ * Description:                Soft resets and then initializes the controller;
+ *                     drains any incomplete requests.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_reset(struct twa_softc *sc)
+{
+       int     s;
+       int     error = 0;
+
+       twa_dbg_dprint_enter(2, sc);
+
+       /*
+        * Disable interrupts from the controller, and mask any
+        * accidental entry into our interrupt handler.
+        */
+       twa_disable_interrupts(sc);
+       s = splcam();
+       
+       /* Soft reset the controller. */
+       if ((error = twa_soft_reset(sc))) {
+               twa_printf (sc, "Controller reset failed.\n");
+               goto out;
+       }
+
+       /* Re-establish logical connection with the controller. */
+       if ((error = twa_init_connection(sc, TWA_INIT_MESSAGE_CREDITS,
+                                       0, 0, 0, 0, 0,
+                                       NULL, NULL, NULL, NULL, NULL))) {
+               twa_printf(sc, "Can't initialize connection after reset.\n");
+               goto out;
+       }
+
+       twa_printf(sc, "Controller reset done!\n");
+
+       /*
+        * Complete all requests in the complete queue; error back all requests
+        * in the busy queue.  Any internal requests will be simply freed.
+        * Re-submit any requests in the pending queue.
+        */
+       twa_drain_complete_queue(sc);
+       twa_drain_busy_queue(sc);
+
+out:
+       splx(s);
+       /*
+        * Enable interrupts, and also clear attention and response interrupts.
+        */
+       twa_enable_interrupts(sc);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_soft_reset
+ * Description:                Does the actual soft reset.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_soft_reset(struct twa_softc *sc)
+{
+       u_int32_t       status_reg;
+
+       twa_dbg_dprint_enter(1, sc);
+
+       twa_printf(sc, "Resetting controller...\n");
+       TWA_SOFT_RESET(sc);
+
+       if (twa_wait_status(sc, TWA_STATUS_MICROCONTROLLER_READY |
+                               TWA_STATUS_ATTENTION_INTERRUPT, 30)) {
+               twa_printf(sc, "Micro-ctlr not ready/No attn intr after reset.\n");
+               return(1);
+       }
+       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT);
+       if (twa_drain_response_queue(sc)) {
+               twa_printf(sc, "Can't drain response queue.\n");
+               return(1);
+       }
+       if (twa_drain_aen_queue(sc)) {
+               twa_printf(sc, "Can't drain AEN queue.\n");
+               return(1);
+       }
+       if (twa_find_aen(sc, TWA_AEN_SOFT_RESET)) {
+               twa_printf(sc, "Reset not reported by controller.\n");
+               return(1);
+       }
+       status_reg = TWA_READ_STATUS_REGISTER(sc);
+       if (TWA_STATUS_ERRORS(status_reg) ||
+                               twa_check_ctlr_state(sc, status_reg)) {
+               twa_printf(sc, "Controller errors detected.\n");
+               return(1);
+       }
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_submit_io
+ * Description:                Wrapper to twa_start.
+ *
+ * Input:              tr      -- ptr to request pkt
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_submit_io(struct twa_request *tr)
+{
+       int     error;
+
+       if ((error = twa_start(tr))) {
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) {
+                       if (error == EBUSY)
+                               /*
+                                * Cmd queue is full.  Freeze the simq to
+                                * maintain ccb ordering.  The next ccb that
+                                * gets completed will unfreeze the simq.
+                                */
+                               twa_disallow_new_requests(tr->tr_sc);
+                       else
+                               /* It's a controller error. */
+                               twa_printf(tr->tr_sc, "SCSI cmd = 0x%x: ERROR: (0x%02X: 0x%04X)\n",
+                                       tr->tr_command->command.cmd_pkt_9k.cdb[0],
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                       error);
+                       
+                       tr->tr_error = error;
+                       twa_scsi_complete(tr);
+               } else {
+                       if (error == EBUSY)
+                               error = 0; /* the request will be in the pending queue */
+                       else {
+                               twa_printf(tr->tr_sc, "cmd = 0x%x: ERROR: (0x%02X: 0x%04X)\n",
+                                               (tr->tr_cmd_pkt_type == TWA_CMD_PKT_TYPE_9K) ?
+                                               (tr->tr_command->command.cmd_pkt_9k.command.opcode) :
+                                               (tr->tr_command->command.cmd_pkt_7k.generic.opcode),
+                                               TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                               tr->tr_error);
+                               tr->tr_error = error;
+                       }
+               }
+       }
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_start
+ * Description:                Posts a cmd to firmware.
+ *
+ * Input:              tr      -- ptr to request pkt
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_start(struct twa_request *tr)
+{
+       struct twa_softc        *sc = tr->tr_sc;
+       u_int32_t               status_reg;
+       int                     s;
+       int                     error;
+
+       twa_dbg_dprint_enter(10, sc);
+
+       s = splcam();
+       /* Check to see if we can post a command. */
+       status_reg = TWA_READ_STATUS_REGISTER(sc);
+       if ((error = twa_check_ctlr_state(sc, status_reg)))
+               goto out;
+
+       if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) {
+               if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ||
+                       (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_IOCTL)) {
+                       if (tr->tr_status != TWA_CMD_PENDING) {
+                               twa_dbg_dprint(2, sc, "pending internal/ioctl request");
+                               tr->tr_status = TWA_CMD_PENDING;
+                               twa_enqueue_pending(tr);
+                       }
+                       TWA_WRITE_CONTROL_REGISTER(sc,
+                                       TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
+               }
+               error = EBUSY;
+       } else {
+               /* Cmd queue is not full.  Post the command. */
+               TWA_WRITE_COMMAND_QUEUE(sc,
+                       tr->tr_cmd_phys + sizeof(struct twa_command_header));
+               /* Mark the request as currently being processed. */
+               tr->tr_status = TWA_CMD_BUSY;
+               /* Move the request into the busy queue. */
+               twa_enqueue_busy(tr);
+       }
+
+out:
+       splx(s);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_done
+ * Description:                Looks for cmd completions from fw; queues cmds completed
+ *                     by fw into complete queue.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- no ctlr error
+ *                     non-zero-- ctlr error
+ */
+static int
+twa_done(struct twa_softc *sc)
+{
+       union twa_response_queue        rq;
+       struct twa_request              *tr;
+       int                             s;
+       int                             error = 0;
+       u_int32_t                       status_reg;
+    
+       twa_dbg_dprint_enter(10, sc);
+
+       s = splcam();
+       for (;;) {
+               status_reg = TWA_READ_STATUS_REGISTER(sc);
+               if ((error = twa_check_ctlr_state(sc, status_reg)))
+                       break;
+               if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
+                       break;
+               /* Response queue is not empty. */
+               rq = TWA_READ_RESPONSE_QUEUE(sc);
+               tr = sc->twa_lookup[rq.u.response_id];  /* lookup the request */
+               if (tr->tr_status != TWA_CMD_BUSY)
+                       twa_printf(sc, "ERROR: Unposted command completed!! req = %p; status = %d\n",
+                                       tr, tr->tr_status);
+               tr->tr_status = TWA_CMD_COMPLETE;
+               /* Enqueue request in the complete queue. */
+               twa_remove_busy(tr);
+               twa_enqueue_complete(tr);
+       }
+       splx(s);
+
+       /* Complete this, and other requests in the complete queue. */
+       twa_drain_complete_queue(sc);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_drain_pending_queue
+ * Description:                Kick starts any requests in the pending queue.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- all pending requests drained
+ *                     non-zero-- otherwise
+ */
+static int
+twa_drain_pending_queue(struct twa_softc *sc)
+{
+       struct twa_request      *tr;
+       int                     error = 0;
+    
+       twa_dbg_dprint_enter(10, sc);
+       
+       /*
+        * Pull requests off the pending queue, and submit them.
+        */
+       while ((tr = twa_dequeue_pending(sc)) != NULL) {
+               if ((error = twa_start(tr))) {
+                       if (error == EBUSY) {
+                               twa_dbg_dprint(2, sc, "Requeueing pending request");
+                               tr->tr_status = TWA_CMD_PENDING;
+                               twa_requeue_pending(tr);/* queue at the head */
+                               break;
+                       } else {
+                               twa_printf(sc, "%s: twa_start returned 0x%x\n",
+                                                       __func__, error);
+                               if (tr->tr_flags & TWA_CMD_SLEEP_ON_REQUEST)
+                                       wakeup_one(tr);/* let the caller know it failed */
+                               tr->tr_error = error;
+                               error = 0;
+                       }
+               }
+       }
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_drain_complete_queue
+ * Description:                Does unmapping for each request completed by fw,
+ *                     and lets the request originators know of the completion.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_drain_complete_queue(struct twa_softc *sc)
+{
+       struct twa_request      *tr;
+    
+       twa_dbg_dprint_enter(10, sc);
+
+       /*
+        * Pull commands off the completed list, dispatch them appropriately.
+        */
+       while ((tr = twa_dequeue_complete(sc)) != NULL) {
+               /* Unmap the command packet, and any associated data buffer. */
+               twa_unmap_request(tr);
+
+               /* Call the callback, if there's one. */
+               if (tr->tr_callback)
+                       tr->tr_callback(tr);
+               else
+                       if (tr->tr_flags & TWA_CMD_SLEEP_ON_REQUEST) {
+                               /* Wake up the sleeping command originator. */
+                               twa_dbg_dprint(7, sc, "Waking up originator of request %p", tr);
+                               wakeup_one(tr);
+                       }
+       }
+}
+
+
+
+/*
+ * Function name:      twa_wait_status
+ * Description:                Wait for a given status to show up in the fw status register.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     status  -- status to look for
+ *                     timeout -- max # of seconds to wait before giving up
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_wait_status(struct twa_softc *sc, u_int32_t status, u_int32_t timeout)
+{
+       time_t          end_time;
+       u_int32_t       status_reg;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       end_time = time_second + timeout;
+       do {
+               status_reg = TWA_READ_STATUS_REGISTER(sc);
+               if ((status_reg & status) == status)/* got the required bit(s)? */
+                       return(0);
+               DELAY(100000);
+       } while (time_second <= end_time);
+
+       return(1);
+}
+
+
+
+/*
+ * Function name:      twa_drain_response_queue
+ * Description:                Drain the response queue.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_drain_response_queue(struct twa_softc *sc)
+{
+       union twa_response_queue        rq;
+       u_int32_t                       status_reg;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       for (;;) {
+               status_reg = TWA_READ_STATUS_REGISTER(sc);
+               if (twa_check_ctlr_state(sc, status_reg))
+                       return(1);
+               if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
+                       return(0); /* no more response queue entries */
+               rq = TWA_READ_RESPONSE_QUEUE(sc);
+       }
+}
+
+
+
+/*
+ * Function name:      twa_host_intr
+ * Description:                This function gets called if we triggered an interrupt.
+ *                     We don't use it as of now.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_host_intr(struct twa_softc *sc)
+{
+       twa_dbg_dprint_enter(6, sc);
+
+       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_HOST_INTERRUPT);
+}
+
+
+
+/*
+ * Function name:      twa_attention_intr
+ * Description:                This function gets called if the fw posted an AEN
+ *                     (Asynchronous Event Notification).  It fetches
+ *                     all the AEN's that the fw might have posted.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_attention_intr(struct twa_softc *sc)
+{
+       int     error;
+
+       twa_dbg_dprint_enter(6, sc);
+
+       if ((error = twa_fetch_aen(sc)))
+               twa_printf(sc, "Fetch AEN failed. error = 0x%x\n", error);
+       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT);
+}
+
+
+
+/*
+ * Function name:      twa_command_intr
+ * Description:                This function gets called if we hit a queue full
+ *                     condition earlier, and the fw is now ready for
+ *                     new cmds.  Submits any pending requests.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_command_intr(struct twa_softc *sc)
+{
+       twa_dbg_dprint_enter(6, sc);
+
+       /* Start any requests that might be in the pending queue. */
+       if (! twa_drain_pending_queue(sc))
+               TWA_WRITE_CONTROL_REGISTER(sc,
+                               TWA_CONTROL_MASK_COMMAND_INTERRUPT);
+}
+
+
+
+/*
+ * Function name:      twa_fetch_aen
+ * Description:                Send down a Request Sense cmd to fw to fetch an AEN.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_fetch_aen(struct twa_softc *sc)
+{
+       struct twa_request      *tr;
+       int                     error = 0;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       if ((tr = twa_get_request(sc)) == NULL)
+               return(EIO);
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+       tr->tr_callback = twa_aen_callback;
+       if ((error = twa_send_scsi_cmd(tr, 0x03 /* REQUEST_SENSE */))) {
+               if (tr->tr_data)
+                       free(tr->tr_data, M_DEVBUF);
+               twa_release_request(tr);
+       }
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_aen_callback
+ * Description:                Callback for requests to fetch AEN's.
+ *
+ * Input:              tr      -- ptr to completed request pkt
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_aen_callback(struct twa_request *tr)
+{
+       struct twa_softc                *sc = tr->tr_sc;
+       struct twa_command_header       *cmd_hdr = (struct twa_command_header *)(tr->tr_data);
+       struct twa_command_9k           *cmd = &(tr->tr_command->command.cmd_pkt_9k);
+       int                             i;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       twa_dbg_dprint(4, sc, "req_id = 0x%x, status = 0x%x",
+                               cmd->request_id,
+                               cmd->status);
+
+       if (! cmd->status) {
+               if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) &&
+                       (cmd->cdb[0] == 0x3 /* REQUEST_SENSE */))
+                       twa_enqueue_aen(sc, cmd_hdr);
+       } else {
+               cmd_hdr->err_specific_desc[sizeof(cmd_hdr->err_specific_desc) - 1] = '\0';
+               twa_printf(sc, "%s: cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                               __func__, cmd->command.opcode,
+                               TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                               cmd_hdr->status_block.error,
+                               twa_find_msg_string(twa_error_table,
+                                               cmd_hdr->status_block.error),
+                               cmd_hdr->err_specific_desc);
+               twa_dbg_print(2, "sense info: ");
+               for (i = 0; i < 18; i++)
+                       twa_dbg_print(2, "%x\t", tr->tr_command->cmd_hdr.sense_data[i]);
+               twa_dbg_print(2, ""); /* print new line */
+               for (i = 0; i < 128; i++)
+                       twa_dbg_print(7, "%x\t", ((int8_t *)(tr->tr_data))[i]);
+       }
+
+       if (tr->tr_data)
+               free(tr->tr_data, M_DEVBUF);
+       twa_release_request(tr);
+}
+
+
+
+/*
+ * Function name:      twa_drain_aen_queue
+ * Description:                Fetches all un-retrieved AEN's posted by fw.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_drain_aen_queue(struct twa_softc *sc)
+{
+       struct twa_request              *tr;
+       struct twa_command_header       *cmd_hdr;
+       time_t                          end_time;
+       int                             error = 0;
+
+       for (;;) {
+               if ((tr = twa_get_request(sc)) == NULL) {
+                       error = EIO;
+                       break;
+               }
+               tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
+               tr->tr_callback = NULL;
+               if ((error = twa_send_scsi_cmd(tr, 0x03 /* REQUEST_SENSE */))) {
+                       twa_dbg_dprint(1, sc, "Cannot send command to fetch aen");
+                       break;
+               }
+
+               end_time = time_second + TWA_REQUEST_TIMEOUT_PERIOD;
+               do {
+                       twa_done(tr->tr_sc);
+                       if (tr->tr_status != TWA_CMD_BUSY)
+                               break;
+               } while (time_second <= end_time);
+
+               if (tr->tr_status != TWA_CMD_COMPLETE) {
+                       error = ETIMEDOUT;
+                       break;
+               }
+
+               if ((error = tr->tr_command->command.cmd_pkt_9k.status))
+                       break;
+
+               cmd_hdr = (struct twa_command_header *)(tr->tr_data);
+               if ((cmd_hdr->status_block.error) /* aen_code */
+                               == TWA_AEN_QUEUE_EMPTY)
+                       break;
+               twa_enqueue_aen(sc, cmd_hdr);
+
+               free(tr->tr_data, M_DEVBUF);
+               twa_release_request(tr);
+       }
+
+       if (tr) {
+               if (tr->tr_data)
+                       free(tr->tr_data, M_DEVBUF);
+               twa_release_request(tr);
+       }
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_enqueue_aen
+ * Description:                Queues AEN's to be supplied to user-space tools on request.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     cmd_hdr -- ptr to hdr of fw cmd pkt, from where the AEN
+ *                                details can be retrieved.
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_enqueue_aen(struct twa_softc *sc, struct twa_command_header *cmd_hdr)
+{
+       struct twa_event_packet *event;
+       unsigned short          aen_code;
+       unsigned long           local_time;
+       unsigned long           sync_time;
+       int                     s;
+
+       twa_dbg_dprint_enter(4, sc);
+       s = splcam();
+       aen_code = cmd_hdr->status_block.error;
+
+       switch (aen_code) {
+       case TWA_AEN_SYNC_TIME_WITH_HOST:
+               twa_dbg_dprint(4, sc, "Received AEN_SYNC_TIME");
+               /* Calculate time (in seconds) since last Sunday 12.00 AM. */
+               local_time = time_second - (tz.tz_minuteswest * 60) -
+                                       (wall_cmos_clock ? adjkerntz : 0);
+               sync_time = (local_time - (3 * 86400)) % 604800;
+               if (twa_set_param(sc, TWA_PARAM_TIME_TABLE,
+                                       TWA_PARAM_TIME_SchedulerTime, 4,
+                                       &sync_time, twa_aen_callback))
+                       twa_printf(sc, "Unable to sync time with ctlr!\n");
+               break;
+
+       case TWA_AEN_QUEUE_EMPTY:
+               twa_dbg_dprint(4, sc, "AEN queue empty");
+               break;
+
+       default:
+               /* Queue the event. */
+               event = sc->twa_aen_queue[sc->twa_aen_head];
+               if (event->retrieved == TWA_AEN_NOT_RETRIEVED)
+                       sc->twa_aen_queue_overflow = TRUE;
+               event->severity = cmd_hdr->status_block.substatus_block.severity;
+               local_time = time_second - (tz.tz_minuteswest * 60) -
+                                       (wall_cmos_clock ? adjkerntz : 0);
+               event->time_stamp_sec = local_time;
+               event->aen_code = aen_code;
+               event->retrieved = TWA_AEN_NOT_RETRIEVED;
+               event->sequence_id = ++(sc->twa_current_sequence_id);
+               cmd_hdr->err_specific_desc[sizeof(cmd_hdr->err_specific_desc) - 1] = '\0';
+               event->parameter_len = strlen(cmd_hdr->err_specific_desc);
+               bcopy(cmd_hdr->err_specific_desc, event->parameter_data,
+                                       event->parameter_len);
+
+               twa_dbg_dprint(4, sc, "event = %x %x %x %x %x %x %x\n %s",
+                               event->sequence_id,
+                               event->time_stamp_sec,
+                               event->aen_code,
+                               event->severity,
+                               event->retrieved,
+                               event->repeat_count,
+                               event->parameter_len,
+                               event->parameter_data);
+
+               twa_dbg_dprint(4, sc, "cmd_hdr = %x %lx %x %x %x %x %x\n %s",
+                               sc->twa_current_sequence_id,
+                               local_time,
+                               cmd_hdr->status_block.error,
+                               cmd_hdr->status_block.substatus_block.severity,
+                               TWA_AEN_NOT_RETRIEVED,
+                               0,
+                               strlen(cmd_hdr->err_specific_desc),
+                               cmd_hdr->err_specific_desc);
+
+               /* Print the event. */
+               if (event->severity < TWA_AEN_SEVERITY_DEBUG)
+                       twa_printf(sc,  "%s: (0x%02X: 0x%04X): %s: %s\n",
+                                       twa_aen_severity_table[event->severity],
+                                       TWA_MESSAGE_SOURCE_CONTROLLER_EVENT,
+                                       aen_code,
+                                       twa_find_msg_string(twa_aen_table, aen_code),
+                                       event->parameter_data);
+
+               if ((sc->twa_aen_head + 1) == TWA_Q_LENGTH)
+                       sc->twa_aen_queue_wrapped = TRUE;
+               sc->twa_aen_head = (sc->twa_aen_head + 1) % TWA_Q_LENGTH;
+               break;
+       } /* switch */
+       splx(s);
+}
+
+
+
+/*
+ * Function name:      twa_find_aen
+ * Description:                Reports whether a given AEN ever occurred.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     aen_code-- AEN to look for
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_find_aen(struct twa_softc *sc, u_int16_t aen_code)
+{
+       u_int32_t       last_index;
+       int             s;
+       int             i;
+
+       s = splcam();
+
+       if (sc->twa_aen_queue_wrapped)
+               last_index = sc->twa_aen_head;
+       else
+               last_index = 0;
+
+       i = sc->twa_aen_head;
+       do {
+               i = (i + TWA_Q_LENGTH - 1) % TWA_Q_LENGTH;
+               if ((sc->twa_aen_queue[i])->aen_code == aen_code) {
+                       splx(s);
+                       return(0);
+               }
+       } while (i != last_index);
+
+       splx(s);
+       return(1);
+}
+
+
+
+/*
+ * Function name:      twa_find_msg_string
+ * Description:                Looks up a given table, and returns the message string
+ *                     corresponding to a given code (error code or AEN code).
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     code    -- code, the message string corresponding to
+ *                                which is to be returned.
+ * Output:             None
+ * Return value:       ptr to corresponding msg string -- success
+ *                     NULL                            -- failure
+ */
+char *
+twa_find_msg_string(struct twa_message *table, u_int16_t code)
+{
+       int     i;
+
+       for (i = 0; table[i].message != NULL; i++)
+               if (table[i].code == code)
+                       return(table[i].message);
+
+       return(table[i].message);
+}
+
+
+
+/*
+ * Function name:      twa_get_request
+ * Description:                Gets a request pkt from the free queue.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       ptr to request pkt      -- success
+ *                     NULL                    -- failure
+ */
+struct twa_request *
+twa_get_request(struct twa_softc *sc)
+{
+       struct twa_request      *tr;
+
+       twa_dbg_dprint_enter(4, sc);
+
+       /* Get a free request packet. */
+       tr = twa_dequeue_free(sc);
+
+       /* Initialize some fields to their defaults. */
+       if (tr) {
+               tr->tr_data = NULL;
+               tr->tr_real_data = NULL;
+               tr->tr_length = 0;
+               tr->tr_real_length = 0;
+               tr->tr_status = TWA_CMD_SETUP;/* command is in setup phase */
+               tr->tr_flags = 0;
+               tr->tr_error = 0;
+               tr->tr_private = NULL;
+               tr->tr_callback = NULL;
+               tr->tr_cmd_pkt_type = 0;
+
+               /*
+                * Look at the status field in the command packet to see how
+                * it completed the last time it was used, and zero out only
+                * the portions that might have changed.  Note that we don't
+                * care to zero out the sglist.
+                */
+               if (tr->tr_command->command.cmd_pkt_9k.status)
+                       bzero(tr->tr_command,
+                               sizeof(struct twa_command_header) + 28 /* max bytes before sglist */);
+               else
+                       bzero(&(tr->tr_command->command), 28 /* max bytes before sglist */);
+       }
+       return(tr);
+}
+
+
+
+/*
+ * Function name:      twa_release_request
+ * Description:                Puts a request pkt into the free queue.
+ *
+ * Input:              tr      -- ptr to request pkt to be freed
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_release_request(struct twa_request *tr)
+{
+       twa_dbg_dprint_enter(4, tr->tr_sc);
+
+       twa_enqueue_free(tr);
+}
+
+
+
+/*
+ * Function name:      twa_describe_controller
+ * Description:                Describes the controller, in terms of its fw version,
+ *                     BIOS version etc.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_describe_controller(struct twa_softc *sc)
+{
+       struct twa_param_9k     *p[6];
+       u_int8_t                num_ports = 0;
+
+       twa_dbg_dprint_enter(2, sc);
+
+       /* Get the port count. */
+       p[0] = twa_get_param(sc, TWA_PARAM_CONTROLLER_TABLE,
+                               TWA_PARAM_CONTROLLER_PORT_COUNT, 1, NULL);
+       if (p[0]) {
+               num_ports = *(u_int8_t *)(p[0]->data);
+               free(p[0], M_DEVBUF);
+       }
+
+       /* Get the firmware and BIOS versions. */
+       p[0] = twa_get_param(sc, TWA_PARAM_VERSION_TABLE,
+                               TWA_PARAM_VERSION_FW, 16, NULL);
+       p[1] = twa_get_param(sc, TWA_PARAM_VERSION_TABLE,
+                               TWA_PARAM_VERSION_BIOS, 16, NULL);
+
+       twa_printf(sc, "%d ports, Firmware %.16s, BIOS %.16s\n",
+                       num_ports, p[0]?(p[0]->data):NULL, p[1]?(p[1]->data):NULL);
+       if (bootverbose) {
+               /* Get more versions. */
+               p[2] = twa_get_param(sc, TWA_PARAM_VERSION_TABLE,
+                                       TWA_PARAM_VERSION_MONITOR, 16, NULL);
+               p[3] = twa_get_param(sc, TWA_PARAM_VERSION_TABLE,
+                                       TWA_PARAM_VERSION_PCBA, 8, NULL);
+               p[4] = twa_get_param(sc, TWA_PARAM_VERSION_TABLE,
+                                       TWA_PARAM_VERSION_ATA, 8, NULL);
+               p[5] = twa_get_param(sc, TWA_PARAM_VERSION_TABLE,
+                                       TWA_PARAM_VERSION_PCI, 8, NULL);
+
+               twa_printf(sc, "Monitor %.16s, PCB %.8s, Achip %.8s, Pchip %.8s\n",
+                               p[2]?(p[2]->data):NULL, p[3]?(p[3]->data):NULL,
+                               p[4]?(p[4]->data):NULL, p[5]?(p[5]->data):NULL);
+
+               if (p[2])
+                       free(p[2], M_DEVBUF);
+               if (p[3])
+                       free(p[3], M_DEVBUF);
+               if (p[4])
+                       free(p[4], M_DEVBUF);
+               if (p[5])
+                       free(p[5], M_DEVBUF);
+       }
+       if (p[0])
+               free(p[0], M_DEVBUF);
+       if (p[1])
+               free(p[1], M_DEVBUF);
+}
+
+
+
+/*
+ * Function name:      twa_check_ctlr_state
+ * Description:                Makes sure that the fw status register reports a
+ *                     proper status.
+ *
+ * Input:              sc              -- ptr to per ctlr structure
+ *                     status_reg      -- value in the status register
+ * Output:             None
+ * Return value:       0       -- no errors
+ *                     non-zero-- errors
+ */
+static int
+twa_check_ctlr_state(struct twa_softc *sc, u_int32_t status_reg)
+{
+       int             result = 0;
+       static time_t   last_warning[2] = {0, 0};
+
+       /* Check if the 'micro-controller ready' bit is not set. */
+       if ((status_reg & TWA_STATUS_EXPECTED_BITS) !=
+                               TWA_STATUS_EXPECTED_BITS) {
+               if (time_second > (last_warning[0] + 5)) {
+                       twa_printf(sc, "Missing expected status bit(s) %b\n",
+                                       ~status_reg & TWA_STATUS_EXPECTED_BITS,
+                                       TWA_STATUS_BITS_DESCRIPTION);
+                       last_warning[0] = time_second;
+               }
+               result = 1;
+       }
+
+       /* Check if any error bits are set. */
+       if ((status_reg & TWA_STATUS_UNEXPECTED_BITS) != 0) {
+               if (time_second > (last_warning[1] + 5)) {
+                       twa_printf(sc, "Unexpected status bit(s) %b\n",
+                                       status_reg & TWA_STATUS_UNEXPECTED_BITS,
+                                       TWA_STATUS_BITS_DESCRIPTION);
+                       last_warning[1] = time_second;
+               }
+               if (status_reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT) {
+                       twa_printf(sc, "PCI parity error: clearing... Re-seat/move/replace card.\n");
+                       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_PARITY_ERROR);
+                       twa_write_pci_config(sc, TWA_PCI_CONFIG_CLEAR_PARITY_ERROR, 2);
+               }
+               if (status_reg & TWA_STATUS_PCI_ABORT_INTERRUPT) {
+                       twa_printf(sc, "PCI abort: clearing...\n");
+                       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_PCI_ABORT);
+                       twa_write_pci_config(sc, TWA_PCI_CONFIG_CLEAR_PCI_ABORT, 2);
+               }
+               if (status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) {
+                       twa_printf(sc, "Controller queue error: clearing...\n");
+                       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_PCI_ABORT);
+               }
+               if (status_reg & TWA_STATUS_SBUF_WRITE_ERROR) {
+                       twa_printf(sc, "SBUF write error: clearing...\n");
+                       TWA_WRITE_CONTROL_REGISTER(sc, TWA_CONTROL_CLEAR_SBUF_WRITE_ERROR);
+               }
+               if (status_reg & TWA_STATUS_MICROCONTROLLER_ERROR) {
+                       twa_printf(sc, "Micro-controller error!\n");
+                       result = 1;
+               }
+       }
+       return(result);
+}      
+
+
+
+/*
+ * Function name:      twa_print_controller
+ * Description:                Prints the current status of the controller.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_print_controller(struct twa_softc *sc)
+{
+       u_int32_t       status_reg;
+
+       /* Print current controller details. */
+       status_reg = TWA_READ_STATUS_REGISTER(sc);
+       twa_printf(sc, "status   %b\n", status_reg, TWA_STATUS_BITS_DESCRIPTION);
+#ifdef TWA_DEBUG
+       twa_printf(sc, "q type    current  max\n");
+       twa_printf(sc, "free      %04d     %04d\n",
+               sc->twa_qstats[TWAQ_FREE].q_length, sc->twa_qstats[TWAQ_FREE].q_max);
+       twa_printf(sc, "busy      %04d     %04d\n",
+               sc->twa_qstats[TWAQ_BUSY].q_length, sc->twa_qstats[TWAQ_BUSY].q_max);
+       twa_printf(sc, "pending   %04d     %04d\n",
+               sc->twa_qstats[TWAQ_PENDING].q_length, sc->twa_qstats[TWAQ_PENDING].q_max);
+       twa_printf(sc, "complete  %04d     %04d\n",
+               sc->twa_qstats[TWAQ_COMPLETE].q_length, sc->twa_qstats[TWAQ_COMPLETE].q_max);
+#endif /* TWA_DEBUG */
+       twa_printf(sc, "AEN queue head %d  tail %d\n",
+                       sc->twa_aen_head, sc->twa_aen_tail);
+}      
+
+
+
+/*
+ * Function name:      twa_panic
+ * Description:                Called when something is seriously wrong with the ctlr.
+ *                     Hits the debugger if the debugger is turned on, else
+ *                     resets the ctlr.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     reason  -- string describing what went wrong
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_panic(struct twa_softc *sc, int8_t *reason)
+{
+       twa_print_controller(sc);
+#ifdef TWA_DEBUG
+       panic(reason);
+#else
+       twa_printf(sc, "twa_panic: RESETTING CONTROLLER...\n");
+       twa_reset(sc);
+#endif
+}
+
diff --git a/sys/dev/raid/twa/twa.h b/sys/dev/raid/twa/twa.h
new file mode 100644 (file)
index 0000000..e6e3c51
--- /dev/null
@@ -0,0 +1,323 @@
+/*-
+ * Copyright (c) 2003-04 3ware, Inc.
+ * Copyright (c) 2000 Michael Smith
+ * Copyright (c) 2000 BSDi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     $FreeBSD$
+ * $DragonFly: src/sys/dev/raid/twa/twa.h,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+ */
+
+/*
+ * 3ware driver for 9000 series storage controllers.
+ *
+ * Author: Vinod Kashyap
+ */
+
+
+/*
+ * The scheme for the driver version is:
+ * <major change>.<external release>.<3ware internal release>.<development release>
+ */
+#define TWA_DRIVER_VERSION_STRING              "2.40.00.000"
+
+#define TWA_CDEV_MAJOR                         187
+
+#define TWA_REQUEST_TIMEOUT_PERIOD             60 /* seconds */
+#define TWA_MESSAGE_SOURCE_CONTROLLER_ERROR    3
+#define TWA_MESSAGE_SOURCE_CONTROLLER_EVENT    4
+#define TWA_MESSAGE_SOURCE_FREEBSD_DRIVER      6
+#define TWA_MESSAGE_SOURCE_FREEBSD_OS          9
+
+#define TWA_MALLOC_CLASS                       M_TWA
+
+/* Macros for bus-space calls. */
+#define TWA_READ_REGISTER(sc, offset)          \
+       (u_int32_t)bus_space_read_4(sc->twa_bus_tag, sc->twa_bus_handle, offset)
+#define TWA_WRITE_REGISTER(sc, offset, val)    \
+       bus_space_write_4(sc->twa_bus_tag, sc->twa_bus_handle, offset, (u_int32_t)val)
+
+/* Possible values of tr->tr_status. */
+#define TWA_CMD_SETUP          0x0     /* being assembled */
+#define TWA_CMD_BUSY           0x1     /* submitted to controller */
+#define TWA_CMD_PENDING                0x2     /* in pending queue */
+#define TWA_CMD_COMPLETE       0x3     /* completed by controller (maybe with error) */
+
+/* Possible values of tr->tr_flags. */
+#define TWA_CMD_DATA_IN                        (1<<0)  /* read request */
+#define TWA_CMD_DATA_OUT               (1<<1)  /* write request */
+#define TWA_CMD_DATA_COPY_NEEDED       (1<<2)  /* data in ccb is misaligned, have to copy to/from private buffer */
+#define TWA_CMD_SLEEP_ON_REQUEST       (1<<3)  /* owner is sleeping on this command */
+#define TWA_CMD_IN_PROGRESS            (1<<4)  /* bus_dmamap_load returned EINPROGRESS */
+
+/* Possible values of tr->tr_cmd_pkt_type. */
+#define TWA_CMD_PKT_TYPE_7K            (1<<0)
+#define TWA_CMD_PKT_TYPE_9K            (1<<1)
+#define TWA_CMD_PKT_TYPE_INTERNAL      (1<<2)
+#define TWA_CMD_PKT_TYPE_IOCTL         (1<<3)
+#define TWA_CMD_PKT_TYPE_EXTERNAL      (1<<4)
+
+/* Possible values of sc->twa_state. */
+#define TWA_STATE_INTR_ENABLED         (1<<0)  /* interrupts have been enabled */
+#define TWA_STATE_SHUTDOWN             (1<<1)  /* controller is shut down */
+#define TWA_STATE_OPEN                 (1<<2)  /* control device is open */
+#define TWA_STATE_SUSPEND              (1<<3)  /* controller is suspended */
+#define TWA_STATE_SIMQ_FROZEN          (1<<4)  /* simq frozen */
+
+/* Possible values of sc->twa_ioctl_lock.lock. */
+#define TWA_LOCK_FREE          0x0     /* lock is free */
+#define TWA_LOCK_HELD          0x1     /* lock is held */
+
+
+/* Error/AEN message structure. */
+struct twa_message {
+       u_int32_t       code;
+       char            *message;
+};
+
+#ifdef TWA_DEBUG
+struct twa_q_statistics {
+       u_int32_t       q_length;
+       u_int32_t       q_max;
+};
+
+#define TWAQ_FREE      0
+#define TWAQ_BUSY      1
+#define TWAQ_PENDING   2
+#define TWAQ_COMPLETE  3
+#define TWAQ_COUNT     4       /* total number of queues */
+#endif /* TWA_DEBUG */
+
+/* Driver's request packet. */
+struct twa_request {
+       struct twa_command_packet *tr_command;  /* ptr to cmd pkt submitted to controller */
+       u_int32_t               tr_request_id;  /* request id for tracking with firmware */
+
+       void                    *tr_data;       /* ptr to data being passed to firmware */
+       size_t                  tr_length;      /* length of buffer being passed to firmware */
+
+       void                    *tr_real_data;  /* ptr to, and length of data passed */
+       size_t                  tr_real_length; /* to us from above, in case a buffer copy
+                                                       was done due to non-compliance to 
+                                                       alignment requirements */
+
+       TAILQ_ENTRY(twa_request) tr_link;       /* to link this request in a list */
+       struct twa_softc        *tr_sc;         /* controller that owns us */
+
+       u_int32_t               tr_status;      /* command status */
+       u_int32_t               tr_flags;       /* request flags */
+       u_int32_t               tr_error;       /* error encountered before request submission */
+       u_int32_t               tr_cmd_pkt_type;/* type of request */
+       void                    *tr_private;    /* request specific data to use during callback */
+       void                    (*tr_callback)(struct twa_request *tr);/* callback handler */
+       bus_addr_t              tr_cmd_phys;    /* physical address of command in controller space */
+       bus_dmamap_t            tr_dma_map;     /* DMA map for data */
+} __attribute__ ((packed));
+
+
+/* Per-controller structure. */
+struct twa_softc {
+       /* Request queues and arrays. */
+       TAILQ_HEAD(, twa_request) twa_free;     /* free request packets */
+       TAILQ_HEAD(, twa_request) twa_busy;     /* requests busy in the controller */
+       TAILQ_HEAD(, twa_request) twa_pending;  /* internal requests pending */
+       TAILQ_HEAD(, twa_request) twa_complete; /* requests completed by firmware (not by us) */
+
+       struct twa_request      *twa_lookup[TWA_Q_LENGTH];/* requests indexed by request_id */
+
+       struct twa_request      *twa_req_buf;
+       struct twa_command_packet *twa_cmd_pkt_buf;
+
+       /* AEN handler fields. */
+       struct twa_event_packet *twa_aen_queue[TWA_Q_LENGTH];/* circular queue of AENs from firmware */
+       uint16_t                working_srl;    /* driver & firmware negotiated srl */
+       uint16_t                working_branch; /* branch # of the firmware that the driver is compatible with */
+       uint16_t                working_build;  /* build # of the firmware that the driver is compatible with */
+       u_int32_t               twa_operating_mode; /* base mode/current mode */
+       u_int32_t               twa_aen_head;   /* AEN queue head */
+       u_int32_t               twa_aen_tail;   /* AEN queue tail */
+       u_int32_t               twa_current_sequence_id;/* index of the last event + 1 */
+       u_int32_t               twa_aen_queue_overflow; /* indicates if unretrieved events were overwritten */
+       u_int32_t               twa_aen_queue_wrapped;  /* indicates if AEN queue ever wrapped */
+       u_int32_t               twa_wait_timeout; /* identifier for calling tsleep */
+
+       /* Controller state. */
+       u_int32_t               twa_state;
+#ifdef TWA_DEBUG
+       struct twa_q_statistics twa_qstats[TWAQ_COUNT]; /* queue statistics */
+#endif /* TWA_DEBUG */
+       struct {
+               u_int32_t       lock;   /* lock state */
+               u_int32_t       timeout;/* time at which the lock will become available,
+                                               even if not released */
+       } twa_ioctl_lock;       /* lock for use by user applications, for synchronization
+                                       between ioctl calls */
+    
+       device_t                twa_bus_dev;    /* bus device */
+       dev_t                   twa_ctrl_dev;   /* control device */
+       struct resource         *twa_io_res;    /* register interface window */
+       bus_space_handle_t      twa_bus_handle; /* bus space handle */
+       bus_space_tag_t         twa_bus_tag;    /* bus space tag */
+       bus_dma_tag_t           twa_dma_tag;    /* data buffer DMA tag */
+       bus_dmamap_t            twa_cmd_map;    /* DMA map for the array of cmd pkts */
+       bus_addr_t              twa_cmd_pkt_phys;/* phys addr of first of array of cmd pkts */
+       struct resource         *twa_irq_res;   /* interrupt resource*/
+       void                    *twa_intr_handle;/* interrupt handle */
+       struct intr_config_hook twa_ich;        /* delayed-startup hook */
+
+       struct sysctl_ctx_list  twa_sysctl_ctx;
+       struct sysctl_oid       *twa_sysctl_tree;
+
+       struct cam_sim          *twa_sim;       /* sim for this controller */
+       struct cam_path         *twa_path;      /* peripheral, path, tgt, lun
+                                               associated with this controller */
+};
+
+
+/*
+ * Queue primitives
+ */
+
+#ifdef TWA_DEBUG
+
+#define TWAQ_INIT(sc, qname)                           \
+       do {                                            \
+               sc->twa_qstats[qname].q_length = 0;     \
+               sc->twa_qstats[qname].q_max = 0;        \
+       } while(0)
+
+#define TWAQ_ADD(sc, qname)                                    \
+       do {                                                    \
+       struct twa_q_statistics *qs = &(sc)->twa_qstats[qname]; \
+                                                               \
+               qs->q_length++;                                 \
+               if (qs->q_length > qs->q_max)                   \
+                       qs->q_max = qs->q_length;               \
+       } while(0)
+
+#define TWAQ_REMOVE(sc, qname) (sc)->twa_qstats[qname].q_length--
+
+#else /* TWA_DEBUG */
+
+#define TWAQ_INIT(sc, qname)
+#define TWAQ_ADD(sc, qname)
+#define TWAQ_REMOVE(sc, qname)
+
+#endif /* TWA_DEBUG */
+
+#define TWAQ_REQUEST_QUEUE(name, index)                                        \
+static __inline void twa_initq_ ## name(struct twa_softc *sc)          \
+{                                                                      \
+       TAILQ_INIT(&sc->twa_ ## name);                                  \
+       TWAQ_INIT(sc, index);                                           \
+}                                                                      \
+static __inline void twa_enqueue_ ## name(struct twa_request *tr)      \
+{                                                                      \
+       int     s;                                                      \
+                                                                       \
+       s = splcam();                                                   \
+       TAILQ_INSERT_TAIL(&tr->tr_sc->twa_ ## name, tr, tr_link);       \
+       TWAQ_ADD(tr->tr_sc, index);                                     \
+       splx(s);                                                        \
+}                                                                      \
+static __inline void twa_requeue_ ## name(struct twa_request *tr)      \
+{                                                                      \
+       int     s;                                                      \
+                                                                       \
+       s = splcam();                                                   \
+       TAILQ_INSERT_HEAD(&tr->tr_sc->twa_ ## name, tr, tr_link);       \
+       TWAQ_ADD(tr->tr_sc, index);                                     \
+       splx(s);                                                        \
+}                                                                      \
+static __inline struct twa_request *twa_dequeue_ ## name(struct twa_softc *sc)\
+{                                                                      \
+       struct twa_request      *tr;                                    \
+       int                     s;                                      \
+                                                                       \
+       s = splcam();                                                   \
+       if ((tr = TAILQ_FIRST(&sc->twa_ ## name)) != NULL) {            \
+               TAILQ_REMOVE(&sc->twa_ ## name, tr, tr_link);           \
+               TWAQ_REMOVE(sc, index);                                 \
+       }                                                               \
+       splx(s);                                                        \
+       return(tr);                                                     \
+}                                                                      \
+static __inline void twa_remove_ ## name(struct twa_request *tr)       \
+{                                                                      \
+       int     s;                                                      \
+                                                                       \
+       s = splcam();                                                   \
+       TAILQ_REMOVE(&tr->tr_sc->twa_ ## name, tr, tr_link);            \
+       TWAQ_REMOVE(tr->tr_sc, index);                                  \
+       splx(s);                                                        \
+}
+
+TWAQ_REQUEST_QUEUE(free, TWAQ_FREE)
+TWAQ_REQUEST_QUEUE(busy, TWAQ_BUSY)
+TWAQ_REQUEST_QUEUE(pending, TWAQ_PENDING)
+TWAQ_REQUEST_QUEUE(complete, TWAQ_COMPLETE)
+
+
+#ifdef TWA_DEBUG
+
+extern u_int8_t        twa_dbg_level;
+extern u_int8_t        twa_call_dbg_level;
+
+/* Printf with the bus device in question. */
+#define twa_dbg_dprint(dbg_level, sc, fmt, args...)            \
+       do {                                                    \
+               if (dbg_level <= twa_dbg_level)                 \
+                       device_printf(sc->twa_bus_dev,          \
+                               "%s: " fmt "\n", __func__ , ##args);\
+       } while(0)
+
+#define twa_dbg_dprint_enter(dbg_level, sc)                    \
+       do {                                                    \
+               if (dbg_level <= twa_call_dbg_level)            \
+                       device_printf(sc->twa_bus_dev,          \
+                               "%s: entered.\n", __func__);    \
+       } while(0)
+
+#define twa_dbg_dprint_exit(dbg_level, sc)                     \
+       do {                                                    \
+               if (dbg_level <= twa_call_dbg_level)            \
+                       device_printf(sc->twa_bus_dev,          \
+                               "%s: exiting.\n", __func__);    \
+       } while(0)
+
+#define twa_dbg_print(dbg_level, fmt, args...)                 \
+       do {                                                    \
+               if (dbg_level <= twa_dbg_level)                 \
+                       printf("%s: " fmt "\n", __func__ , ##args);\
+       } while(0)
+
+#else
+#define twa_dbg_dprint(dbg_level, sc, fmt, args...)
+#define twa_dbg_dprint_enter(dbg_level, sc)
+#define twa_dbg_dprint_exit(dbg_level, sc)
+#define twa_dbg_print(dbg_level, fmt, args...)
+#endif
+
+#define twa_printf(sc, fmt, args...)   \
+       device_printf(sc->twa_bus_dev, fmt, ##args)
diff --git a/sys/dev/raid/twa/twa_cam.c b/sys/dev/raid/twa/twa_cam.c
new file mode 100644 (file)
index 0000000..42ed426
--- /dev/null
@@ -0,0 +1,719 @@
+/*-
+ * Copyright (c) 2003-04 3ware, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     $FreeBSD$
+ * $DragonFly: src/sys/dev/raid/twa/twa_cam.c,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+ */
+
+/*
+ * 3ware driver for 9000 series storage controllers.
+ *
+ * Author: Vinod Kashyap
+ */
+
+
+#include "twa_includes.h"
+
+#include <bus/cam/cam.h>
+#include <bus/cam/cam_ccb.h>
+#include <bus/cam/cam_sim.h>
+#include <bus/cam/cam_xpt_sim.h>
+#include <bus/cam/cam_xpt_periph.h>
+#include <bus/cam/cam_debug.h>
+#include <bus/cam/cam_periph.h>
+
+#include <bus/cam/scsi/scsi_all.h>
+#include <bus/cam/scsi/scsi_message.h>
+
+static int     twa_execute_scsi(struct twa_request *tr, union ccb *ccb);
+static void    twa_action(struct cam_sim *sim, union ccb *ccb);
+static void    twa_poll(struct cam_sim *sim);
+static void    twa_async(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg);
+static void    twa_bus_scan_cb(struct cam_periph *periph, union ccb *ccb);
+
+
+
+/*
+ * Function name:      twa_cam_setup
+ * Description:                Attaches the driver to CAM.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_cam_setup(struct twa_softc *sc)
+{
+       struct cam_devq         *devq;
+       struct ccb_setasync     csa;
+
+       twa_dbg_dprint(3, sc, "sc = %p", sc);
+       /*
+        * Create the device queue for our SIM.
+        */
+       devq = cam_simq_alloc(TWA_Q_LENGTH);
+       if (devq == NULL)
+               return(ENOMEM);
+
+       /*
+        * Create a SIM entry.  Though we can support TWA_Q_LENGTH simultaneous
+        * requests, we claim to be able to handle only (TWA_Q_LENGTH - 1), so
+        * that we always have a request packet available to service attention
+        * interrupts.
+        */
+       twa_dbg_dprint(3, sc, "Calling cam_sim_alloc");
+       sc->twa_sim = cam_sim_alloc(twa_action, twa_poll, "twa", sc,
+                                       device_get_unit(sc->twa_bus_dev),
+                                       TWA_Q_LENGTH - 1, 1, devq);
+       cam_simq_release(devq);
+       if (sc->twa_sim == NULL) {
+               return(ENOMEM);
+       }
+
+       /*
+        * Register the bus.
+        */
+       twa_dbg_dprint(3, sc, "Calling xpt_bus_register");
+       if (xpt_bus_register(sc->twa_sim, 0) != CAM_SUCCESS) {
+               cam_sim_free(sc->twa_sim);
+               sc->twa_sim = NULL; /* so twa_cam_detach will not try to free it */
+               return(ENXIO);
+       }
+
+       twa_dbg_dprint(3, sc, "Calling xpt_create_path");
+       if (xpt_create_path(&sc->twa_path, NULL,
+                               cam_sim_path(sc->twa_sim),
+                               CAM_TARGET_WILDCARD,
+                               CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
+               xpt_bus_deregister(cam_sim_path (sc->twa_sim));
+               cam_sim_free(sc->twa_sim); /* passing TRUE will free the devq as well */
+               return(ENXIO);
+       }
+
+       twa_dbg_dprint(3, sc, "Calling xpt_setup_ccb");
+       xpt_setup_ccb(&csa.ccb_h, sc->twa_path, 5);
+       csa.ccb_h.func_code = XPT_SASYNC_CB;
+       csa.event_enable = AC_FOUND_DEVICE | AC_LOST_DEVICE;
+       csa.callback = twa_async;
+       csa.callback_arg = sc;
+       xpt_action((union ccb *)&csa);
+
+       twa_dbg_dprint(3, sc, "Calling twa_request_bus_scan");
+       /*
+        * Request a bus scan, so that CAM gets to know of
+        * the logical units that we control.
+        */
+       twa_request_bus_scan(sc);
+       twa_dbg_dprint(3, sc, "Exiting");
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_cam_detach
+ * Description:                Detaches the driver from CAM.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_cam_detach(struct twa_softc *sc)
+{
+       if (sc->twa_path)
+               xpt_free_path(sc->twa_path);
+       if (sc->twa_sim) {
+               xpt_bus_deregister(cam_sim_path(sc->twa_sim));
+               cam_sim_free(sc->twa_sim); /* passing TRUE will free the devq as well */
+       }
+}
+
+
+
+/*
+ * Function name:      twa_send_scsi_cmd
+ * Description:                Sends down a scsi cmd to fw.
+ *
+ * Input:              tr      -- ptr to request pkt
+ *                     cmd     -- opcode of scsi cmd to send
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_send_scsi_cmd(struct twa_request *tr, int cmd)
+{
+       union ccb       ccb;
+
+       bzero(&ccb, sizeof(union ccb));
+       ccb.csio.cdb_io.cdb_bytes[0] = (u_int8_t)cmd;
+       ccb.csio.cdb_io.cdb_bytes[4] = 128;
+       ccb.csio.cdb_len = 16;
+       if ((ccb.csio.data_ptr = malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT))
+                                       == NULL)
+               return(ENOMEM);
+       bzero(ccb.csio.data_ptr, TWA_SECTOR_SIZE);
+       ccb.csio.dxfer_len = TWA_SECTOR_SIZE;
+
+       ccb.ccb_h.target_id = 0;
+       ccb.ccb_h.flags |= CAM_DIR_IN;
+
+       if (twa_execute_scsi(tr, &ccb))
+               return(EIO);
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_execute_scsi
+ * Description:                Build a fw cmd, based on a CAM style ccb, and
+ *                     send it down.
+ *
+ * Input:              tr      -- ptr to request pkt
+ *                     ccb     -- ptr to CAM style ccb
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_execute_scsi(struct twa_request *tr, union ccb *ccb)
+{
+       struct twa_softc                *sc = tr->tr_sc;
+       struct twa_command_packet       *cmdpkt;
+       struct twa_command_9k           *cmd9k;
+       struct ccb_hdr                  *ccb_h = &(ccb->ccb_h);
+       struct ccb_scsiio               *csio = &(ccb->csio);
+       int                             error;
+
+       twa_dbg_dprint(3, sc, "SCSI I/O request 0x%x", 
+                               csio->cdb_io.cdb_bytes[0]);
+
+       if (ccb_h->target_id >= TWA_MAX_UNITS) {
+               twa_dbg_dprint(3, sc, "Invalid target. PTL = %x %x %x",
+                       ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun);
+               ccb_h->status |= CAM_TID_INVALID;
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
+                       xpt_done(ccb);
+               return(1);
+       }
+       if (ccb_h->target_lun != 0) {
+               twa_dbg_dprint(3, sc, "Invalid lun. PTL = %x %x %x",
+                       ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun);
+               ccb_h->status |= CAM_LUN_INVALID;
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
+                       xpt_done(ccb);
+               return(1);
+       }
+
+       if(ccb_h->flags & CAM_CDB_PHYS) {
+               twa_printf(sc, "Physical CDB address!\n");
+               ccb_h->status = CAM_REQ_CMP_ERR;
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
+                       xpt_done(ccb);
+               return(1);
+       }
+
+       /*
+        * We are going to work on this request.  Mark it as enqueued (though
+        * we don't actually queue it...)
+        */
+       ccb_h->status |= CAM_SIM_QUEUED;
+
+       if((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
+               if(ccb_h->flags & CAM_DIR_IN)
+                       tr->tr_flags |= TWA_CMD_DATA_IN;
+               else
+                       tr->tr_flags |= TWA_CMD_DATA_OUT;
+       }
+
+       cmdpkt = tr->tr_command;
+
+       cmdpkt->cmd_hdr.header_desc.size_header = 128;
+               
+       cmd9k = &(cmdpkt->command.cmd_pkt_9k);
+       cmd9k->command.opcode = TWA_OP_EXECUTE_SCSI_COMMAND;
+       cmd9k->unit = ccb_h->target_id;
+       cmd9k->request_id = tr->tr_request_id;
+       cmd9k->status = 0;
+       cmd9k->sgl_offset = 16; /* offset from end of hdr = max cdb len */
+
+       if(ccb_h->flags & CAM_CDB_POINTER)
+               bcopy(csio->cdb_io.cdb_ptr, cmd9k->cdb, csio->cdb_len);
+       else
+               bcopy(csio->cdb_io.cdb_bytes, cmd9k->cdb, csio->cdb_len);
+
+       if (!(ccb_h->flags & CAM_DATA_PHYS)) {
+               /* Virtual data addresses.  Need to convert them... */
+               twa_dbg_dprint(3, sc, "XPT_SCSI_IO: Single virtual address!");
+               if (!(ccb_h->flags & CAM_SCATTER_VALID)) {
+                       if (csio->dxfer_len > TWA_MAX_IO_SIZE) {
+                               twa_printf(sc, "I/O size %d too big.\n",
+                                                       csio->dxfer_len);
+                               ccb_h->status = CAM_REQ_TOO_BIG;
+                               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
+                                       xpt_done(ccb);
+                               return(1);
+                       }
+
+                       if ((tr->tr_length = csio->dxfer_len)) {
+                               tr->tr_data = csio->data_ptr;
+                               cmd9k->sgl_entries = 1;
+                       }
+               } else {
+                       twa_printf(sc, "twa_execute_scsi: XPT_SCSI_IO: Got SGList!\n");
+                       ccb_h->status = CAM_REQ_CMP_ERR;
+                       if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) {
+                               xpt_done(ccb);
+                       }
+                       return(1);
+               }
+       } else {
+               /* Data addresses are physical. */
+               twa_printf(sc, "twa_execute_scsi: XPT_SCSI_IO: Physical data addresses!\n");
+               ccb_h->status = CAM_REQ_CMP_ERR;
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) {
+                       ccb_h->status |= CAM_RELEASE_SIMQ;
+                       ccb_h->status &= ~CAM_SIM_QUEUED;
+                       xpt_done(ccb);
+               }
+               return(1);
+       }
+
+       tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_9K;
+       /* twa_setup_data_dmamap will fill in the SGL, and submit the I/O. */
+       error = twa_map_request(tr);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_action
+ * Description:                Driver entry point for CAM's use.
+ *
+ * Input:              sim     -- sim corresponding to the ctlr
+ *                     ccb     -- ptr to CAM request
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_action(struct cam_sim *sim, union ccb *ccb)
+{
+       struct twa_softc        *sc = (struct twa_softc *)cam_sim_softc(sim);
+       struct ccb_hdr          *ccb_h = &(ccb->ccb_h);
+
+       switch (ccb_h->func_code) {
+       case XPT_SCSI_IO:       /* SCSI I/O */
+       {
+               struct twa_request      *tr;
+
+               if ((sc->twa_state & TWA_STATE_SIMQ_FROZEN) ||
+                               ((tr = twa_get_request(sc)) == NULL)) {
+                       twa_dbg_dprint(2, sc, "simq frozen/Cannot get request pkt.");
+                       /*
+                        * Freeze the simq to maintain ccb ordering.  The next
+                        * ccb that gets completed will unfreeze the simq.
+                        */
+                       twa_disallow_new_requests(sc);
+                       ccb_h->status |= CAM_REQUEUE_REQ;
+                       xpt_done(ccb);
+                       break;
+               }
+               tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_EXTERNAL;
+               tr->tr_private = ccb;
+               tr->tr_callback = twa_complete_io;
+               if (twa_execute_scsi(tr, ccb))
+                       twa_release_request(tr);
+               break;
+       }
+
+       case XPT_ABORT:
+               twa_dbg_dprint(2, sc, "Abort request");
+               ccb_h->status = CAM_UA_ABORT;
+               xpt_done(ccb);
+               break;
+
+       case XPT_RESET_BUS:
+               twa_printf(sc, "Reset Bus request from CAM...\n");
+               if (twa_reset(sc)) {
+                       twa_printf(sc, "Reset Bus failed!\n");
+                       ccb_h->status = CAM_REQ_CMP_ERR;
+               }
+               else
+                       ccb_h->status = CAM_REQ_CMP;
+
+               xpt_done(ccb);
+               break;
+
+       case XPT_SET_TRAN_SETTINGS:
+               twa_dbg_dprint(3, sc, "XPT_SET_TRAN_SETTINGS");
+
+               /*
+                * This command is not supported, since it's very specific
+                * to SCSI, and we are doing ATA.
+                */
+               ccb_h->status = CAM_FUNC_NOTAVAIL;
+               xpt_done(ccb);
+               break;
+
+       case XPT_GET_TRAN_SETTINGS: 
+       {
+               struct ccb_trans_settings       *cts = &ccb->cts;
+
+               twa_dbg_dprint(3, sc, "XPT_GET_TRAN_SETTINGS");
+               cts->valid = (CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID);
+               cts->flags &= ~(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
+               ccb_h->status = CAM_REQ_CMP;
+               xpt_done(ccb);
+               break;
+       }
+
+       case XPT_CALC_GEOMETRY:
+       {
+               struct ccb_calc_geometry        *geom;
+
+               twa_dbg_dprint(3, sc, "XPT_CALC_GEOMETRY request");
+               geom = &ccb->ccg;
+
+               if (geom->volume_size > 0x200000) /* 1 GB */ {
+                       geom->heads = 255;
+                       geom->secs_per_track = 63;
+               } else {
+                       geom->heads = 64;
+                       geom->secs_per_track = 32;
+               }
+               geom->cylinders = geom->volume_size /
+                                       (geom->heads * geom->secs_per_track);
+               ccb_h->status = CAM_REQ_CMP;
+               xpt_done(ccb);
+               break;
+       }
+
+       case XPT_PATH_INQ:    /* Path inquiry -- get twa properties */
+       {
+               struct ccb_pathinq      *path_inq = &ccb->cpi;
+
+               twa_dbg_dprint(3, sc, "XPT_PATH_INQ request");
+
+               path_inq->version_num = 1;
+               path_inq->hba_inquiry = 0;
+               path_inq->target_sprt = 0;
+               path_inq->hba_misc = 0;
+               path_inq->hba_eng_cnt = 0;
+               path_inq->max_target = TWA_MAX_UNITS;
+               path_inq->max_lun = 0;
+               path_inq->unit_number = cam_sim_unit(sim);
+               path_inq->bus_id = cam_sim_bus(sim);
+               path_inq->initiator_id = 12;
+               path_inq->base_transfer_speed = 100000;
+               strncpy(path_inq->sim_vid, "FreeBSD", SIM_IDLEN);
+               strncpy(path_inq->hba_vid, "3ware", HBA_IDLEN);
+               strncpy(path_inq->dev_name, cam_sim_name(sim), DEV_IDLEN);
+               ccb_h->status = CAM_REQ_CMP;
+               xpt_done(ccb);
+               break;
+       }
+
+       default:
+               twa_dbg_dprint(3, sc, "func_code = %x", ccb_h->func_code);
+               ccb_h->status = CAM_REQ_INVALID;
+               xpt_done(ccb);
+               break;
+       }
+}
+
+
+
+/*
+ * Function name:      twa_poll
+ * Description:                Driver entry point called when interrupts are not available.
+ *
+ * Input:              sim     -- sim corresponding to the controller
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_poll(struct cam_sim *sim)
+{
+#ifdef TWA_DEBUG
+       struct twa_softc *sc = (struct twa_softc *)cam_sim_softc(sim);
+#endif /* TWA_DEBUG */
+
+       twa_dbg_dprint(3, sc, "Entering sc = %p", sc);
+       twa_interrupt(cam_sim_softc(sim));
+       twa_dbg_dprint(3, sc, "Exiting sc = %p", sc);
+}
+
+
+
+/*
+ * Function name:      twa_async
+ * Description:                Driver entry point for CAM to notify driver of special
+ *                     events.  We don't use this for now.
+ *
+ * Input:              callback_arg    -- ptr to per ctlr structure
+ *                     code            -- code associated with the event
+ *                     path            -- cam path
+ *                     arg             -- 
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+void
+twa_async(void *callback_arg, u_int32_t code, 
+                       struct cam_path *path, void *arg)
+{
+#ifdef TWA_DEBUG
+       struct twa_softc *sc = (struct twa_softc *)callback_arg;
+#endif /* TWA_DEBUG */
+
+       twa_dbg_dprint(3, sc, "sc = %p, code = %x, path = %p, arg = %p",
+                               sc, code, path, arg);
+}
+
+
+
+/*
+ * Function name:      twa_request_bus_scan
+ * Description:                Requests CAM for a scan of the bus.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_request_bus_scan(struct twa_softc *sc)
+{
+       struct cam_path *path;
+       union ccb       *ccb;
+
+       if ((ccb = malloc(sizeof(union ccb), M_TEMP, M_WAITOK)) == NULL)
+               return;
+       bzero(ccb, sizeof(union ccb));
+       if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->twa_sim),
+                       CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP)
+               return;
+
+       xpt_setup_ccb(&ccb->ccb_h, path, 5);
+       ccb->ccb_h.func_code = XPT_SCAN_BUS;
+       ccb->ccb_h.cbfcnp = twa_bus_scan_cb;
+       ccb->crcn.flags = CAM_FLAG_NONE;
+       xpt_action(ccb);
+}
+
+
+
+/*
+ * Function name:      twa_bus_scan_cb
+ * Description:                Callback from CAM on a bus scan request.
+ *
+ * Input:              periph  -- we don't use this
+ *                     ccb     -- bus scan request ccb that we sent to CAM
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_bus_scan_cb(struct cam_periph *periph, union ccb *ccb)
+{
+       twa_dbg_print(3, "ccb = %p\n", ccb);
+       if (ccb->ccb_h.status != CAM_REQ_CMP)
+               printf("cam_scan_callback: failure status = %x\n",
+                                       ccb->ccb_h.status);
+       else
+               twa_dbg_print(3, "success");
+
+       xpt_free_path(ccb->ccb_h.path);
+       free(ccb, M_TEMP);
+}
+
+
+
+/*
+ * Function name:      twa_scsi_complete
+ * Description:                Called to complete CAM scsi requests.
+ *
+ * Input:              tr      -- ptr to request pkt to be completed
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_scsi_complete(struct twa_request *tr)
+{
+       struct twa_softc                *sc = tr->tr_sc;
+       struct twa_command_header       *cmd_hdr = &(tr->tr_command->cmd_hdr);
+       struct twa_command_9k           *cmd = &(tr->tr_command->command.cmd_pkt_9k);
+       union ccb                       *ccb = (union ccb *)(tr->tr_private);
+       u_int16_t                       error;
+       u_int8_t                        *cdb;
+
+       if (tr->tr_error) {
+               if (tr->tr_error == EBUSY)
+                       ccb->ccb_h.status |= CAM_REQUEUE_REQ;
+               else if (tr->tr_error == EFBIG)
+                       ccb->ccb_h.status = CAM_REQ_TOO_BIG;
+               else
+                       ccb->ccb_h.status = CAM_REQ_CMP_ERR;
+       } else {
+               if (cmd->status) {
+                       twa_dbg_dprint(1, sc, "req_id = 0x%x, status = 0x%x",
+                                               cmd->request_id,
+                                               cmd->status);
+
+                       error = cmd_hdr->status_block.error;
+                       if ((error == TWA_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) ||
+                                       (error == TWA_ERROR_UNIT_OFFLINE)) {
+                               twa_dbg_dprint(3, sc, "Unsupported unit. PTL = %x %x %x",
+                                                       ccb->ccb_h.path_id,
+                                                       ccb->ccb_h.target_id,
+                                                       ccb->ccb_h.target_lun);
+                               ccb->ccb_h.status |= CAM_TID_INVALID;
+                       } else {
+                               twa_dbg_dprint(2, sc, "cmd = %x %x %x %x %x %x %x",
+                                               cmd->command.opcode,
+                                               cmd->command.reserved,
+                                               cmd->unit,
+                                               cmd->request_id,
+                                               cmd->status,
+                                               cmd->sgl_offset,
+                                               cmd->sgl_entries);
+
+                               cdb = (u_int8_t *)(cmd->cdb);
+                               twa_dbg_dprint(2, sc, "cdb = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
+                                       cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7],
+                                       cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]);
+
+                               cmd_hdr->err_specific_desc[sizeof(cmd_hdr->err_specific_desc) - 1] = '\0';
+                               /* 
+                                * Print the error. Firmware doesn't yet support
+                                * the 'Mode Sense' cmd.  Don't print if the cmd
+                                * is 'Mode Sense', and the error is 'Invalid field
+                                * in CDB'.
+                                */
+                               if (! ((cdb[0] == 0x1A) && (error == 0x10D)))
+                                       twa_printf(sc, "SCSI cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
+                                               cdb[0],
+                                               TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                                               error,
+                                               twa_find_msg_string(twa_error_table, error),
+                                               cmd_hdr->err_specific_desc);
+                       }
+
+                       bcopy(cmd_hdr->sense_data, &(ccb->csio.sense_data),
+                                               TWA_SENSE_DATA_LENGTH);
+                       ccb->csio.sense_len = TWA_SENSE_DATA_LENGTH;
+                       ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
+               } else
+                       ccb->ccb_h.status = CAM_REQ_CMP;
+
+               ccb->csio.scsi_status = cmd->status;
+               /* If simq is frozen, unfreeze it. */
+               if (sc->twa_state & TWA_STATE_SIMQ_FROZEN)
+                       twa_allow_new_requests(sc, (void *)ccb);
+       }
+
+       ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
+       xpt_done(ccb);
+}
+
+
+
+/*
+ * Function name:      twa_drain_busy_queue
+ * Description:                This function gets called after a controller reset.
+ *                     It errors back to CAM, all those requests that were
+ *                     pending with the firmware, at the time of the reset.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_drain_busy_queue(struct twa_softc *sc)
+{
+       struct twa_request      *tr;
+       union ccb               *ccb;
+
+       /* Walk the busy queue. */
+       while ((tr = twa_dequeue_busy(sc))) {
+               twa_unmap_request(tr);
+               if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ||
+                       (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_IOCTL)) {
+                       /* It's an internal/ioctl request.  Simply free it. */
+                       if (tr->tr_data)
+                               free(tr->tr_data, M_DEVBUF);
+               } else {
+                       if ((ccb = tr->tr_private)) {
+                               /* It's a SCSI request.  Complete it. */
+                               ccb->ccb_h.status = CAM_SCSI_BUS_RESET |
+                                                       CAM_RELEASE_SIMQ;
+                               ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
+                               xpt_done(ccb);
+                       }
+               }
+               twa_release_request(tr);
+       }
+}
+
+
+
+/*
+ * Function name:      twa_allow_new_requests
+ * Description:                Sets the appropriate status bits in a ccb such that,
+ *                     when the ccb is completed by a call to xpt_done,
+ *                     CAM knows that it's ok to unfreeze the flow of new
+ *                     requests to this controller, if the flow is frozen.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     ccb     -- ptr to CAM request
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_allow_new_requests(struct twa_softc *sc, void *ccb)
+{
+       ((union ccb *)(ccb))->ccb_h.status |= CAM_RELEASE_SIMQ;
+       sc->twa_state &= ~TWA_STATE_SIMQ_FROZEN;
+}
+
+
+
+/*
+ * Function name:      twa_disallow_new_requests
+ * Description:                Calls the appropriate CAM function, so as to freeze
+ *                     the flow of new requests from CAM to this controller.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_disallow_new_requests(struct twa_softc *sc)
+{
+       xpt_freeze_simq(sc->twa_sim, 1);
+       sc->twa_state |= TWA_STATE_SIMQ_FROZEN;
+}
diff --git a/sys/dev/raid/twa/twa_externs.h b/sys/dev/raid/twa/twa_externs.h
new file mode 100644 (file)
index 0000000..8593a8f
--- /dev/null
@@ -0,0 +1,78 @@
+/*-
+ * Copyright (c) 2003-04 3ware, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     $FreeBSD$
+ * $DragonFly: src/sys/dev/raid/twa/twa_externs.h,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+ */
+
+/*
+ * 3ware driver for 9000 series storage controllers.
+ *
+ * Author: Vinod Kashyap
+ */
+
+
+/* Global data structures */
+extern char                    twa_fw_img[];
+extern int                     twa_fw_img_size;
+extern struct twa_message      twa_aen_table[];
+extern char                    *twa_aen_severity_table[];
+extern struct twa_message      twa_error_table[];
+
+
+/* Functions in twa.c */
+extern int     twa_setup(struct twa_softc *sc);                /* do early driver/controller setup */
+extern int     twa_deinit_ctlr(struct twa_softc *sc);          /* stop controller */
+extern void    twa_interrupt(struct twa_softc *sc);            /* ISR */
+extern int     twa_ioctl(struct twa_softc *sc, int cmd, void *addr);/* handle user request */
+extern void    twa_enable_interrupts(struct twa_softc *sc);    /* enable controller interrupts */
+extern void    twa_disable_interrupts(struct twa_softc *sc);   /* disable controller interrupts */
+extern void    twa_complete_io(struct twa_request *tr);        /* I/O completion callback */
+extern int     twa_reset(struct twa_softc *sc);                /* (soft) reset controller */
+extern int     twa_submit_io(struct twa_request *tr);          /* wrapper to twa_start */
+extern int     twa_start(struct twa_request *tr);              /* submit command to controller */
+extern char    *twa_find_msg_string(struct twa_message *table, u_int16_t code);/* lookup a msg */
+extern struct twa_request *twa_get_request(struct twa_softc *sc);/* get a req pkt from free pool */
+extern void    twa_release_request(struct twa_request *tr);    /* put a req pkt back into free pool */
+extern void    twa_describe_controller(struct twa_softc *sc);  /* describe controller info */
+extern void    twa_print_controller(struct twa_softc *sc);     /* print controller state */
+
+/* Functions in twa_freebsd.c */
+extern void    twa_write_pci_config(struct twa_softc *sc, u_int32_t value, int size);/* write to pci config space */
+extern int     twa_alloc_req_pkts(struct twa_softc *sc, int num_reqs); /* alloc req & cmd pkts */
+extern int     twa_map_request(struct twa_request *tr);        /* copy cmd pkt & data to DMA'able memory */
+extern void    twa_unmap_request(struct twa_request *tr);      /* undo mapping */
+
+/* Functions in twa_cam.c */
+extern void    twa_request_bus_scan(struct twa_softc *sc);     /* request CAM for a bus scan */
+extern int     twa_send_scsi_cmd(struct twa_request *tr, int cmd);/* send down a SCSI cmd */
+extern void    twa_scsi_complete(struct twa_request *tr);      /* complete a SCSI cmd by calling CAM */
+extern void    twa_drain_busy_queue(struct twa_softc *sc);     /* drain busy queue (during reset) */
+
+extern int     twa_cam_setup(struct twa_softc *sc);            /* attach to CAM */
+extern void    twa_cam_detach(struct twa_softc *sc);           /* detach from CAM */
+extern void    twa_allow_new_requests(struct twa_softc *sc, void *ccb);/* unfreeze ccb flow from CAM */
+extern void    twa_disallow_new_requests(struct twa_softc *sc);/* freeze ccb flow from CAM */
+
diff --git a/sys/dev/raid/twa/twa_freebsd.c b/sys/dev/raid/twa/twa_freebsd.c
new file mode 100644 (file)
index 0000000..25dba4f
--- /dev/null
@@ -0,0 +1,1040 @@
+/*-
+ * Copyright (c) 2003-04 3ware, Inc.
+ * Copyright (c) 2000 Michael Smith
+ * Copyright (c) 2000 BSDi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     $FreeBSD$
+ * $DragonFly: src/sys/dev/raid/twa/twa_freebsd.c,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+ */
+
+/*
+ * 3ware driver for 9000 series storage controllers.
+ *
+ * Author: Vinod Kashyap
+ */
+
+
+#include "twa_includes.h"
+
+static void    twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs,
+                                               int nsegments, int error);
+static void    twa_setup_request_dmamap(void *arg, bus_dma_segment_t *segs,
+                                               int nsegments, int error);
+
+MALLOC_DEFINE(TWA_MALLOC_CLASS, "twa commands", "twa commands");
+
+
+static d_open_t                twa_open;
+static d_close_t               twa_close;
+static d_ioctl_t               twa_ioctl_wrapper;
+
+static struct cdevsw twa_cdevsw = {
+       "twa",
+       TWA_CDEV_MAJOR,
+       0,
+       NULL,
+       0,
+       twa_open,
+       twa_close,
+       noread,
+       nowrite,
+       twa_ioctl_wrapper,
+       nopoll,
+       nommap,
+       nostrategy,
+       nodump,
+       nopsize,
+};
+
+static devclass_t      twa_devclass;
+
+
+/*
+ * Function name:      twa_open
+ * Description:                Called when the controller is opened.
+ *                     Simply marks the controller as open.
+ *
+ * Input:              dev     -- control device corresponding to the ctlr
+ *                     flags   -- mode of open
+ *                     fmt     -- device type (character/block etc.)
+ *                     proc    -- current process
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_open(dev_t dev, int flags, int fmt, d_thread_t *proc)
+{
+       int                     unit = minor(dev);
+       struct twa_softc        *sc = devclass_get_softc(twa_devclass, unit);
+
+       sc->twa_state |= TWA_STATE_OPEN;
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_close
+ * Description:                Called when the controller is closed.
+ *                     Simply marks the controller as not open.
+ *
+ * Input:              dev     -- control device corresponding to the ctlr
+ *                     flags   -- mode of corresponding open
+ *                     fmt     -- device type (character/block etc.)
+ *                     proc    -- current process
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_close(dev_t dev, int flags, int fmt, d_thread_t *proc)
+{
+       int                     unit = minor(dev);
+       struct twa_softc        *sc = devclass_get_softc(twa_devclass, unit);
+
+       sc->twa_state &= ~TWA_STATE_OPEN;
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_ioctl_wrapper
+ * Description:                Called when an ioctl is posted to the controller.
+ *                     Simply calls the ioctl handler.
+ *
+ * Input:              dev     -- control device corresponding to the ctlr
+ *                     cmd     -- ioctl cmd
+ *                     buf     -- ptr to buffer in kernel memory, which is
+ *                                a copy of the input buffer in user-space
+ *                     flags   -- mode of corresponding open
+ *                     proc    -- current process
+ * Output:             buf     -- ptr to buffer in kernel memory, which will
+ *                                be copied to the output buffer in user-space
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_ioctl_wrapper(dev_t dev, u_long cmd, caddr_t buf,
+                                       int flags, d_thread_t *proc)
+{
+       struct twa_softc        *sc = (struct twa_softc *)(dev->si_drv1);
+
+       return(twa_ioctl(sc, cmd, buf));
+}
+
+
+
+static int     twa_probe (device_t dev);
+static int     twa_attach (device_t dev);
+static void    twa_free (struct twa_softc *sc);
+static int     twa_detach (device_t dev);
+static int     twa_shutdown (device_t dev);
+static int     twa_suspend (device_t dev);
+static int     twa_resume (device_t dev);
+static void    twa_pci_intr(void *arg);
+static void    twa_intrhook (void *arg);
+
+static device_method_t twa_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         twa_probe),
+       DEVMETHOD(device_attach,        twa_attach),
+       DEVMETHOD(device_detach,        twa_detach),
+       DEVMETHOD(device_shutdown,      twa_shutdown),
+       DEVMETHOD(device_suspend,       twa_suspend),
+       DEVMETHOD(device_resume,        twa_resume),
+
+       DEVMETHOD(bus_print_child,      bus_generic_print_child),
+       DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
+       {0, 0}
+};
+
+static driver_t        twa_pci_driver = {
+       "twa",
+       twa_methods,
+       sizeof(struct twa_softc)
+};
+
+DRIVER_MODULE(twa, pci, twa_pci_driver, twa_devclass, 0, 0);
+
+
+
+/*
+ * Function name:      twa_probe
+ * Description:                Called at driver load time.  Claims 9000 ctlrs.
+ *
+ * Input:              dev     -- bus device corresponding to the ctlr
+ * Output:             None
+ * Return value:       <= 0    -- success
+ *                     > 0     -- failure
+ */
+static int
+twa_probe(device_t dev)
+{
+       static u_int8_t first_ctlr = 1;
+
+       twa_dbg_print(3, "entered");
+
+       if ((pci_get_vendor(dev) == TWA_VENDOR_ID) &&
+                       (pci_get_device(dev) == TWA_DEVICE_ID_9K)) {
+               device_set_desc(dev, TWA_DEVICE_NAME);
+               /* Print the driver version only once. */
+               if (first_ctlr) {
+                       printf("3ware device driver for 9000 series storage controllers, version: %s\n",
+                                       TWA_DRIVER_VERSION_STRING);
+                       first_ctlr = 0;
+               }
+               return(0);
+       }
+       return(ENXIO);
+}
+
+
+
+/*
+ * Function name:      twa_attach
+ * Description:                Allocates pci resources; updates sc; adds a node to the
+ *                     sysctl tree to expose the driver version; makes calls
+ *                     to initialize ctlr, and to attach to CAM.
+ *
+ * Input:              dev     -- bus device corresponding to the ctlr
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_attach(device_t dev)
+{
+       struct twa_softc        *sc = device_get_softc(dev);
+       u_int32_t               command;
+       int                     res_id;
+       int                     error;
+
+       twa_dbg_dprint_enter(3, sc);
+
+       /* Initialize the softc structure. */
+       sc->twa_bus_dev = dev;
+
+       sysctl_ctx_init(&sc->twa_sysctl_ctx);
+       sc->twa_sysctl_tree = SYSCTL_ADD_NODE(&sc->twa_sysctl_ctx,
+                               SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
+                               device_get_nameunit(dev), CTLFLAG_RD, 0, "");
+       if (sc->twa_sysctl_tree == NULL) {
+               twa_printf(sc, "Cannot add sysctl tree node.\n");
+               return(ENXIO);
+       }
+       SYSCTL_ADD_STRING(&sc->twa_sysctl_ctx, SYSCTL_CHILDREN(sc->twa_sysctl_tree),
+                               OID_AUTO, "driver_version", CTLFLAG_RD,
+                               TWA_DRIVER_VERSION_STRING, 0, "TWA driver version");
+
+       /* Make sure we are going to be able to talk to this board. */
+       command = pci_read_config(dev, PCIR_COMMAND, 2);
+       if ((command & PCIM_CMD_PORTEN) == 0) {
+               twa_printf(sc, "Register window not available.\n");
+               return(ENXIO);
+       }
+       
+       /* Force the busmaster enable bit on, in case the BIOS forgot. */
+       command |= PCIM_CMD_BUSMASTEREN;
+       pci_write_config(dev, PCIR_COMMAND, command, 2);
+
+       /* Allocate the PCI register window. */
+       res_id = TWA_IO_CONFIG_REG;
+       if ((sc->twa_io_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &res_id,
+                                       0, ~0, 1, RF_ACTIVE)) == NULL) {
+               twa_printf(sc, "can't allocate register window.\n");
+               twa_free(sc);
+               return(ENXIO);
+       }
+       sc->twa_bus_tag = rman_get_bustag(sc->twa_io_res);
+       sc->twa_bus_handle = rman_get_bushandle(sc->twa_io_res);
+
+       /* Allocate and connect our interrupt. */
+       res_id = 0;
+       if ((sc->twa_irq_res = bus_alloc_resource(sc->twa_bus_dev, SYS_RES_IRQ,
+                                       &res_id, 0, ~0, 1,
+                                       RF_SHAREABLE | RF_ACTIVE)) == NULL) {
+               twa_printf(sc, "Can't allocate interrupt.\n");
+               twa_free(sc);
+               return(ENXIO);
+       }
+       if (bus_setup_intr(sc->twa_bus_dev, sc->twa_irq_res, INTR_TYPE_CAM,
+                               twa_pci_intr, sc, &sc->twa_intr_handle)) {
+               twa_printf(sc, "Can't set up interrupt.\n");
+               twa_free(sc);
+               return(ENXIO);
+       }
+
+       /* Initialize the driver for this controller. */
+       if ((error = twa_setup(sc))) {
+               twa_free(sc);
+               return(error);
+       }
+
+       /* Print some information about the controller and configuration. */
+       twa_describe_controller(sc);
+
+       /* Create the control device. */
+       sc->twa_ctrl_dev = make_dev(&twa_cdevsw, device_get_unit(sc->twa_bus_dev),
+                                       UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
+                                       "twa%d", device_get_unit(sc->twa_bus_dev));
+       sc->twa_ctrl_dev->si_drv1 = sc;
+
+       /*
+        * Schedule ourselves to bring the controller up once interrupts are
+        * available.  This isn't strictly necessary, since we disable
+        * interrupts while probing the controller, but it is more in keeping
+        * with common practice for other disk devices.
+        */
+       sc->twa_ich.ich_func = twa_intrhook;
+       sc->twa_ich.ich_arg = sc;
+       if (config_intrhook_establish(&sc->twa_ich) != 0) {
+               twa_printf(sc, "Can't establish configuration hook.\n");
+               twa_free(sc);
+               return(ENXIO);
+       }
+
+       if ((error = twa_cam_setup(sc))) {
+               twa_free(sc);
+               return(error);
+       }
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_free
+ * Description:                Performs clean-up at the time of going down.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_free(struct twa_softc *sc)
+{
+       struct twa_request      *tr;
+
+       twa_dbg_dprint_enter(3, sc);
+
+       /* Detach from CAM */
+       twa_cam_detach(sc);
+
+       /* Destroy dma handles. */
+
+       bus_dmamap_unload(sc->twa_dma_tag, sc->twa_cmd_map); 
+       while ((tr = twa_dequeue_free(sc)) != NULL)
+               bus_dmamap_destroy(sc->twa_dma_tag, tr->tr_dma_map);
+
+       /* Free all memory allocated so far. */
+       if (sc->twa_req_buf)
+               free(sc->twa_req_buf, TWA_MALLOC_CLASS);
+       if (sc->twa_cmd_pkt_buf)
+               bus_dmamem_free(sc->twa_dma_tag, sc->twa_cmd_pkt_buf,
+                                       sc->twa_cmd_map);
+       if (sc->twa_aen_queue[0])
+               free (sc->twa_aen_queue[0], M_DEVBUF);
+
+       /* Destroy the data-transfer DMA tag. */
+       if (sc->twa_dma_tag)
+               bus_dma_tag_destroy(sc->twa_dma_tag);
+
+       /* Disconnect the interrupt handler. */
+       if (sc->twa_intr_handle)
+               bus_teardown_intr(sc->twa_bus_dev, sc->twa_irq_res,
+                                       sc->twa_intr_handle);
+       if (sc->twa_irq_res != NULL)
+               bus_release_resource(sc->twa_bus_dev, SYS_RES_IRQ,
+                                       0, sc->twa_irq_res);
+
+       /* Release the register window mapping. */
+       if (sc->twa_io_res != NULL)
+               bus_release_resource(sc->twa_bus_dev, SYS_RES_IOPORT,
+                                       TWA_IO_CONFIG_REG, sc->twa_io_res);
+
+       /* Destroy the control device. */
+       if (sc->twa_ctrl_dev != (dev_t)NULL)
+               destroy_dev(sc->twa_ctrl_dev);
+
+       sysctl_ctx_free(&sc->twa_sysctl_ctx);
+}
+
+
+
+/*
+ * Function name:      twa_detach
+ * Description:                Called when the controller is being detached from
+ *                     the pci bus.
+ *
+ * Input:              dev     -- bus device corresponding to the ctlr
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_detach(device_t dev)
+{
+       struct twa_softc        *sc = device_get_softc(dev);
+       int                     s;
+       int                     error;
+
+       twa_dbg_dprint_enter(3, sc);
+
+       error = EBUSY;
+       s = splcam();
+       if (sc->twa_state & TWA_STATE_OPEN)
+               goto out;
+
+       /* Shut the controller down. */
+       if ((error = twa_shutdown(dev)))
+               goto out;
+
+       /* Free all resources associated with this controller. */
+       twa_free(sc);
+       error = 0;
+
+out:
+       splx(s);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_shutdown
+ * Description:                Called at unload/shutdown time.  Lets the controller
+ *                     know that we are going down.
+ *
+ * Input:              dev     -- bus device corresponding to the ctlr
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_shutdown(device_t dev)
+{
+       struct twa_softc        *sc = device_get_softc(dev);
+       int                     s;
+       int                     error = 0;
+
+       twa_dbg_dprint_enter(3, sc);
+
+       s = splcam();
+
+       /* Disconnect from the controller. */
+       error = twa_deinit_ctlr(sc);
+
+       splx(s);
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_suspend
+ * Description:                Called to suspend I/O before hot-swapping PCI ctlrs.
+ *                     Doesn't do much as of now.
+ *
+ * Input:              dev     -- bus device corresponding to the ctlr
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_suspend(device_t dev)
+{
+       struct twa_softc        *sc = device_get_softc(dev);
+       int                     s;
+
+       twa_dbg_dprint_enter(3, sc);
+
+       s = splcam();
+       sc->twa_state |= TWA_STATE_SUSPEND;
+    
+       twa_disable_interrupts(sc);
+       splx(s);
+
+       return(1);
+}
+
+
+
+/*
+ * Function name:      twa_resume
+ * Description:                Called to resume I/O after hot-swapping PCI ctlrs.
+ *                     Doesn't do much as of now.
+ *
+ * Input:              dev     -- bus device corresponding to the ctlr
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+static int
+twa_resume(device_t dev)
+{
+       struct twa_softc        *sc = device_get_softc(dev);
+
+       twa_dbg_dprint_enter(3, sc);
+
+       sc->twa_state &= ~TWA_STATE_SUSPEND;
+       twa_enable_interrupts(sc);
+
+       return(1);
+}
+
+
+
+/*
+ * Function name:      twa_pci_intr
+ * Description:                Interrupt handler.  Wrapper for twa_interrupt.
+ *
+ * Input:              arg     -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_pci_intr(void *arg)
+{
+       struct twa_softc        *sc = (struct twa_softc *)arg;
+
+       twa_interrupt(sc);
+}
+
+
+
+/*
+ * Function name:      twa_intrhook
+ * Description:                Callback for us to enable interrupts.
+ *
+ * Input:              arg     -- ptr to per ctlr structure
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_intrhook(void *arg)
+{
+       struct twa_softc        *sc = (struct twa_softc *)arg;
+
+       twa_dbg_dprint(4, sc, "twa_intrhook Entered");
+
+       /* Pull ourselves off the intrhook chain. */
+       config_intrhook_disestablish(&sc->twa_ich);
+
+       /* Enable interrupts. */
+       twa_enable_interrupts(sc);
+}
+
+
+
+/*
+ * Function name:      twa_write_pci_config
+ * Description:                Writes to the PCI config space.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     value   -- value to be written
+ *                     size    -- # of bytes to be written
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_write_pci_config(struct twa_softc *sc, u_int32_t value, int size)
+{
+       pci_write_config(sc->twa_bus_dev, PCIR_STATUS, value, size);
+}
+
+
+
+/*
+ * Function name:      twa_alloc_req_pkts
+ * Description:                Allocates memory for, and initializes request pkts,
+ *                     and queues them in the free queue.
+ *
+ * Input:              sc      -- ptr to per ctlr structure
+ *                     num_reqs-- # of request pkts to allocate and initialize.
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_alloc_req_pkts(struct twa_softc *sc, int num_reqs)
+{
+       struct twa_request      *tr;
+       int                     i;
+
+       if ((sc->twa_req_buf = malloc(num_reqs * sizeof(struct twa_request),
+                                       TWA_MALLOC_CLASS, M_NOWAIT)) == NULL)
+               return(ENOMEM);
+
+       /* Allocate the bus DMA tag appropriate for PCI. */
+       if (bus_dma_tag_create(NULL,                    /* parent */
+                               TWA_ALIGNMENT,          /* alignment */
+                               0,                      /* boundary */
+                               BUS_SPACE_MAXADDR,      /* lowaddr */
+                               BUS_SPACE_MAXADDR + 1,  /* highaddr */
+                               NULL, NULL,             /* filter, filterarg */
+                               TWA_Q_LENGTH *
+                               (sizeof(struct twa_command_packet)),/* maxsize */
+                               TWA_MAX_SG_ELEMENTS,    /* nsegments */
+                               BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
+                               BUS_DMA_ALLOCNOW,       /* flags */
+                               &sc->twa_dma_tag        /* tag */)) {
+               twa_printf(sc, "Can't allocate DMA tag.\n");
+               return(ENOMEM);
+       }
+
+       /* Allocate memory for cmd pkts. */
+       if (bus_dmamem_alloc(sc->twa_dma_tag,
+                               (void *)(&(sc->twa_cmd_pkt_buf)),
+                               BUS_DMA_WAITOK, &(sc->twa_cmd_map)))
+               return(ENOMEM);
+
+       bus_dmamap_load(sc->twa_dma_tag, sc->twa_cmd_map,
+                               sc->twa_cmd_pkt_buf,
+                               num_reqs * sizeof(struct twa_command_packet),
+                               twa_setup_request_dmamap, sc, 0);
+       bzero(sc->twa_req_buf, num_reqs * sizeof(struct twa_request));
+       bzero(sc->twa_cmd_pkt_buf,
+                       num_reqs * sizeof(struct twa_command_packet));
+
+       for (i = 0; i < num_reqs; i++) {
+               tr = &(sc->twa_req_buf[i]);
+               tr->tr_command = &(sc->twa_cmd_pkt_buf[i]);
+               tr->tr_cmd_phys = sc->twa_cmd_pkt_phys +
+                                       (i * sizeof(struct twa_command_packet));
+               tr->tr_request_id = i;
+               tr->tr_sc = sc;
+               sc->twa_lookup[i] = tr;
+
+               /*
+                * Create a map for data buffers.  maxsize (256 * 1024) used in
+                * bus_dma_tag_create above should suffice the bounce page needs
+                * for data buffers, since the max I/O size we support is 128KB.
+                * If we supported I/O's bigger than 256KB, we would have to
+                * create a second dma_tag, with the appropriate maxsize.
+                */
+               if (bus_dmamap_create(sc->twa_dma_tag, 0,
+                                               &tr->tr_dma_map))
+                       return(ENOMEM);
+
+               /* Insert request into the free queue. */
+               twa_release_request(tr);
+       }
+       return(0);
+}
+
+
+
+/*
+ * Function name:      twa_fillin_sgl
+ * Description:                Fills in the scatter/gather list.
+ *
+ * Input:              sgl     -- ptr to sg list
+ *                     segs    -- ptr to fill the sg list from
+ *                     nsegments--# of segments
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_fillin_sgl(struct twa_sg *sgl, bus_dma_segment_t *segs, int nsegments)
+{
+       int     i;
+
+       for (i = 0; i < nsegments; i++) {
+               sgl[i].address = segs[i].ds_addr;
+               sgl[i].length = segs[i].ds_len;
+       }
+}
+
+
+
+/*
+ * Function name:      twa_setup_data_dmamap
+ * Description:                Callback of bus_dmamap_load for the buffer associated
+ *                     with data.  Updates the cmd pkt (size/sgl_entries
+ *                     fields, as applicable) to reflect the number of sg
+ *                     elements.
+ *
+ * Input:              arg     -- ptr to request pkt
+ *                     segs    -- ptr to a list of segment descriptors
+ *                     nsegments--# of segments
+ *                     error   -- 0 if no errors encountered before callback,
+ *                                non-zero if errors were encountered
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs,
+                                       int nsegments, int error)
+{
+       struct twa_request              *tr = (struct twa_request *)arg;
+       struct twa_command_packet       *cmdpkt = tr->tr_command;
+       struct twa_command_9k           *cmd9k;
+       union twa_command_7k            *cmd7k;
+       u_int8_t                        sgl_offset;
+
+       twa_dbg_dprint_enter(10, tr->tr_sc);
+
+       if ((tr->tr_flags & TWA_CMD_IN_PROGRESS) &&
+                       (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL))
+               twa_allow_new_requests(tr->tr_sc, (void *)(tr->tr_private));
+
+       if (error == EFBIG) {
+               tr->tr_error = error;
+               goto out;
+       }
+
+       if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) {
+               cmd9k = &(cmdpkt->command.cmd_pkt_9k);
+               twa_fillin_sgl(&(cmd9k->sg_list[0]), segs, nsegments);
+               cmd9k->sgl_entries += nsegments - 1;
+       } else {
+               /* It's a 7000 command packet. */
+               cmd7k = &(cmdpkt->command.cmd_pkt_7k);
+               if ((sgl_offset = cmdpkt->command.cmd_pkt_7k.generic.sgl_offset))
+                       twa_fillin_sgl((struct twa_sg *)
+                                       (((u_int32_t *)cmd7k) + sgl_offset),
+                                       segs, nsegments);
+               /* Modify the size field, based on sg address size. */
+               cmd7k->generic.size += 
+                               ((TWA_64BIT_ADDRESSES ? 3 : 2) * nsegments);
+       }
+
+       if (tr->tr_flags & TWA_CMD_DATA_IN)
+               bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map,
+                                                       BUS_DMASYNC_PREREAD);
+       if (tr->tr_flags & TWA_CMD_DATA_OUT) {
+               /* 
+                * If we're using an alignment buffer, and we're
+                * writing data, copy the real data out.
+                */
+               if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED)
+                       bcopy(tr->tr_real_data, tr->tr_data, tr->tr_real_length);
+               bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map,
+                                               BUS_DMASYNC_PREWRITE);
+       }
+       error = twa_submit_io(tr);
+
+out:
+       if (error) {
+               twa_unmap_request(tr);
+               /*
+                * If the caller had been returned EINPROGRESS, and he has
+                * registered a callback for handling completion, the callback
+                * will never get called because we were unable to submit the
+                * request.  So, free up the request right here.
+                */
+               if ((tr->tr_flags & TWA_CMD_IN_PROGRESS) && (tr->tr_callback))
+                       twa_release_request(tr);
+       }
+}
+
+
+
+/*
+ * Function name:      twa_setup_request_dmamap
+ * Description:                Callback of bus_dmamap_load for the buffer associated
+ *                     with a cmd pkt.
+ *
+ * Input:              arg     -- ptr to request pkt
+ *                     segs    -- ptr to a list of segment descriptors
+ *                     nsegments--# of segments
+ *                     error   -- 0 if no errors encountered before callback,
+ *                                non-zero if errors were encountered
+ * Output:             None
+ * Return value:       None
+ */
+static void
+twa_setup_request_dmamap(void *arg, bus_dma_segment_t *segs,
+                                               int nsegments, int error)
+{
+       struct twa_softc        *sc = (struct twa_softc *)arg;
+
+       twa_dbg_dprint_enter(10, sc);
+
+       sc->twa_cmd_pkt_phys = segs[0].ds_addr;
+}
+
+
+
+/*
+ * Function name:      twa_map_request
+ * Description:                Maps a cmd pkt and data associated with it, into
+ *                     DMA'able memory.
+ *
+ * Input:              tr      -- ptr to request pkt
+ * Output:             None
+ * Return value:       0       -- success
+ *                     non-zero-- failure
+ */
+int
+twa_map_request(struct twa_request *tr)
+{
+       struct twa_softc        *sc = tr->tr_sc;
+       int                     error = 0;
+
+       twa_dbg_dprint_enter(10, sc);
+
+       /* If the command involves data, map that too. */
+       if (tr->tr_data != NULL) {
+               /*
+                * It's sufficient for the data pointer to be 4-byte aligned
+                * to work with 9000.  However, if 4-byte aligned addresses
+                * are passed to bus_dmamap_load, we can get back sg elements
+                * that are not 512-byte multiples in size.  So, we will let
+                * only those buffers that are 512-byte aligned to pass
+                * through, and bounce the rest, so as to make sure that we
+                * always get back sg elements that are 512-byte multiples
+                * in size.
+                */
+               if (((vm_offset_t)tr->tr_data % 512) || (tr->tr_length % 512)) {
+                       tr->tr_flags |= TWA_CMD_DATA_COPY_NEEDED;
+                       tr->tr_real_data = tr->tr_data; /* save original data pointer */
+                       tr->tr_real_length = tr->tr_length; /* save original data length */
+                       tr->tr_length = (tr->tr_length + 511) & ~511;
+                       tr->tr_data = malloc(tr->tr_length, TWA_MALLOC_CLASS, M_NOWAIT);
+                       if (tr->tr_data == NULL) {
+                               twa_printf(sc, "%s: malloc failed\n", __func__);
+                               tr->tr_data = tr->tr_real_data; /* restore original data pointer */
+                               tr->tr_length = tr->tr_real_length; /* restore original data length */
+                               return(ENOMEM);
+                       }
+               }
+       
+               /*
+                * Map the data buffer into bus space and build the s/g list.
+                */
+               if ((error = bus_dmamap_load(sc->twa_dma_tag, tr->tr_dma_map,
+                                       tr->tr_data, tr->tr_length, 
+                                       twa_setup_data_dmamap, tr,
+                                       BUS_DMA_WAITOK))) {
+                       if (error == EINPROGRESS) {
+                               tr->tr_flags |= TWA_CMD_IN_PROGRESS;
+                               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
+                                       twa_disallow_new_requests(sc);
+                               error = 0;
+                       } else {
+                               /* Free alignment buffer if it was used. */
+                               if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) {
+                                       free(tr->tr_data, TWA_MALLOC_CLASS);
+                                       tr->tr_data = tr->tr_real_data; /* restore 'real' data pointer */
+                                       tr->tr_length = tr->tr_real_length;/* restore 'real' data length */
+                               }
+                       }
+               } else
+                       error = tr->tr_error;
+
+       } else
+               if ((error = twa_submit_io(tr)))
+                       twa_unmap_request(tr);
+
+       return(error);
+}
+
+
+
+/*
+ * Function name:      twa_unmap_request
+ * Description:                Undoes the mapping done by twa_map_request.
+ *
+ * Input:              tr      -- ptr to request pkt
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_unmap_request(struct twa_request *tr)
+{
+       struct twa_softc        *sc = tr->tr_sc;
+       u_int8_t                cmd_status;
+
+       twa_dbg_dprint_enter(10, sc);
+
+       /* If the command involved data, unmap that too. */
+       if (tr->tr_data != NULL) {
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K)
+                       cmd_status = tr->tr_command->command.cmd_pkt_9k.status;
+               else
+                       cmd_status = tr->tr_command->command.cmd_pkt_7k.generic.status;
+
+               if (tr->tr_flags & TWA_CMD_DATA_IN) {
+                       bus_dmamap_sync(sc->twa_dma_tag,
+                                       tr->tr_dma_map, BUS_DMASYNC_POSTREAD);
+
+                       /* 
+                        * If we are using a bounce buffer, and we are reading
+                        * data, copy the real data in.
+                        */
+                       if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED)
+                               if (cmd_status == 0)
+                                       bcopy(tr->tr_data, tr->tr_real_data,
+                                                       tr->tr_real_length);
+               }
+               if (tr->tr_flags & TWA_CMD_DATA_OUT)
+                       bus_dmamap_sync(sc->twa_dma_tag, tr->tr_dma_map,
+                                                       BUS_DMASYNC_POSTWRITE);
+
+               bus_dmamap_unload(sc->twa_dma_tag, tr->tr_dma_map); 
+       }
+
+       /* Free alignment buffer if it was used. */
+       if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) {
+               free(tr->tr_data, TWA_MALLOC_CLASS);
+               tr->tr_data = tr->tr_real_data; /* restore 'real' data pointer */
+               tr->tr_length = tr->tr_real_length;/* restore 'real' data length */
+       }
+}
+
+
+
+#ifdef TWA_DEBUG
+void   twa_report(void);
+void   twa_reset_stats(void);
+void   twa_print_request(struct twa_request *tr, int req_type);
+
+
+
+/*
+ * Function name:      twa_report
+ * Description:                For being called from ddb.  Prints controller stats,
+ *                     and requests, if any, that are in the wrong queue.
+ *
+ * Input:              None
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_report(void)
+{
+       struct twa_softc        *sc;
+       struct twa_request      *tr;
+       int                     s;
+       int                     i;
+
+       s = splcam();
+       for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
+               twa_print_controller(sc);
+               TAILQ_FOREACH(tr, &sc->twa_busy, tr_link)
+                       twa_print_request(tr, TWA_CMD_BUSY);
+               TAILQ_FOREACH(tr, &sc->twa_complete, tr_link)
+                       twa_print_request(tr, TWA_CMD_COMPLETE);
+       }
+       splx(s);
+}
+
+
+
+/*
+ * Function name:      twa_reset_stats
+ * Description:                For being called from ddb.
+ *                     Resets some controller stats.
+ *
+ * Input:              None
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_reset_stats(void)
+{
+       struct twa_softc        *sc;
+       int                     s;
+       int                     i;
+
+       s = splcam();
+       for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
+               sc->twa_qstats[TWAQ_FREE].q_max = 0;
+               sc->twa_qstats[TWAQ_BUSY].q_max = 0;
+               sc->twa_qstats[TWAQ_PENDING].q_max = 0;
+               sc->twa_qstats[TWAQ_COMPLETE].q_max = 0;
+       }
+       splx(s);
+}
+
+
+
+/*
+ * Function name:      twa_print_request
+ * Description:                Prints a given request if it's in the wrong queue.
+ *
+ * Input:              tr      -- ptr to request pkt
+ *                     req_type-- expected status of the given request
+ * Output:             None
+ * Return value:       None
+ */
+void
+twa_print_request(struct twa_request *tr, int req_type)
+{
+       struct twa_softc                *sc = tr->tr_sc;
+       struct twa_command_packet       *cmdpkt = tr->tr_command;
+       struct twa_command_9k           *cmd9k;
+       union twa_command_7k            *cmd7k;
+       u_int8_t                        *cdb;
+       int                             cmd_phys_addr;
+
+       if (tr->tr_status != req_type) {
+               twa_printf(sc, "Invalid %s request %p in queue! req_type = %x, queue_type = %x\n",
+                       (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ? "INTERNAL" : "EXTERNAL",
+                       tr, tr->tr_status, req_type);
+
+               if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) {
+                       cmd9k = &(cmdpkt->command.cmd_pkt_9k);
+                       cmd_phys_addr = cmd9k->sg_list[0].address;
+                       twa_printf(sc, "9K cmd = %x %x %x %x %x %x %x %x %x\n",
+                                       cmd9k->command.opcode,
+                                       cmd9k->command.reserved,
+                                       cmd9k->unit,
+                                       cmd9k->request_id,
+                                       cmd9k->status,
+                                       cmd9k->sgl_offset,
+                                       cmd9k->sgl_entries,
+                                       cmd_phys_addr,
+                                       cmd9k->sg_list[0].length);
+                       cdb = (u_int8_t *)(cmdpkt->command.cmd_pkt_9k.cdb);
+                       twa_printf(sc, "cdb = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n",
+                               cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7],
+                               cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]);
+               } else {
+                       cmd7k = &(cmdpkt->command.cmd_pkt_7k);
+                       twa_printf(sc, "7K cmd = %x %x %x %x %x %x %x %x %x\n",
+                                       cmd7k->generic.opcode,
+                                       cmd7k->generic.sgl_offset,
+                                       cmd7k->generic.size,
+                                       cmd7k->generic.request_id,
+                                       cmd7k->generic.unit,
+                                       cmd7k->generic.host_id,
+                                       cmd7k->generic.status,
+                                       cmd7k->generic.flags,
+                                       cmd7k->generic.count);
+               }
+
+               cmd_phys_addr = (int)(tr->tr_cmd_phys);
+               twa_printf(sc, "cmdphys=0x%x data=%p length=0x%x\n",
+                               cmd_phys_addr, tr->tr_data, tr->tr_length);
+               twa_printf(sc, "req_id=0x%x flags=0x%x callback=%p private=%p\n",
+                                       tr->tr_request_id, tr->tr_flags,
+                                       tr->tr_callback, tr->tr_private);
+       }
+}
+#endif
diff --git a/sys/dev/raid/twa/twa_fwimg.c b/sys/dev/raid/twa/twa_fwimg.c
new file mode 100644 (file)
index 0000000..5828bca
--- /dev/null
@@ -0,0 +1,23839 @@
+/*-
+ * Copyright (c) 2003-04 3ware, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     $FreeBSD$
+ * $DragonFly: src/sys/dev/raid/twa/twa_fwimg.c,v 1.1 2004/04/16 20:13:16 drhodus Exp $
+ */
+
+/*
+ * 3ware driver for 9000 series storage controllers.
+ *
+ * Author: Vinod Kashyap
+ */
+
+
+#include "opt_twa.h"
+
+#ifdef TWA_FLASH_FIRMWARE
+
+char  twa_fw_img[] = {
+1,0,208,0,196,66,7,0,51,71,250,136,5,0,0,0,8,8,8,8,
+8,8,8,8,8,8,8,8,8,8,51,119,97,114,101,32,69,115,99,97,
+108,97,100,101,32,70,105,114,109,119,97,114,101,32,73,109,97,103,101,32,
+40,67,41,32,50,48,48,51,45,50,48,48,52,32,51,119,97,114,101,32,
+73,110,99,46,13,10,66,117,105,108,116,32,98,121,32,70,108,97,115,104,
+73,109,97,103,101,67,111,109,112,111,115,101,114,32,49,46,48,51,32,111,
+110,32,70,114,105,32,77,97,114,32,49,57,32,49,50,58,52,52,58,52,
+48,32,50,48,48,52,10,13,10,72,101,97,100,101,114,32,82,101,118,105,
+115,105,111,110,32,48,49,13,10,70,69,57,88,32,50,46,48,50,46,48,
+48,46,48,48,56,13,10,66,69,57,88,32,50,46,48,50,46,48,49,46,
+48,51,55,13,10,26,0,0,3,30,200,255,99,39,53,0,99,167,49,0,
+99,175,45,0,99,183,41,0,99,191,37,0,99,199,33,0,99,207,29,0,
+99,215,25,0,99,255,21,0,99,223,17,0,99,231,13,0,99,239,9,0,
+128,255,4,0,31,232,93,38,1,0,36,38,24,90,4,38,0,64,4,38,
+0,64,93,54,0,0,38,54,176,0,102,31,1,0,93,30,1,0,35,30,
+20,90,93,54,0,0,38,54,144,0,28,10,64,14,128,0,1,14,80,58,
+162,5,1,240,93,86,0,0,42,86,228,54,234,167,32,0,128,255,124,0,
+93,54,0,0,38,54,176,0,38,31,1,0,35,255,21,0,35,239,9,0,
+35,231,13,0,35,223,17,0,35,215,25,0,35,207,29,0,35,199,33,0,
+35,191,37,0,35,183,41,0,35,175,45,0,35,167,49,0,35,39,53,0,
+3,30,56,0,127,0,0,0,1,0,0,0,0,0,0,0,80,58,128,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,70,108,97,115,104,32,85,112,100,97,116,101,114,0,20,0,
+138,7,225,255,128,239,4,0,6,16,93,78,0,0,41,78,14,48,93,214,
+0,0,58,214,200,46,93,206,0,0,57,206,126,46,93,174,0,0,53,174,
+28,56,0,226,26,160,99,79,1,0,34,143,1,0,97,138,234,29,2,134,
+4,0,48,223,1,0,2,126,8,0,47,199,1,0,2,118,12,0,46,191,
+1,0,2,110,16,0,45,255,1,0,2,102,20,0,44,183,1,0,2,94,
+24,0,43,135,1,0,2,86,28,0,42,143,1,0,245,13,34,223,1,0,
+2,142,4,0,49,199,1,0,2,134,8,0,48,191,1,0,0,178,0,250,
+0,138,0,130,241,129,178,53,16,16,191,17,99,7,5,0,35,118,4,0,
+14,126,4,0,111,7,1,0,35,102,4,0,12,110,8,0,109,7,1,0,
+35,86,4,0,10,94,12,0,107,7,1,0,240,169,177,5,245,137,187,5,
+2,224,128,225,240,161,177,5,244,137,251,5,2,80,218,81,10,208,2,80,
+217,81,10,200,35,151,1,0,242,129,251,45,35,159,1,0,241,153,185,45,
+246,249,146,45,162,73,245,37,99,7,5,0,35,134,4,0,16,142,4,0,
+93,118,128,255,46,118,252,254,14,120,187,121,113,127,1,0,35,102,4,0,
+12,110,8,0,68,86,254,255,42,86,0,96,10,88,184,89,109,95,1,0,
+35,134,4,0,16,142,12,0,68,118,126,255,46,118,176,37,14,120,183,121,
+113,127,1,0,93,110,0,0,45,110,28,56,28,216,205,217,93,102,0,0,
+44,102,52,56,28,192,204,193,181,29,68,218,27,94,252,255,35,142,4,0,
+17,86,12,0,42,23,1,0,43,135,1,0,208,17,59,87,1,0,68,218,
+59,95,1,0,68,218,2,48,10,56,11,64,93,254,0,0,63,254,138,1,
+122,0,248,217,218,229,93,126,0,0,47,126,52,56,28,216,207,217,93,118,
+0,0,46,118,52,56,28,208,206,209,93,110,0,0,45,110,52,56,28,192,
+205,193,181,45,250,217,137,13,35,94,4,0,11,102,12,0,44,23,1,0,
+245,5,35,142,4,0,17,86,4,0,42,23,1,0,59,135,1,0,208,17,
+68,218,68,218,27,126,252,255,35,110,4,0,13,118,4,0,46,87,1,0,
+47,103,1,0,204,81,59,95,1,0,68,218,2,48,10,56,11,64,93,254,
+0,0,63,254,8,2,121,0,248,217,218,213,93,198,0,0,56,198,62,47,
+93,94,0,0,43,94,52,56,28,216,203,217,93,86,0,0,42,86,52,56,
+28,208,202,209,93,142,0,0,49,142,52,56,28,200,209,201,181,45,250,217,
+137,13,35,126,4,0,15,134,12,0,48,23,1,0,245,5,35,110,4,0,
+13,118,4,0,46,23,1,0,59,103,1,0,204,17,68,218,68,218,27,94,
+252,255,35,142,4,0,17,86,4,0,42,87,1,0,43,135,1,0,208,81,
+59,95,1,0,68,218,2,48,10,56,11,64,93,254,0,0,63,254,142,2,
+120,0,249,217,218,213,93,126,0,0,47,126,52,56,28,16,207,17,93,118,
+0,0,46,118,20,57,28,64,206,65,93,110,0,0,45,110,20,57,28,56,
+205,57,226,65,162,77,35,94,4,0,11,102,12,0,68,142,126,255,49,142,
+176,37,44,135,1,0,17,80,176,81,170,65,197,61,65,58,7,126,255,255,
+15,55,0,0,198,118,48,0,14,104,164,106,13,88,194,90,11,96,35,142,
+4,0,12,80,209,81,42,87,1,0,68,18,2,134,252,255,48,127,1,0,
+10,248,207,249,63,79,1,0,198,118,128,0,224,113,178,5,224,73,178,29,
+198,110,3,0,13,88,194,90,11,96,35,142,4,0,12,80,209,81,42,87,
+1,0,224,81,226,13,198,134,8,0,224,129,162,5,194,74,202,73,198,126,
+8,0,224,121,162,5,162,74,127,79,1,0,232,17,202,197,128,255,8,0,
+74,6,255,255,130,7,225,241,58,6,64,48,32,16,64,198,16,0,57,6,
+68,51,34,17,55,6,192,176,160,144,128,255,194,17,31,88,128,255,4,0,
+31,80,11,248,10,224,162,226,194,226,128,255,150,2,10,16,224,17,178,5,
+128,7,250,1,0,218,27,16,194,18,2,104,220,105,13,80,42,127,1,0,
+250,121,250,5,28,112,194,113,46,103,5,0,249,97,178,13,42,95,1,0,
+250,89,170,29,28,80,194,81,42,135,5,0,247,129,202,21,13,232,28,120,
+194,121,47,111,5,0,247,105,138,13,128,255,12,4,61,23,13,0,234,17,
+250,5,181,13,29,48,128,255,182,1,224,81,226,5,65,218,128,94,0,240,
+235,217,134,213,128,86,0,240,234,217,218,5,32,86,195,1,128,7,134,1,
+61,143,1,0,250,137,234,37,61,135,5,0,247,129,170,37,128,255,38,4,
+10,48,253,63,11,0,61,71,13,0,221,57,128,255,206,4,10,16,224,17,
+178,5,128,7,88,1,253,95,11,0,221,89,61,239,13,0,203,233,61,87,
+1,0,250,81,218,5,61,143,5,0,249,137,210,5,32,86,195,1,128,7,
+52,1,128,255,228,3,248,81,170,13,128,255,128,3,10,224,216,225,128,255,
+166,3,10,216,220,217,181,5,64,222,16,0,29,224,213,13,28,48,128,255,
+30,1,10,16,224,17,178,5,128,7,2,1,28,48,128,255,122,1,10,224,
+224,225,186,245,128,255,74,3,10,224,216,225,60,127,1,0,250,121,218,5,
+60,119,5,0,249,113,162,5,27,224,60,111,1,0,250,105,202,37,60,103,
+5,0,249,97,138,37,28,48,128,255,68,1,10,224,60,87,1,0,43,6,
+128,112,96,80,235,81,186,21,60,135,5,0,49,6,136,119,102,85,241,129,
+202,13,60,127,21,0,224,121,226,5,28,48,128,255,24,1,10,224,229,5,
+0,226,197,5,0,226,165,5,0,226,27,48,61,71,13,0,29,56,128,255,
+236,3,10,16,224,17,202,61,61,111,21,0,224,105,242,53,61,95,13,0,
+29,48,129,90,193,90,203,217,128,255,224,0,10,232,224,225,178,21,187,225,
+125,231,21,0,61,127,13,0,61,119,21,0,239,113,185,5,125,7,21,0,
+29,48,128,255,68,0,61,111,21,0,106,111,21,0,27,48,61,71,13,0,
+29,56,128,255,152,3,10,16,224,17,170,21,128,255,122,2,10,232,216,233,
+61,95,5,0,249,89,154,13,31,82,99,87,1,0,29,48,3,56,4,66,
+128,255,114,3,0,82,66,6,255,241,38,87,13,0,230,135,11,0,198,81,
+176,81,127,0,128,7,97,0,6,232,191,255,236,255,10,16,61,135,1,0,
+49,6,64,48,32,16,241,129,178,13,61,119,1,0,47,6,128,112,96,80,
+239,113,194,5,32,86,200,1,229,29,34,103,1,0,45,6,64,48,32,16,
+237,97,178,13,34,87,1,0,43,6,128,112,96,80,235,81,194,5,32,86,
+200,1,213,13,29,48,2,56,253,71,11,0,128,255,102,35,224,81,194,5,
+32,86,200,1,165,5,0,82,64,6,127,0,38,143,21,0,224,137,210,5,
+38,87,21,0,198,81,165,5,0,82,127,0,128,7,225,0,128,239,4,0,
+0,50,128,255,58,3,100,87,13,128,36,23,13,128,34,23,17,0,93,254,
+0,0,34,127,16,0,63,254,44,0,36,55,13,128,15,112,34,111,21,0,
+206,49,109,0,10,224,224,225,210,5,36,55,13,128,128,255,22,14,224,225,
+226,29,0,50,128,255,196,6,100,87,13,128,36,23,13,128,34,23,17,0,
+93,254,0,0,34,135,16,0,63,254,106,0,36,55,13,128,16,120,34,119,
+21,0,207,49,110,0,10,224,224,225,210,5,36,55,13,128,128,255,216,13,
+224,225,186,5,128,255,10,0,28,80,64,6,255,0,128,7,225,112,128,239,
+4,0,36,23,13,128,34,23,17,0,93,254,0,0,34,127,24,0,63,254,
+34,0,36,55,13,128,15,112,34,111,29,0,206,49,109,0,36,23,13,128,
+10,224,34,23,17,0,93,254,0,0,34,87,56,0,63,254,70,0,36,55,
+13,128,10,136,34,135,61,0,209,49,112,0,234,225,250,109,36,231,13,128,
+60,231,17,0,36,223,13,128,93,254,0,0,59,223,17,0,63,254,124,0,
+60,103,24,0,27,222,40,0,36,55,13,128,12,88,60,87,29,0,203,49,
+28,230,24,0,106,0,59,135,0,0,10,224,36,55,13,128,16,120,207,49,
+59,119,5,0,93,254,0,0,63,254,152,0,110,0,36,223,13,128,10,200,
+59,223,17,0,220,201,36,231,13,128,60,231,17,0,93,254,0,0,36,215,
+13,128,63,254,218,0,58,215,17,0,28,230,40,0,59,143,24,0,26,214,
+48,0,36,55,13,128,17,128,59,127,29,0,208,49,27,222,24,0,111,0,
+60,111,0,0,10,216,36,55,13,128,13,96,204,49,60,95,5,0,93,254,
+0,0,63,254,246,0,107,0,10,224,58,143,0,0,219,225,36,55,13,128,
+17,128,208,49,58,127,5,0,93,254,0,0,63,254,20,1,111,0,25,48,
+220,81,10,62,8,0,128,255,236,0,100,87,17,128,181,5,100,231,17,128,
+64,6,255,112,127,0,128,7,97,0,128,239,4,0,36,23,13,128,34,23,
+17,0,93,254,0,0,34,127,40,0,63,254,34,0,36,55,13,128,15,112,
+34,111,45,0,206,49,109,0,64,6,127,0,128,7,97,0,128,239,4,0,
+36,23,13,128,34,23,17,0,93,254,0,0,34,127,48,0,63,254,34,0,
+36,55,13,128,15,112,34,111,53,0,206,49,109,0,64,6,127,0,128,7,
+97,0,128,239,4,0,36,23,13,128,34,23,17,0,93,254,0,0,34,127,
+56,0,63,254,34,0,36,55,13,128,15,112,34,111,61,0,206,49,109,0,
+64,6,127,0,12,0,128,7,97,0,6,232,61,135,1,0,49,6,64,48,
+32,16,241,129,178,13,61,119,1,0,47,6,128,112,96,80,239,113,194,5,
+32,86,202,1,133,21,29,48,128,255,184,0,29,48,10,56,253,71,11,0,
+128,255,182,32,224,81,194,5,32,86,202,1,165,5,0,82,64,6,127,0,
+128,7,128,7,225,16,7,216,6,232,149,21,61,135,1,0,49,6,64,48,
+32,16,241,129,154,13,29,224,28,48,191,255,152,255,224,81,186,5,28,80,
+213,5,68,234,251,233,241,237,0,82,64,6,255,16,52,0,154,7,24,0,
+140,7,128,7,225,112,128,239,4,0,6,216,7,208,8,200,229,87,64,0,
+224,7,96,1,36,23,13,128,10,224,34,23,17,0,27,56,34,127,8,0,
+26,64,36,55,13,128,15,112,206,49,25,72,34,111,13,0,93,254,0,0,
+63,254,56,0,109,0,10,216,252,47,32,0,27,80,64,6,255,112,128,7,
+128,7,140,7,152,7,128,7,128,7,38,143,38,87,13,0,230,135,11,0,
+198,81,176,81,127,0,24,0,128,7,33,0,6,16,224,17,138,13,32,54,
+36,0,128,255,34,11,10,16,224,17,226,45,68,142,0,0,49,142,24,139,
+98,143,17,0,68,134,0,0,48,134,164,139,98,135,17,0,64,126,16,0,
+98,127,5,0,32,118,0,64,98,119,13,0,64,110,16,0,98,111,1,0,
+34,103,1,0,12,102,170,10,98,103,21,0,34,95,1,0,11,94,84,5,
+98,95,25,0,34,87,1,0,98,87,29,0,34,143,1,0,66,138,98,143,
+33,0,2,80,64,6,63,0,38,23,1,0,2,80,127,0,38,23,5,0,
+2,80,127,0,38,23,13,0,2,80,127,0,68,134,0,0,48,134,88,139,
+16,142,4,0,68,110,0,0,45,110,88,139,13,118,8,0,46,127,1,0,
+49,103,1,0,204,121,15,88,202,90,11,16,2,80,127,0,38,23,1,0,
+2,80,127,0,128,7,193,16,6,232,0,226,229,87,64,0,224,7,96,1,
+10,216,61,143,21,0,32,134,170,0,113,135,0,0,61,127,25,0,32,118,
+85,0,111,119,0,0,61,111,21,0,32,102,144,0,109,103,0,0,61,95,
+1,0,235,87,1,0,202,142,255,0,17,128,208,130,61,127,33,0,239,119,
+1,0,14,224,16,225,61,111,21,0,32,102,240,0,109,103,0,0,251,47,
+32,0,43,6,91,34,1,0,235,225,186,5,0,18,229,13,42,6,186,34,
+1,0,234,225,250,5,64,142,8,0,125,143,5,0,0,18,181,5,32,22,
+192,1,2,80,64,6,223,16,128,7,225,247,6,216,7,200,8,184,9,192,
+59,143,1,0,241,201,161,13,24,128,217,129,59,127,5,0,59,119,1,0,
+206,121,239,129,195,5,32,22,193,1,165,125,64,54,1,0,128,255,112,9,
+10,16,2,208,26,168,224,209,202,5,32,22,21,1,229,109,0,18,59,231,
+1,0,0,18,229,21,2,96,194,98,12,104,68,86,0,0,42,86,88,139,
+13,88,202,89,43,239,1,0,29,136,202,138,17,232,29,128,220,129,240,201,
+129,13,29,120,207,225,65,18,2,112,14,6,180,255,137,237,2,176,133,77,
+22,96,194,98,12,104,68,86,0,0,42,86,88,139,13,88,202,89,43,239,
+1,0,29,136,202,138,17,232,27,48,28,56,26,64,29,72,128,255,24,1,
+25,16,188,17,25,80,229,13,2,128,213,129,65,186,23,126,255,255,15,119,
+0,0,80,119,0,0,95,194,65,202,65,82,65,18,29,104,220,105,237,81,
+161,5,181,5,224,193,218,237,27,48,28,56,128,255,52,1,27,48,28,56,
+26,64,29,72,128,255,56,0,27,48,28,56,26,64,29,72,128,255,236,0,
+224,81,242,5,26,48,128,255,186,8,32,22,194,1,165,13,29,96,204,225,
+65,178,224,193,138,189,26,48,128,255,164,8,0,18,2,80,64,6,255,247,
+128,7,193,240,6,216,7,232,8,224,9,192,58,6,240,255,31,0,229,87,
+64,0,224,7,96,1,10,200,0,18,149,53,253,143,1,0,252,135,1,0,
+240,137,202,5,66,234,66,226,245,37,59,127,21,0,32,118,170,0,111,119,
+0,0,59,111,25,0,32,102,85,0,109,103,0,0,59,95,21,0,32,86,
+160,0,107,87,0,0,66,234,29,142,254,255,66,226,28,134,254,255,240,127,
+1,0,113,127,0,0,250,119,1,0,206,110,64,0,250,103,1,0,204,94,
+64,0,235,105,250,245,65,18,24,80,191,82,10,136,159,138,24,128,209,129,
+16,120,161,122,239,17,241,197,249,47,32,0,64,6,223,240,0,18,133,13,
+231,143,1,0,104,143,0,0,66,58,66,66,65,18,9,120,191,122,159,122,
+9,104,207,105,161,106,237,17,161,245,127,0,0,18,213,13,232,143,1,0,
+66,66,231,135,1,0,66,58,240,137,194,5,32,86,194,1,181,13,65,18,
+9,112,191,114,159,114,9,96,206,97,161,98,236,17,214,237,0,82,127,0,
+34,6,240,255,31,0,38,143,21,0,32,134,170,0,113,135,0,0,38,127,
+25,0,32,118,85,0,111,119,0,0,38,111,21,0,32,102,128,0,109,103,
+0,0,38,95,21,0,32,86,170,0,107,87,0,0,38,143,25,0,32,134,
+85,0,113,135,0,0,32,126,48,0,103,127,0,0,226,119,1,0,206,110,
+64,0,226,103,1,0,204,94,64,0,235,105,250,245,127,0,128,7,97,0,
+6,232,224,233,138,13,32,54,36,0,128,255,90,7,10,232,224,233,162,45,
+29,48,191,255,30,252,68,142,0,0,49,142,228,139,125,143,17,0,64,134,
+16,0,125,135,5,0,32,126,0,64,125,127,13,0,125,135,1,0,61,111,
+1,0,128,102,170,170,204,105,125,111,21,0,61,95,1,0,11,94,84,85,
+125,95,25,0,61,87,1,0,125,87,29,0,61,143,1,0,66,138,125,143,
+33,0,29,80,64,6,127,0,128,7,225,0,6,248,229,87,64,0,224,7,
+96,1,10,224,252,47,32,0,63,143,21,0,32,134,170,0,113,135,0,0,
+63,127,25,0,32,118,85,0,111,119,0,0,63,111,21,0,32,102,144,0,
+109,103,0,0,63,87,1,0,42,87,0,0,31,48,202,142,255,0,63,239,
+33,0,208,138,253,239,1,0,17,233,128,255,26,0,44,6,91,0,32,0,
+236,233,186,5,0,82,181,5,32,86,192,1,64,6,255,0,128,7,33,0,
+38,143,21,0,32,134,240,0,113,135,0,0,12,50,128,255,126,5,64,6,
+63,0,38,135,128,7,38,23,1,0,2,80,127,0,38,23,5,0,2,80,
+127,0,38,23,13,0,2,80,127,0,34,6,0,192,23,0,2,80,127,0,
+128,7,225,16,6,232,0,226,229,87,64,0,224,7,96,1,10,216,61,143,
+21,0,128,134,170,170,113,135,0,0,61,127,25,0,32,118,85,85,111,119,
+0,0,61,111,21,0,128,102,144,144,109,103,0,0,32,54,32,78,128,255,
+22,5,61,95,1,0,235,87,1,0,10,136,208,138,61,135,29,0,240,127,
+1,0,15,224,17,225,61,119,21,0,128,110,170,170,110,111,0,0,61,103,
+25,0,32,94,85,85,108,95,0,0,61,87,21,0,128,142,240,240,106,143,
+0,0,32,54,32,78,128,255,210,4,251,47,32,0,48,6,186,186,31,31,
+240,225,186,5,0,18,181,5,32,22,192,1,2,80,64,6,255,16,190,7,
+225,241,3,30,124,254,6,232,7,224,8,216,9,208,35,142,0,0,64,134,
+0,64,17,200,16,201,61,127,1,0,239,225,161,13,26,112,220,113,61,111,
+5,0,61,103,1,0,204,105,237,113,195,5,32,22,193,1,133,101,28,88,
+61,87,1,0,11,136,170,137,17,16,61,135,9,0,240,23,194,2,2,184,
+149,85,61,127,1,0,15,112,23,104,61,103,9,0,13,88,236,95,34,2,
+11,96,12,192,206,193,29,48,24,56,25,64,128,255,32,1,0,18,24,72,
+149,37,252,73,218,29,224,209,178,29,2,80,217,81,65,218,27,142,255,255,
+17,135,0,0,74,135,0,0,95,210,65,226,224,209,226,13,2,126,1,0,
+15,112,217,113,65,218,27,110,255,255,13,103,0,0,78,103,0,0,95,210,
+65,226,66,74,68,18,61,87,9,0,10,88,129,90,11,128,193,130,16,136,
+17,120,216,121,239,73,225,213,29,48,24,56,25,64,128,255,44,0,29,48,
+24,56,25,64,128,255,248,0,10,16,224,17,194,5,32,22,194,1,213,5,
+65,186,224,209,250,173,0,18,2,80,3,30,132,1,126,6,255,241,128,7,
+225,48,6,224,7,216,8,248,60,135,5,0,16,136,129,138,17,232,59,233,
+229,87,64,0,224,7,96,1,10,208,60,127,21,0,128,118,170,170,111,119,
+0,0,60,111,25,0,32,102,85,85,109,103,0,0,60,95,21,0,128,86,
+160,160,107,87,0,0,0,18,229,21,66,218,27,142,254,255,66,250,31,134,
+254,255,240,127,1,0,113,127,0,0,66,234,29,118,254,255,66,250,31,110,
+254,255,237,103,1,0,110,103,0,0,65,18,60,87,9,0,10,88,129,90,
+235,17,225,229,32,54,32,78,128,255,44,3,250,47,32,0,64,6,255,48,
+38,135,5,0,16,136,129,138,17,16,39,17,0,74,229,21,66,66,8,126,
+254,255,66,58,7,118,254,255,238,111,1,0,111,111,0,0,66,66,8,102,
+254,255,66,18,2,94,254,255,235,87,1,0,108,87,0,0,65,74,38,135,
+9,0,16,136,129,138,241,73,225,229,127,0,38,135,5,0,16,136,129,138,
+17,16,39,17,0,74,133,37,66,66,8,126,254,255,239,119,1,0,66,58,
+7,110,254,255,237,103,1,0,236,113,194,5,32,22,194,1,149,29,66,66,
+8,94,254,255,235,87,1,0,66,18,2,142,254,255,241,135,1,0,240,81,
+194,5,32,22,194,1,165,13,65,74,9,120,38,111,9,0,13,112,129,114,
+238,121,177,221,0,18,2,80,127,0,38,23,1,0,2,80,127,0,38,23,
+5,0,2,80,127,0,38,23,13,0,2,80,127,0,34,6,0,192,23,0,
+2,80,127,0,128,7,225,16,6,232,0,226,229,87,64,0,224,7,96,1,
+10,216,61,143,21,0,128,134,170,170,113,135,0,0,61,127,25,0,32,118,
+85,85,111,119,0,0,61,111,21,0,128,102,144,144,109,103,0,0,32,54,
+32,78,128,255,26,2,61,95,1,0,235,87,1,0,10,136,208,138,61,135,
+29,0,240,127,1,0,15,224,17,225,61,119,21,0,128,110,170,170,110,111,
+0,0,61,103,25,0,32,94,85,85,108,95,0,0,61,87,21,0,128,142,
+240,240,106,143,0,0,32,54,32,78,128,255,214,1,251,47,32,0,48,6,
+186,186,31,31,240,225,186,5,0,18,181,5,32,22,192,1,2,80,64,6,
+255,16,190,7,225,241,3,30,124,254,6,232,7,208,8,192,9,200,35,142,
+0,0,64,134,0,64,17,216,16,217,61,127,1,0,239,209,161,13,25,112,
+218,113,61,111,5,0,61,103,1,0,204,105,237,113,195,5,32,22,193,1,
+149,85,26,88,61,87,1,0,11,136,170,137,17,16,61,135,9,0,240,23,
+194,2,2,184,165,69,61,127,1,0,15,112,23,104,61,103,9,0,13,88,
+236,95,34,2,11,96,12,224,206,225,29,48,28,56,27,64,128,255,226,0,
+0,74,28,16,165,21,250,17,234,13,224,201,194,13,9,80,219,81,65,194,
+24,142,255,255,17,135,0,0,74,135,0,0,95,202,65,210,65,18,65,74,
+61,119,9,0,14,120,129,122,15,96,193,98,12,104,13,88,220,89,235,17,
+209,229,29,48,28,56,27,64,128,255,44,0,29,48,28,56,27,64,128,255,
+184,0,10,16,224,17,194,5,32,22,194,1,213,5,65,186,224,201,234,189,
+0,18,2,80,3,30,132,1,126,6,255,241,128,7,225,16,6,248,7,232,
+8,224,229,87,64,0,224,7,96,1,10,216,63,143,21,0,128,134,170,170,
+113,135,0,0,63,127,25,0,32,118,85,85,111,119,0,0,63,111,21,0,
+128,102,160,160,109,103,0,0,0,18,197,13,66,234,29,94,254,255,66,226,
+28,86,254,255,234,143,1,0,107,143,0,0,65,18,63,127,9,0,15,128,
+129,130,240,17,129,245,32,54,32,78,128,255,110,0,251,47,32,0,64,6,
+255,16,0,18,197,13,66,66,8,142,254,255,66,58,7,134,254,255,240,127,
+1,0,113,127,0,0,65,18,38,111,9,0,13,112,129,114,238,17,129,245,
+127,0,0,18,149,21,66,66,8,142,254,255,241,135,1,0,66,58,7,126,
+254,255,239,119,1,0,238,129,194,5,32,22,194,1,165,13,65,18,2,104,
+38,95,9,0,11,96,129,98,236,105,161,237,0,18,2,80,127,0,127,0,
+128,7,225,0,6,232,29,6,155,255,233,5,32,230,213,1,29,238,156,255,
+149,21,47,6,140,134,71,0,15,128,253,135,34,2,16,136,17,112,45,6,
+64,66,15,0,237,119,194,2,14,230,1,0,0,234,128,102,26,183,236,225,
+147,13,128,54,26,183,128,255,54,0,128,94,26,183,171,225,229,5,28,80,
+10,48,128,255,38,0,0,226,224,225,234,237,224,233,202,213,64,6,255,0,
+127,0,36,135,64,86,0,0,42,87,80,245,10,16,194,0,2,80,127,0,
+128,7,225,0,6,232,191,255,234,255,10,224,29,136,220,137,17,128,128,126,
+27,183,239,135,192,234,252,233,231,5,191,255,210,255,253,81,214,253,197,13,
+191,255,200,255,10,16,197,5,191,255,192,255,10,16,252,17,207,253,253,17,
+166,253,64,6,255,0,192,25,1,50,127,0,88,26,99,255,5,0,99,231,
+1,0,3,224,128,255,48,0,35,255,5,0,35,231,1,0,72,26,127,0,
+88,26,99,255,5,0,99,231,1,0,224,49,3,224,178,5,128,255,38,18,
+35,255,5,0,35,231,1,0,72,26,127,0,3,30,236,255,99,255,17,0,
+99,231,13,0,99,215,9,0,3,230,12,0,99,239,1,0,99,223,5,0,
+128,239,4,0,6,208,224,209,186,29,1,210,149,29,68,54,0,0,38,55,
+45,141,224,49,218,5,93,54,0,0,38,54,128,0,6,216,93,254,0,0,
+63,254,42,0,123,0,93,102,0,0,44,102,128,0,236,217,186,5,0,48,
+245,5,26,48,128,255,132,17,10,48,224,49,178,229,35,215,9,0,35,231,
+13,0,35,255,17,0,35,239,1,0,35,223,5,0,6,80,3,30,20,0,
+127,0,88,26,99,255,5,0,99,231,1,0,6,50,3,224,128,255,170,1,
+35,231,1,0,35,255,5,0,72,26,127,0,192,25,127,0,3,30,236,255,
+99,255,17,0,99,231,13,0,99,215,9,0,3,230,12,0,99,239,1,0,
+99,223,5,0,128,239,4,0,68,102,0,0,44,103,41,141,0,218,224,97,
+218,37,1,50,68,14,0,0,97,55,41,141,93,54,0,0,38,54,112,0,
+128,255,222,13,133,21,27,48,65,218,194,50,68,62,0,0,39,62,92,128,
+199,49,38,215,1,0,93,254,0,0,63,254,68,0,122,0,27,88,194,90,
+68,70,0,0,200,89,43,63,93,128,224,57,154,237,35,215,9,0,35,223,
+5,0,35,239,1,0,35,255,17,0,35,231,13,0,3,30,20,0,127,0,
+80,26,99,255,13,0,99,231,9,0,99,239,1,0,3,230,8,0,99,223,
+5,0,128,239,4,0,213,29,39,103,1,0,68,14,0,0,97,103,201,134,
+7,48,38,63,5,0,224,57,178,13,38,223,9,0,93,254,0,0,7,48,
+2,58,63,254,42,0,123,0,133,13,38,223,9,0,93,254,0,0,63,254,
+58,0,123,0,68,62,0,0,39,63,201,134,224,57,250,221,35,223,5,0,
+35,239,1,0,35,255,13,0,35,231,9,0,3,30,16,0,127,0,88,26,
+99,255,5,0,99,231,1,0,6,56,3,224,0,50,95,58,104,58,251,53,
+71,0,9,0,14,0,19,0,24,0,29,0,34,0,39,0,44,0,49,0,
+68,54,0,0,38,54,48,141,133,45,68,54,0,0,38,54,124,141,181,37,
+68,54,0,0,38,54,180,141,229,29,68,54,0,0,38,54,96,142,149,29,
+68,54,0,0,38,54,232,141,197,21,68,54,0,0,38,54,8,142,245,13,
+68,54,0,0,38,54,44,142,165,13,68,54,0,0,38,54,68,142,213,5,
+68,54,0,0,38,54,68,141,35,255,5,0,35,231,1,0,6,80,72,26,
+127,0,80,26,99,255,13,0,99,231,9,0,99,239,1,0,3,230,8,0,
+99,223,5,0,6,232,1,50,191,255,86,255,10,216,29,48,191,255,78,255,
+64,54,0,0,38,54,128,128,196,49,27,64,10,72,68,62,0,0,39,62,
+164,142,128,255,192,10,128,255,254,10,35,231,9,0,35,255,13,0,35,239,
+1,0,35,223,5,0,3,30,16,0,127,0,3,30,224,255,99,79,29,0,
+99,71,25,0,99,255,13,0,99,231,9,0,35,102,20,0,3,230,8,0,
+99,103,1,0,6,64,64,54,0,0,38,54,112,128,99,63,21,0,196,49,
+35,94,16,0,203,94,7,0,99,95,5,0,8,56,35,79,5,0,12,64,
+128,255,20,0,35,231,9,0,35,255,13,0,3,30,32,0,127,0,4,2,
+3,30,212,253,99,79,41,2,99,71,37,2,99,255,25,2,99,231,21,2,
+99,207,17,2,3,230,20,2,99,215,13,2,99,239,5,2,99,223,9,2,
+128,239,4,0,7,200,6,216,128,255,160,16,27,215,15,0,220,210,159,210,
+219,247,15,0,218,5,9,50,128,255,86,27,133,61,59,103,5,0,224,97,
+154,21,35,94,4,0,123,95,5,0,35,86,4,0,123,87,1,0,32,54,
+0,2,123,55,9,0,219,175,15,0,219,151,15,0,27,48,93,62,0,0,
+35,103,41,2,39,62,136,17,99,103,1,0,35,79,37,2,25,64,128,255,
+38,2,10,200,59,87,5,0,35,94,4,0,235,81,170,13,27,48,128,255,
+196,14,123,7,5,0,123,7,1,0,123,7,9,0,224,209,218,5,219,223,
+15,0,162,5,31,202,27,48,128,255,62,16,25,80,35,207,17,2,35,215,
+13,2,35,223,9,2,35,239,5,2,35,255,25,2,35,231,21,2,3,30,
+44,2,127,0,88,26,99,255,5,0,99,231,1,0,3,224,197,13,6,88,
+10,82,234,95,194,98,12,102,48,0,71,103,255,255,234,55,194,2,95,58,
+224,49,202,245,224,65,146,13,229,5,32,54,48,0,71,55,255,255,95,58,
+231,65,161,253,35,255,5,0,35,231,1,0,7,80,72,26,127,0,24,0,
+3,30,208,255,99,255,45,0,99,231,41,0,99,207,37,0,3,230,40,0,
+99,215,33,0,99,239,25,0,99,223,29,0,128,239,4,0,99,55,21,0,
+38,119,9,0,99,119,17,0,7,216,38,207,13,0,224,217,99,223,1,0,
+250,5,68,222,0,0,59,222,172,142,99,223,1,0,27,48,128,255,136,16,
+35,111,21,0,10,48,13,71,21,0,45,63,5,0,224,65,194,5,230,57,
+169,5,7,48,6,112,219,113,99,119,9,0,35,119,21,0,46,119,1,0,
+230,113,99,119,5,0,190,5,99,55,5,0,35,79,21,0,35,215,5,0,
+9,79,16,0,166,209,224,73,130,37,224,65,186,29,27,71,0,0,8,6,
+211,255,242,5,8,6,213,255,194,5,8,6,224,255,170,5,65,218,27,95,
+0,0,11,6,208,255,170,13,27,55,1,0,6,6,136,255,194,5,6,6,
+168,255,170,5,66,218,32,118,48,0,181,5,32,118,32,0,99,119,13,0,
+229,13,14,71,0,0,35,63,17,0,8,48,65,114,99,119,1,0,93,254,
+0,0,63,254,212,0,121,0,35,119,1,0,251,113,129,245,35,63,21,0,
+7,63,17,0,224,57,194,13,149,29,35,55,13,0,35,63,17,0,93,254,
+0,0,63,254,252,0,121,0,95,210,224,209,223,245,197,13,27,103,0,0,
+35,63,17,0,12,48,65,218,93,254,0,0,63,254,26,1,121,0,35,111,
+9,0,237,217,161,245,181,13,35,63,17,0,32,54,32,0,93,254,0,0,
+63,254,54,1,121,0,95,210,224,209,223,245,35,207,37,0,35,215,33,0,
+35,223,29,0,35,239,25,0,35,255,45,0,35,231,41,0,35,87,5,0,
+3,30,48,0,127,0,108,1,3,30,108,254,99,79,145,1,99,255,129,1,
+99,231,125,1,99,207,121,1,3,230,124,1,99,215,117,1,99,239,109,1,
+99,223,113,1,128,239,4,0,99,55,21,0,99,63,25,0,0,210,8,216,
+224,217,218,5,68,222,0,0,59,222,172,142,35,111,21,0,99,111,89,1,
+35,111,25,0,99,111,93,1,128,7,30,7,6,6,219,255,226,13,35,63,
+21,0,93,254,0,0,35,103,25,0,63,254,68,0,108,0,65,218,65,210,
+128,7,254,6,65,218,31,50,99,55,85,1,99,55,81,1,0,202,35,54,
+96,1,197,5,70,7,0,0,65,50,35,78,105,1,233,49,163,253,27,255,
+0,0,31,6,211,255,218,5,1,50,67,55,97,1,197,29,31,6,213,255,
+218,5,1,50,67,55,98,1,213,21,31,6,208,255,218,5,1,50,67,55,
+96,1,229,13,31,6,224,255,218,5,1,50,67,55,99,1,245,5,31,6,
+221,255,234,5,1,50,67,55,100,1,65,218,181,221,31,6,208,255,198,29,
+31,6,199,255,159,29,99,7,81,1,213,13,27,95,0,0,35,63,81,1,
+65,218,234,63,64,2,199,89,11,94,208,255,99,95,81,1,27,55,0,0,
+6,6,208,255,214,29,6,6,199,255,215,237,149,29,31,6,214,255,234,21,
+35,95,145,1,28,66,67,90,72,89,68,90,43,55,253,255,99,95,145,1,
+99,55,81,1,224,49,254,5,128,49,99,55,81,1,1,50,67,55,97,1,
+65,218,27,79,0,0,9,6,210,255,234,61,27,55,1,0,1,202,65,218,
+6,6,208,255,198,29,6,6,199,255,159,29,99,7,85,1,213,13,27,87,
+0,0,35,55,85,1,65,218,234,55,64,2,198,81,10,86,208,255,99,87,
+85,1,27,55,0,0,6,6,208,255,134,37,6,6,199,255,215,237,197,29,
+27,95,0,0,11,6,214,255,186,21,35,87,145,1,28,58,67,82,71,81,
+68,82,99,87,145,1,42,87,253,255,99,87,85,1,224,81,142,13,31,50,
+99,55,85,1,197,5,99,7,85,1,165,5,65,218,27,55,0,0,6,6,
+224,255,178,253,6,6,148,255,250,13,27,55,1,0,1,58,65,218,6,6,
+148,255,218,5,65,218,67,63,103,1,181,21,67,63,102,1,133,21,6,6,
+180,255,234,5,65,218,1,50,67,55,103,1,133,13,6,6,152,255,218,5,
+65,218,1,50,67,55,104,1,27,63,0,0,65,218,67,63,105,1,7,6,
+187,255,186,5,128,7,78,4,7,6,185,255,186,5,128,7,68,4,7,6,
+176,255,186,5,128,7,8,2,7,6,168,255,186,5,128,7,32,2,7,6,
+157,255,177,5,128,7,202,4,186,5,128,7,202,4,7,6,156,255,162,45,
+7,6,152,255,177,5,128,7,16,4,7,6,151,255,162,37,7,6,146,255,
+177,5,128,7,164,4,186,5,128,7,28,4,7,6,144,255,177,5,128,7,
+224,1,186,5,128,7,184,1,7,6,141,255,186,5,128,7,102,4,7,6,
+139,255,186,5,128,7,198,1,7,6,136,255,186,5,128,7,188,1,128,7,
+108,4,224,201,178,5,67,7,96,1,3,63,103,1,224,57,35,63,145,1,
+242,21,7,94,255,255,35,79,149,1,203,86,4,0,234,73,226,55,0,0,
+194,50,199,49,67,50,28,82,74,49,72,50,99,55,145,1,38,71,249,255,
+38,79,253,255,181,13,67,58,28,82,74,57,68,58,39,71,253,255,99,63,
+145,1,8,72,191,74,3,55,104,1,224,49,194,5,232,0,8,72,191,74,
+67,7,3,0,67,7,79,1,3,206,79,1,9,48,224,49,190,29,1,106,
+67,111,3,0,193,50,250,13,224,65,218,13,32,54,56,0,89,55,255,255,
+42,6,204,204,204,204,95,202,43,6,204,204,204,12,213,5,8,48,9,56,
+128,255,92,13,10,64,11,72,9,48,99,55,17,0,25,80,8,48,32,78,
+34,0,39,6,0,40,107,238,133,61,0,90,0,202,213,37,9,6,225,255,
+254,5,40,6,0,202,154,59,233,71,192,0,165,5,25,88,35,103,17,0,
+193,202,236,57,203,21,230,65,139,13,35,111,17,0,65,202,167,105,99,111,
+17,0,165,13,35,103,17,0,236,57,249,5,65,202,167,97,95,98,99,103,
+17,0,168,49,129,58,95,74,224,73,190,221,99,95,17,0,0,66,25,56,
+11,57,178,5,10,70,247,255,10,56,191,255,90,250,25,48,3,58,4,74,
+35,111,17,0,0,66,224,105,218,197,10,56,191,255,68,250,35,63,85,1,
+10,200,224,57,174,5,1,58,35,54,79,1,167,49,229,5,32,62,48,0,
+89,63,255,255,95,202,230,201,171,253,3,79,3,0,224,73,194,5,32,54,
+45,0,133,21,3,71,98,1,224,65,194,5,32,54,43,0,149,13,3,63,
+99,1,224,57,186,5,128,7,22,1,32,54,32,0,89,55,255,255,95,202,
+128,7,8,1,3,55,105,1,35,95,145,1,72,50,67,55,105,1,67,90,
+28,66,72,89,68,90,99,95,145,1,43,87,253,255,0,90,213,117,224,201,
+178,5,67,7,96,1,3,79,103,1,35,71,145,1,224,73,146,29,8,72,
+9,62,255,255,35,95,149,1,199,54,4,0,230,89,226,71,0,0,194,66,
+201,65,8,62,3,0,28,50,70,57,72,58,99,63,145,1,39,87,249,255,
+39,95,253,255,165,13,67,66,28,90,75,65,68,66,99,71,145,1,40,87,
+253,255,0,90,3,63,104,1,224,57,178,5,202,0,0,90,3,79,105,1,
+9,6,139,255,250,61,3,206,235,0,67,7,235,0,181,29,35,63,33,0,
+35,55,29,0,10,66,0,74,128,255,122,13,10,48,11,56,32,70,48,0,
+0,74,128,255,164,11,89,87,255,255,10,66,35,55,29,0,35,63,33,0,
+95,202,0,74,128,255,52,12,99,87,29,0,99,95,33,0,11,72,10,64,
+0,50,0,58,128,255,56,11,97,82,178,221,35,63,85,1,224,57,174,5,
+1,58,35,54,235,0,167,49,229,5,32,62,48,0,89,63,255,255,95,202,
+230,201,171,253,25,56,128,7,22,2,99,87,29,0,3,71,105,1,3,206,
+135,0,8,6,168,255,226,111,0,0,99,95,33,0,196,106,68,94,0,0,
+43,94,180,142,203,105,99,111,9,0,67,7,135,0,35,79,33,0,10,64,
+0,50,0,58,128,255,150,10,97,82,186,5,67,7,100,1,3,87,105,1,
+10,6,145,255,138,13,3,106,99,111,13,0,7,106,99,111,17,0,165,45,
+4,106,99,111,13,0,15,106,149,253,35,71,17,0,35,55,29,0,8,72,
+35,63,33,0,191,74,128,255,76,10,35,55,9,0,0,74,0,56,10,64,
+128,255,202,10,10,55,0,0,35,71,13,0,89,55,255,255,8,72,95,202,
+35,55,29,0,35,63,33,0,191,74,128,255,206,10,99,87,29,0,99,95,
+33,0,35,79,33,0,35,71,29,0,0,50,0,58,128,255,82,10,97,82,
+178,213,35,111,13,0,99,106,170,13,3,79,100,1,224,73,226,5,32,54,
+48,0,89,55,255,255,95,202,35,71,85,1,224,65,174,5,1,66,35,54,
+135,0,168,49,229,5,32,62,48,0,89,63,255,255,95,202,230,201,171,253,
+35,111,13,0,100,106,178,5,191,7,248,254,3,95,100,1,224,89,186,5,
+191,7,236,254,3,87,105,1,32,54,48,0,89,87,255,255,89,55,254,255,
+94,202,191,7,214,254,68,206,0,0,57,206,212,142,25,56,35,54,80,1,
+191,255,244,247,202,209,32,54,41,0,89,55,15,0,89,7,16,0,165,109,
+67,7,96,1,3,79,104,1,35,95,145,1,224,73,210,13,11,70,3,0,
+28,90,75,65,68,66,99,71,145,1,40,71,253,255,104,215,0,0,229,85,
+3,63,103,1,28,66,224,57,130,21,11,54,3,0,72,49,68,50,99,55,
+145,1,26,72,38,55,253,255,191,74,102,215,1,0,102,79,5,0,165,69,
+67,90,72,89,68,90,99,95,145,1,43,95,253,255,107,215,1,0,133,61,
+1,50,35,71,145,1,67,55,101,1,67,66,28,90,75,65,8,78,4,0,
+99,79,145,1,40,63,1,0,197,37,67,63,4,0,213,13,35,71,145,1,
+28,90,67,66,75,65,68,66,99,71,145,1,40,71,253,255,67,71,4,0,
+3,63,4,0,67,7,5,0,224,57,218,13,35,63,21,0,0,50,93,254,
+0,0,35,103,25,0,63,254,52,7,108,0,191,7,18,249,35,62,4,0,
+35,54,80,1,191,255,20,247,202,209,27,55,0,0,224,49,178,5,191,7,
+222,248,26,80,35,207,121,1,35,215,117,1,35,223,113,1,35,239,109,1,
+35,255,129,1,35,231,125,1,3,30,148,1,127,0,3,30,224,255,99,79,
+29,0,99,255,13,0,35,94,16,0,203,94,7,0,99,95,5,0,99,231,
+9,0,99,71,25,0,35,79,5,0,35,70,24,0,99,71,1,0,3,230,
+8,0,191,255,134,245,35,255,13,0,35,231,9,0,3,30,32,0,127,0,
+88,26,99,255,5,0,99,231,1,0,6,50,3,224,128,255,68,19,35,231,
+1,0,35,255,5,0,72,26,127,0,16,0,17,2,6,216,7,200,8,208,
+64,230,0,0,60,230,128,128,196,225,28,232,29,56,68,54,0,0,38,54,
+35,143,128,255,62,5,224,217,210,21,27,103,0,0,224,97,146,21,29,56,
+32,54,34,0,128,255,32,5,27,48,29,56,128,255,32,5,29,56,68,54,
+0,0,38,54,23,143,128,255,18,5,29,56,68,54,0,0,38,54,27,143,
+128,255,4,5,25,48,29,56,128,255,252,4,29,56,68,54,0,0,38,54,
+15,143,128,255,238,4,224,209,255,5,29,56,32,54,48,0,128,255,216,4,
+213,29,3,238,12,0,26,48,67,7,12,0,181,13,10,74,6,64,233,71,
+128,82,10,86,48,0,93,87,255,255,73,48,95,234,224,49,223,245,229,5,
+11,48,65,234,28,56,128,255,166,4,29,95,0,0,224,89,138,253,28,56,
+10,50,128,255,150,4,191,255,30,255,0,82,39,2,16,0,0,2,8,2,
+128,255,252,18,32,230,35,0,28,48,194,50,68,86,0,0,202,49,38,63,
+205,134,224,57,38,54,204,134,162,13,7,216,0,58,102,7,1,0,93,254,
+0,0,63,254,48,0,123,0,95,226,188,237,68,230,0,0,60,79,161,129,
+224,73,60,230,160,129,146,13,9,216,93,254,0,0,63,254,80,0,123,0,
+124,7,1,0,128,255,172,18,30,2,8,2,6,216,68,230,0,0,128,255,
+154,18,60,103,93,135,224,97,60,230,92,135,170,13,93,94,0,0,43,94,
+162,255,124,95,1,0,28,48,128,255,152,16,0,74,9,48,194,50,68,70,
+0,0,200,49,38,63,205,134,224,57,38,54,204,134,250,5,102,223,1,0,
+128,255,96,18,0,82,133,13,65,74,9,6,220,255,198,237,128,255,80,18,
+31,82,30,2,80,26,80,26,99,255,13,0,99,239,1,0,99,223,5,0,
+6,232,99,231,9,0,68,222,0,0,59,222,100,135,59,103,33,0,3,230,
+8,0,224,97,218,5,32,54,0,8,123,55,33,0,59,55,33,0,29,56,
+95,50,6,72,221,73,72,74,38,232,73,233,180,5,231,233,185,5,0,216,
+149,61,29,48,128,255,110,16,10,48,127,50,146,253,198,70,7,0,178,5,
+8,58,135,65,59,95,29,0,230,89,138,13,29,56,198,57,123,63,29,0,
+8,216,198,217,181,29,59,63,25,0,224,57,178,5,231,49,185,5,123,55,
+25,0,59,63,29,0,224,57,210,5,29,72,198,73,233,57,217,5,29,56,
+198,57,123,63,29,0,8,56,198,57,7,222,8,0,72,66,168,233,71,234,
+24,82,74,233,123,239,253,255,27,48,128,255,76,1,27,80,35,223,5,0,
+35,239,1,0,35,255,13,0,35,231,9,0,3,30,16,0,127,0,3,30,
+228,255,99,255,25,0,99,207,17,0,99,215,13,0,99,231,21,0,99,239,
+5,0,99,223,9,0,3,230,20,0,6,222,11,0,24,90,75,217,230,217,
+185,5,0,72,149,117,27,6,240,255,177,5,32,222,16,0,68,214,0,0,
+58,214,100,135,58,239,5,0,224,233,186,13,26,238,16,0,122,239,5,0,
+122,239,17,0,122,239,21,0,122,7,13,0,29,56,61,239,1,0,61,79,
+253,255,251,73,193,45,61,87,1,0,9,48,122,63,5,0,187,49,6,6,
+120,255,241,5,103,87,1,0,29,72,106,63,5,0,197,69,58,71,29,0,
+221,73,232,73,218,5,29,64,219,233,1,90,197,5,6,64,221,65,0,90,
+104,223,253,255,8,72,125,55,253,255,224,89,146,53,103,239,1,0,125,63,
+5,0,125,87,1,0,106,239,5,0,133,45,58,55,5,0,230,233,186,205,
+99,55,1,0,27,200,25,48,0,58,191,255,88,254,224,81,234,21,29,56,
+7,64,40,63,1,0,231,65,217,5,58,54,16,0,230,57,138,253,40,103,
+253,255,25,48,172,49,1,58,191,255,50,254,224,81,186,5,0,74,229,5,
+35,119,1,0,122,119,5,0,133,173,35,207,17,0,35,231,21,0,35,255,
+25,0,35,239,5,0,35,223,9,0,35,215,13,0,9,80,3,30,28,0,
+127,0,84,26,99,255,9,0,99,239,1,0,99,231,5,0,68,70,0,0,
+38,79,253,255,40,71,105,135,3,230,4,0,232,49,169,13,8,56,7,64,
+40,63,5,0,231,49,185,13,232,57,161,253,133,13,8,56,39,71,1,0,
+232,57,185,5,230,65,163,253,68,14,0,0,97,63,105,135,0,250,39,87,
+253,255,0,234,10,96,199,97,230,97,138,13,7,48,38,63,5,0,202,73,
+102,79,253,255,1,250,9,88,198,89,232,89,170,21,40,95,1,0,40,87,
+253,255,103,55,1,0,202,73,102,63,5,0,11,64,102,71,1,0,102,79,
+253,255,104,55,5,0,1,234,224,249,186,13,224,233,154,13,103,55,1,0,
+102,63,5,0,102,71,1,0,104,55,5,0,35,239,1,0,35,255,9,0,
+35,231,5,0,76,26,127,0,84,26,99,255,9,0,99,231,5,0,99,239,
+1,0,3,230,4,0,6,232,128,255,112,15,29,48,191,255,252,253,10,232,
+128,255,104,15,29,80,35,239,1,0,35,255,9,0,35,231,5,0,76,26,
+127,0,84,26,99,255,9,0,99,231,5,0,99,239,1,0,3,230,4,0,
+6,232,128,255,58,15,224,233,194,5,29,48,191,255,242,254,128,255,48,15,
+35,239,1,0,35,255,9,0,35,231,5,0,76,26,127,0,3,30,9,2,
+0,226,6,232,128,255,104,1,224,233,194,69,61,55,5,0,224,49,130,69,
+221,247,15,0,234,5,9,50,128,255,26,12,31,226,133,61,221,239,15,0,
+218,53,61,103,1,0,230,97,163,37,221,255,13,0,146,13,61,95,12,0,
+0,58,203,54,255,63,2,66,128,255,226,10,61,87,12,0,61,79,1,0,
+61,63,5,0,202,54,255,63,167,73,9,64,128,255,200,9,61,63,5,0,
+61,55,1,0,167,49,230,81,206,5,221,31,15,0,31,226,61,95,5,0,
+221,183,13,0,125,95,1,0,224,89,202,5,125,7,9,0,213,5,32,54,
+0,2,125,55,9,0,29,48,128,255,2,1,28,80,31,2,0,2,128,255,
+116,1,22,2,8,2,6,224,7,232,29,48,128,255,192,0,61,103,5,0,
+224,97,186,61,28,48,128,255,226,1,10,216,224,217,130,13,28,55,0,0,
+29,56,128,255,232,1,127,82,130,21,95,218,224,217,247,45,61,87,12,0,
+28,78,1,0,202,54,255,63,9,56,27,64,128,255,60,9,251,81,190,37,
+221,31,15,0,31,226,133,37,61,71,9,0,95,66,125,71,9,0,140,13,
+28,55,0,0,29,56,128,255,168,1,10,48,181,13,61,95,1,0,65,90,
+125,95,1,0,28,55,0,0,75,55,255,255,134,0,65,226,127,50,210,229,
+28,79,0,0,224,73,186,229,0,226,29,48,128,255,94,0,28,80,30,2,
+0,2,68,94,0,0,43,94,96,128,171,49,164,50,6,6,236,255,193,13,
+6,72,194,74,68,62,0,0,39,62,164,129,9,64,199,65,8,48,128,255,
+202,13,22,2,0,2,68,94,0,0,43,94,96,128,171,49,164,50,6,6,
+236,255,177,13,194,50,68,62,0,0,199,49,38,55,165,129,224,49,178,5,
+128,255,146,13,22,2,0,2,68,94,0,0,43,94,96,128,171,49,164,50,
+6,6,236,255,177,13,194,50,68,62,0,0,199,49,38,55,165,129,224,49,
+178,5,128,255,108,13,22,2,0,2,9,2,68,54,0,0,38,54,96,128,
+198,47,15,0,6,238,16,0,198,55,31,0,6,230,32,0,38,103,28,0,
+32,110,0,192,77,97,140,102,1,0,38,87,44,0,102,103,28,0,77,81,
+138,86,2,0,102,87,44,0,198,55,47,0,191,255,64,255,29,48,191,255,
+58,255,28,48,191,255,52,255,31,2,9,2,6,224,7,232,29,48,191,255,
+82,255,61,103,9,0,95,98,125,103,9,0,252,5,28,48,29,56,128,255,
+132,0,10,224,149,13,61,95,1,0,65,90,125,95,1,0,75,231,255,255,
+156,0,29,48,191,255,78,255,28,80,31,2,0,2,39,103,9,0,95,98,
+103,103,9,0,220,5,128,255,84,0,10,48,149,13,39,95,1,0,65,90,
+103,95,1,0,75,55,255,255,134,0,6,80,22,2,10,88,95,66,150,13,
+6,87,0,0,7,95,0,0,65,50,65,58,234,89,242,245,202,86,255,0,
+203,94,255,0,171,81,127,0,6,56,6,103,0,0,65,50,224,97,202,253,
+6,86,255,255,167,81,127,0,4,0,20,2,6,224,7,232,68,54,0,0,
+38,54,96,128,230,233,193,69,68,86,0,0,234,87,87,143,196,82,198,81,
+234,233,201,61,221,247,15,0,146,61,29,71,15,0,200,70,3,0,99,66,
+178,53,221,215,15,0,130,13,221,239,15,0,210,5,61,63,5,0,125,63,
+1,0,221,151,15,0,61,55,5,0,221,175,15,0,224,49,202,29,67,231,
+3,0,221,255,13,0,146,13,61,103,12,0,0,58,204,54,255,63,2,66,
+128,255,6,8,61,95,12,0,35,62,3,0,203,54,255,63,1,66,128,255,
+242,6,97,82,254,13,221,31,15,0,229,5,29,48,191,255,188,252,224,81,
+178,5,31,82,245,5,28,48,29,56,191,255,74,253,28,80,138,0,42,2,
+4,0,192,25,71,73,70,65,8,80,9,88,127,0,80,26,99,231,5,0,
+99,215,13,0,6,224,99,239,1,0,8,208,99,223,9,0,7,232,9,216,
+251,233,0,74,202,5,250,225,170,5,1,74,35,215,13,0,35,239,1,0,
+35,231,5,0,35,223,9,0,9,80,3,30,16,0,127,0,80,26,99,231,
+5,0,99,215,13,0,6,224,99,239,1,0,8,208,99,223,9,0,7,232,
+9,216,251,233,1,74,202,5,250,225,170,5,0,74,35,215,13,0,35,239,
+1,0,35,231,5,0,35,223,9,0,9,80,3,30,16,0,127,0,80,26,
+80,26,192,25,8,80,198,81,230,81,225,95,0,0,201,89,199,89,127,0,
+0,2,6,64,7,72,0,50,0,58,128,255,242,1,22,2,7,2,6,224,
+7,232,9,48,8,72,224,49,159,21,127,50,246,13,9,6,193,255,207,13,
+9,6,63,0,150,13,224,49,186,5,224,73,214,5,127,50,234,5,224,73,
+198,5,0,82,0,90,245,37,224,73,202,5,28,80,29,88,165,37,224,73,
+158,13,28,48,29,56,128,73,9,64,0,74,128,255,200,2,133,29,9,6,
+224,255,134,13,29,80,9,62,224,255,231,87,128,0,0,88,229,13,32,86,
+32,0,169,81,29,64,234,71,192,0,233,239,128,0,233,231,128,0,28,65,
+8,80,29,88,29,2,24,0,17,2,99,55,17,0,8,208,99,63,21,0,
+99,63,9,0,9,216,191,58,35,255,9,0,99,63,13,0,224,249,154,13,
+224,217,250,5,35,87,17,0,0,88,250,87,194,2,133,125,64,70,0,128,
+224,249,178,13,32,238,63,0,31,88,72,89,138,21,129,66,95,234,224,65,
+170,253,181,13,32,238,31,0,35,103,17,0,72,97,218,5,129,66,95,234,
+224,65,154,253,27,48,64,70,0,128,224,49,178,13,32,78,63,0,6,56,
+72,57,250,13,129,66,95,74,224,65,170,253,165,13,32,78,31,0,26,48,
+72,49,218,5,129,66,95,74,224,65,170,253,0,202,0,226,233,233,166,69,
+35,103,9,0,99,103,1,0,35,103,17,0,169,233,99,103,5,0,162,13,
+29,64,0,72,26,48,27,56,128,255,220,1,10,64,11,72,181,5,26,64,
+27,72,9,56,8,48,133,45,28,64,193,226,159,66,193,202,35,111,1,0,
+8,201,231,105,251,5,231,105,250,21,35,111,5,0,230,105,177,21,35,111,
+5,0,230,105,225,71,0,0,35,111,1,0,199,65,168,105,99,111,1,0,
+35,111,5,0,156,230,1,0,166,105,99,111,5,0,7,64,223,66,129,58,
+129,50,8,49,95,234,224,233,142,221,28,80,25,88,39,2,24,0,7,2,
+6,224,7,232,8,208,9,216,224,233,138,13,224,217,234,5,250,231,194,90,
+11,80,0,88,213,21,28,48,29,56,26,64,27,72,191,255,186,254,10,48,
+11,56,26,64,27,72,128,255,44,0,28,64,10,224,8,80,188,81,225,63,
+0,0,167,233,157,89,29,2,9,2,135,73,232,49,225,63,0,0,167,73,
+168,49,6,80,9,88,31,2,80,0,18,2,8,208,218,254,255,255,144,210,
+6,224,220,70,255,255,8,48,250,55,34,2,99,55,21,0,9,216,27,48,
+198,222,255,255,8,72,255,79,34,2,99,79,17,0,144,50,8,72,230,71,
+34,2,251,79,34,2,99,79,25,0,99,71,29,0,144,226,28,72,255,79,
+34,2,99,79,33,0,7,232,28,56,250,63,34,2,99,63,37,0,99,7,
+45,0,221,54,255,255,6,56,255,63,34,2,99,63,49,0,250,55,34,2,
+99,55,53,0,99,7,57,0,99,7,61,0,99,7,69,0,99,7,73,0,
+251,231,34,2,99,231,41,0,99,7,77,0,144,234,255,239,34,2,99,239,
+65,0,0,226,0,234,29,248,194,250,31,72,195,73,105,231,1,0,0,218,
+0,226,245,21,27,56,194,58,29,80,187,81,199,81,194,82,195,81,42,55,
+17,0,31,72,6,88,144,90,203,225,195,73,41,63,1,0,198,86,255,255,
+202,57,105,63,1,0,65,218,253,217,151,237,195,249,63,87,1,0,65,234,
+10,88,202,0,127,87,1,0,144,90,203,225,100,234,198,213,35,63,13,0,
+35,95,9,0,208,58,7,89,35,87,5,0,35,55,1,0,208,82,6,81,
+40,2,80,0,9,2,6,224,7,232,9,48,224,49,159,21,127,50,246,13,
+8,6,193,255,207,13,8,6,63,0,150,13,224,49,186,5,224,65,214,5,
+127,50,234,5,224,65,198,5,0,82,0,90,229,37,224,65,202,5,28,80,
+29,88,149,37,224,65,142,13,28,48,29,56,128,65,0,74,191,255,164,252,
+133,29,28,72,8,6,224,255,134,13,8,70,224,255,232,79,192,0,0,80,
+9,88,213,13,32,86,32,0,168,81,234,231,128,0,232,239,192,0,29,225,
+28,88,232,79,192,0,9,80,31,2,6,80,198,94,3,0,218,21,39,89,
+203,94,3,0,154,21,100,66,241,13,6,96,200,97,130,98,194,98,39,95,
+1,0,68,58,102,95,1,0,68,50,230,97,155,253,200,70,3,0,224,65,
+178,13,6,96,200,97,7,95,0,0,65,58,70,95,0,0,65,50,230,97,
+155,253,127,0,8,72,7,64,88,26,99,239,1,0,136,0,6,232,9,48,
+99,231,5,0,221,49,29,230,255,255,9,6,223,255,169,37,8,56,200,58,
+8,57,7,88,208,90,11,57,197,5,70,71,255,255,95,50,198,86,15,0,
+186,253,16,74,29,80,73,81,149,13,102,63,1,0,102,63,5,0,102,63,
+9,0,102,63,13,0,80,50,234,49,234,245,6,54,16,0,181,5,70,71,
+0,0,95,50,252,49,202,253,29,80,35,231,5,0,35,239,1,0,72,26,
+127,0,3,30,232,255,99,255,21,0,99,231,17,0,99,215,9,0,3,230,
+16,0,8,208,99,207,13,0,199,209,6,72,99,239,1,0,9,200,99,223,
+5,0,32,238,238,15,0,218,133,69,129,218,219,102,0,1,234,5,135,55,
+1,0,65,58,134,222,0,255,219,94,1,0,135,103,1,0,146,13,73,103,
+0,0,65,58,65,74,65,234,221,238,255,15,165,45,167,87,1,0,66,58,
+202,70,240,0,196,66,8,97,202,86,15,0,67,82,12,48,201,49,189,49,
+236,233,191,5,6,54,0,240,0,66,229,5,73,7,0,0,65,50,65,74,
+65,66,249,49,185,13,234,65,134,253,133,13,134,95,1,0,73,95,0,0,
+65,50,65,74,65,66,234,65,134,253,221,81,202,238,255,15,250,57,138,197,
+35,207,13,0,35,215,9,0,35,223,5,0,35,239,1,0,35,255,21,0,
+35,231,17,0,3,30,24,0,127,0,3,30,216,255,99,255,37,0,99,231,
+33,0,99,239,21,0,3,230,32,0,99,215,29,0,6,232,99,223,25,0,
+7,208,8,216,128,255,26,3,68,102,0,0,44,103,89,143,224,97,178,5,
+128,255,190,5,68,94,0,0,43,95,93,143,224,89,178,5,191,255,82,248,
+68,86,0,0,42,87,97,143,224,81,178,5,191,255,156,206,68,78,0,0,
+41,79,101,143,224,73,194,5,0,50,128,255,128,4,68,70,0,0,40,71,
+105,143,224,65,242,5,128,255,102,5,42,54,220,0,191,255,114,206,224,233,
+234,21,67,7,2,0,67,7,3,0,35,62,2,0,99,63,13,0,99,7,
+17,0,35,102,3,0,99,103,5,0,99,7,9,0,35,222,4,0,35,214,
+12,0,1,234,68,14,0,0,97,223,245,129,68,94,0,0,43,95,109,143,
+224,89,226,5,29,48,26,56,27,64,191,255,38,206,29,48,26,56,27,64,
+191,255,120,210,10,48,128,255,136,2,35,215,29,0,35,223,25,0,35,239,
+21,0,35,255,37,0,35,231,33,0,3,30,40,0,127,0,88,26,99,255,
+5,0,99,231,1,0,8,80,3,224,7,72,9,64,10,72,6,56,38,6,
+1,0,4,0,128,255,142,1,35,231,1,0,35,255,5,0,72,26,127,0,
+88,26,99,255,5,0,99,231,1,0,8,80,3,224,7,72,9,64,10,72,
+6,56,64,54,4,0,128,255,100,1,35,231,1,0,35,255,5,0,72,26,
+127,0,3,30,224,255,99,79,29,0,99,255,13,0,99,231,9,0,7,72,
+3,230,8,0,201,102,0,1,99,71,25,0,6,56,9,64,194,21,35,86,
+16,0,202,86,7,0,99,87,5,0,35,94,27,0,28,98,76,89,68,90,
+99,95,1,0,43,79,253,255,38,6,4,0,4,0,197,5,38,6,4,0,
+3,0,128,255,4,1,35,255,13,0,35,231,9,0,3,30,32,0,127,0,
+88,26,99,255,5,0,99,231,1,0,7,64,3,224,6,56,38,6,6,0,
+3,0,128,255,220,0,35,231,1,0,35,255,5,0,72,26,127,0,88,26,
+99,255,5,0,99,231,1,0,6,56,3,224,38,6,5,0,2,0,128,255,
+184,0,35,231,1,0,35,255,5,0,72,26,127,0,88,26,99,255,5,0,
+99,231,1,0,8,80,3,224,7,72,9,64,10,72,6,56,38,6,7,0,
+4,0,128,255,140,0,35,231,1,0,35,255,5,0,72,26,127,0,88,26,
+99,255,5,0,99,231,1,0,6,56,3,224,38,6,8,0,2,0,128,255,
+104,0,35,231,1,0,35,255,5,0,72,26,127,0,88,26,99,255,5,0,
+99,231,1,0,8,80,3,224,7,72,9,64,10,72,6,56,38,6,18,0,
+4,0,128,255,60,0,35,231,1,0,35,255,5,0,72,26,127,0,88,26,
+99,255,5,0,99,231,1,0,8,80,3,224,7,72,9,64,10,72,6,56,
+38,6,19,0,4,0,128,255,16,0,35,231,1,0,35,255,5,0,72,26,
+127,0,92,26,99,255,1,0,97,2,0,82,128,255,92,5,217,5,10,48,
+128,255,86,0,31,82,35,255,1,0,68,26,127,0,84,26,99,255,9,0,
+99,231,5,0,99,239,1,0,3,230,4,0,128,239,4,0,93,102,0,0,
+44,102,4,3,224,97,234,5,68,86,0,0,42,86,248,129,245,5,128,255,
+238,2,10,48,224,49,170,5,0,80,35,239,1,0,35,255,9,0,35,231,
+5,0,76,26,127,0,84,26,99,255,9,0,99,231,5,0,99,239,1,0,
+3,230,4,0,6,232,191,255,164,255,10,48,224,49,178,5,102,239,1,0,
+35,239,1,0,35,255,9,0,35,231,5,0,76,26,127,0,88,26,88,26,
+99,255,5,0,99,231,1,0,32,54,16,0,3,224,31,58,191,255,82,255,
+35,231,1,0,35,255,5,0,72,26,127,0,4,0,3,30,228,255,99,255,
+25,0,99,231,21,0,99,207,17,0,3,230,20,0,99,215,13,0,99,239,
+5,0,99,223,9,0,128,239,4,0,99,55,1,0,0,202,128,255,92,2,
+68,222,0,0,59,223,137,135,165,13,59,215,1,0,93,254,0,0,63,254,
+34,0,122,0,59,223,5,0,224,217,234,245,68,102,0,0,44,103,113,143,
+224,97,242,5,128,255,32,2,42,54,220,0,191,255,44,203,35,63,1,0,
+2,50,191,255,212,254,25,88,171,0,2,82,75,80,202,54,1,0,98,50,
+145,253,128,255,10,2,35,207,17,0,35,215,13,0,35,223,9,0,35,239,
+5,0,35,255,25,0,35,231,21,0,3,30,28,0,127,0,84,26,99,255,
+9,0,99,231,5,0,99,239,1,0,3,230,4,0,6,232,128,255,208,1,
+68,102,0,0,44,103,137,135,125,103,5,0,68,14,0,0,97,239,137,135,
+128,255,188,1,35,239,1,0,35,255,9,0,35,231,5,0,76,26,127,0,
+88,26,99,255,5,0,99,231,1,0,1,50,3,224,191,255,16,255,35,231,
+1,0,35,255,5,0,72,26,127,0,80,26,99,255,13,0,99,231,9,0,
+99,223,5,0,3,230,8,0,99,239,1,0,6,216,68,238,0,0,128,255,
+106,1,61,103,141,135,224,97,61,238,140,135,250,5,68,94,254,255,43,94,
+0,96,125,95,1,0,61,55,1,0,68,78,254,255,219,49,41,78,0,96,
+230,73,203,13,68,70,255,255,40,70,0,112,232,49,235,5,125,55,1,0,
+6,232,187,233,213,5,31,234,12,50,191,255,68,254,128,255,34,1,29,80,
+35,223,5,0,35,239,1,0,35,255,13,0,35,231,9,0,3,30,16,0,
+127,0,88,26,99,255,5,0,99,231,1,0,6,248,3,224,224,249,202,5,
+128,255,228,0,10,248,1,74,9,80,194,82,223,81,106,7,1,0,65,74,
+9,6,224,255,135,253,32,78,18,0,1,50,9,96,194,98,223,97,108,55,
+1,0,65,74,9,6,232,255,247,245,32,78,29,0,1,50,9,56,194,58,
+223,57,103,55,1,0,65,74,9,6,224,255,247,245,35,255,5,0,35,231,
+1,0,72,26,127,0,3,30,236,255,99,255,17,0,99,231,13,0,99,215,
+9,0,3,230,12,0,99,239,1,0,99,223,5,0,128,239,4,0,6,216,
+224,217,199,5,27,6,224,255,183,5,31,82,165,37,128,255,94,0,10,56,
+27,48,194,50,6,72,199,73,41,215,1,0,105,218,178,5,224,209,218,5,
+27,48,191,255,170,254,133,21,97,210,226,13,68,58,7,70,252,255,199,49,
+102,7,253,255,0,58,27,48,93,254,0,0,63,254,80,0,122,0,0,82,
+35,215,9,0,35,223,5,0,35,239,1,0,35,255,17,0,35,231,13,0,
+3,30,20,0,127,0,88,26,192,25,68,86,0,0,42,86,252,129,127,0,
+192,25,127,0,192,25,127,0,192,25,192,25,127,0,192,25,127,0,192,25,
+127,0,192,25,31,82,127,0,192,25,127,0,192,25,127,0,88,0,96,0,
+106,0,116,0,132,0,142,0,152,0,162,0,172,0,182,0,192,0,240,0,
+208,0,218,0,228,0,0,1,246,0,10,1,20,1,30,1,40,1,50,1,
+84,1,98,1,114,1,130,1,148,1,164,1,180,1,196,1,212,1,228,1,
+244,1,74,1,88,1,104,1,120,1,138,1,154,1,170,1,186,1,202,1,
+218,1,234,1,128,7,33,0,224,7,68,1,128,7,33,0,128,7,193,255,
+165,13,128,7,33,0,128,7,193,247,213,5,128,7,33,0,128,7,193,243,
+240,239,64,0,224,7,68,1,128,7,33,0,128,7,193,241,229,29,128,7,
+33,0,128,7,193,240,149,29,128,7,33,0,128,7,193,112,197,21,128,7,
+33,0,128,7,193,48,245,13,128,7,33,0,128,7,193,16,165,13,128,7,
+33,0,128,7,193,0,213,5,128,7,33,0,128,7,65,0,240,239,64,0,
+224,7,68,1,128,7,33,0,128,7,193,255,165,13,128,7,33,0,128,7,
+193,247,213,5,128,7,33,0,128,7,193,243,128,7,78,0,128,7,33,0,
+213,37,128,7,33,0,128,7,193,240,229,29,128,7,33,0,128,7,193,241,
+149,29,128,7,33,0,128,7,193,112,197,21,128,7,33,0,128,7,193,48,
+245,13,128,7,33,0,128,7,193,16,165,13,128,7,33,0,128,7,193,0,
+213,5,128,7,33,0,128,7,65,0,240,239,64,0,240,87,64,0,234,95,
+253,255,171,25,106,0,240,255,64,0,255,103,1,0,204,25,64,6,63,0,
+240,103,64,0,236,103,1,0,204,25,64,6,192,255,133,21,240,103,64,0,
+236,103,1,0,204,25,64,6,192,247,133,13,240,103,64,0,236,103,1,0,
+204,25,64,6,192,243,64,6,63,0,240,103,64,0,236,103,1,0,204,25,
+64,6,192,241,133,53,240,103,64,0,236,103,1,0,204,25,64,6,192,240,
+133,45,240,103,64,0,236,103,1,0,204,25,64,6,192,112,133,37,240,103,
+64,0,236,103,1,0,204,25,64,6,192,48,133,29,240,103,64,0,236,103,
+1,0,204,25,64,6,192,16,133,21,240,103,64,0,236,103,1,0,204,25,
+64,6,192,0,133,13,240,103,64,0,236,103,1,0,204,25,64,6,64,0,
+64,6,63,0,0,0,0,0,127,0,0,0,88,90,129,0,0,0,0,0,
+24,0,0,0,124,90,129,0,0,0,0,0,100,7,0,0,116,101,129,0,
+124,101,129,0,132,101,129,0,140,101,129,0,148,101,129,0,156,101,129,0,
+164,101,129,0,0,102,129,0,8,102,129,0,16,102,129,0,24,102,129,0,
+32,102,129,0,40,102,129,0,48,102,129,0,64,102,129,0,72,102,129,0,
+80,102,129,0,88,102,129,0,96,102,129,0,104,102,129,0,112,102,129,0,
+128,102,129,0,136,102,129,0,144,102,129,0,152,102,129,0,160,102,129,0,
+168,102,129,0,176,102,129,0,192,102,129,0,200,102,129,0,208,102,129,0,
+216,102,129,0,224,102,129,0,232,102,129,0,240,102,129,0,0,103,129,0,
+8,103,129,0,16,103,129,0,24,103,129,0,32,103,129,0,40,103,129,0,
+48,103,129,0,64,103,129,0,72,103,129,0,80,103,129,0,88,103,129,0,
+96,103,129,0,104,103,129,0,112,103,129,0,168,105,129,0,172,105,129,0,
+176,105,129,0,180,105,129,0,184,105,129,0,188,105,129,0,192,105,129,0,
+49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,
+49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,
+49,49,49,49,49,49,49,49,49,177,177,177,177,177,177,177,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,238,238,34,34,187,187,85,85,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+102,108,97,115,104,70,105,108,101,46,99,112,112,0,0,0,67,104,101,99,
+107,105,110,103,32,102,108,97,115,104,32,109,101,109,111,114,121,32,102,105,
+108,101,115,10,0,0,0,0,45,45,45,45,45,45,45,45,45,45,45,45,
+45,45,45,45,45,45,45,45,45,32,58,32,32,45,45,45,45,45,45,45,
+45,45,45,32,32,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,
+45,45,10,0,32,110,111,110,101,32,102,111,117,110,100,10,109,97,114,107,
+105,110,103,32,108,97,115,116,32,118,97,108,105,100,32,102,105,108,101,46,
+46,46,46,0,32,102,111,117,110,100,46,10,76,105,110,107,105,110,103,32,
+118,97,108,105,100,32,102,105,108,101,115,46,46,46,46,32,10,0,0,0,
+32,68,111,110,101,10,82,101,112,97,105,114,32,99,111,109,112,108,101,116,
+101,100,32,115,117,99,99,101,115,115,102,117,108,108,121,32,10,0,0,0,
+10,10,82,101,112,97,105,114,105,110,103,32,116,104,101,32,102,108,97,115,
+104,32,102,105,108,101,32,115,121,115,116,101,109,10,0,0,66,97,100,32,
+100,105,114,101,99,116,111,114,121,44,32,114,101,112,97,105,114,32,97,98,
+111,114,116,101,100,10,0,0,48,120,37,48,56,88,46,48,120,37,48,56,
+88,32,58,32,32,48,120,37,48,56,120,32,32,37,54,100,32,40,61,37,
+35,120,41,10,0,0,0,0,118,97,108,105,100,97,116,105,111,110,32,102,
+97,105,108,101,100,44,32,115,101,97,114,99,104,105,110,103,32,102,111,114,
+32,118,97,108,105,100,32,102,105,108,101,115,46,46,46,46,0,0,0,0,
+32,82,101,112,97,105,114,32,102,97,105,108,101,100,32,10,0,0,0,0,
+86,97,108,105,100,97,116,105,110,103,32,102,108,97,115,104,32,102,105,108,
+101,32,115,121,115,116,101,109,46,46,46,46,46,10,115,105,103,110,97,116,
+117,114,101,49,46,115,105,103,110,97,116,117,114,101,50,32,58,32,32,97,
+100,100,114,101,115,115,32,32,32,32,32,116,111,116,97,108,32,115,105,122,
+101,10,0,0,85,110,115,117,112,112,111,114,116,101,100,32,70,108,97,115,
+104,70,105,108,101,32,118,101,114,115,105,111,110,32,40,97,100,100,114,61,
+48,120,37,88,41,10,0,0,102,108,97,115,104,70,105,108,101,46,99,112,
+112,0,0,0,85,110,115,117,112,112,111,114,116,101,100,32,70,108,97,115,
+104,70,105,108,101,32,118,101,114,115,105,111,110,32,40,97,100,100,114,61,
+48,120,37,88,41,10,0,0,66,73,79,83,32,105,109,97,103,101,32,110,
+111,116,32,102,111,117,110,100,32,105,110,32,102,108,97,115,104,33,10,0,
+70,105,114,109,119,97,114,101,32,105,109,97,103,101,32,110,111,116,32,102,
+111,117,110,100,32,105,110,32,102,108,97,115,104,33,10,0,85,110,101,120,
+112,101,99,116,101,100,32,108,111,99,97,116,105,111,110,32,111,102,32,70,
+105,114,109,119,97,114,101,32,105,110,32,102,108,97,115,104,33,10,0,0,
+32,32,32,69,120,112,101,99,116,101,100,32,97,100,100,114,58,32,37,120,
+32,32,32,32,65,99,116,117,97,108,32,97,100,100,114,58,32,37,120,10,
+0,0,0,0,85,110,101,120,112,101,99,116,101,100,32,115,105,122,101,32,
+111,102,32,70,105,114,109,119,97,114,101,32,104,101,97,100,101,114,33,10,
+0,0,0,0,32,32,32,69,120,112,101,99,116,101,100,32,115,105,122,101,
+58,32,37,120,32,32,32,32,65,99,116,117,97,108,32,115,105,122,101,58,
+32,37,120,10,0,0,0,0,85,110,101,120,112,101,99,116,101,100,32,108,
+111,99,97,116,105,111,110,32,111,102,32,66,73,79,83,32,105,110,32,102,
+108,97,115,104,33,10,0,0,85,110,101,120,112,101,99,116,101,100,32,115,
+105,122,101,32,111,102,32,66,73,79,83,32,104,101,97,100,101,114,33,10,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,22,128,0,
+0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,
+22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,
+0,0,0,0,22,22,128,0,16,0,0,0,8,0,0,0,8,0,0,0,
+32,0,0,0,64,0,0,0,64,0,0,0,64,0,0,0,64,0,0,0,
+64,0,0,0,64,0,0,0,64,0,0,0,64,0,0,0,64,0,0,0,
+64,0,0,0,64,0,0,0,64,0,0,0,64,0,0,0,64,0,0,0,
+64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,184,11,128,0,
+0,0,0,0,40,11,128,0,0,0,0,0,220,10,128,0,0,0,0,0,
+228,10,128,0,0,0,0,0,236,10,128,0,0,0,0,0,244,10,128,0,
+0,0,0,0,32,11,128,0,0,0,0,0,0,0,0,0,0,0,0,0,
+184,11,128,0,0,0,0,0,156,14,128,0,0,0,0,0,220,10,128,0,
+0,0,0,0,228,10,128,0,0,0,0,0,236,10,128,0,0,0,0,0,
+244,10,128,0,0,0,0,0,32,11,128,0,0,0,0,0,0,0,0,0,
+0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,
+22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,
+0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,
+0,0,0,0,0,0,0,0,230,15,128,0,0,0,0,0,72,15,128,0,
+0,0,0,0,38,15,128,0,0,0,0,0,46,15,128,0,0,0,0,0,
+54,15,128,0,0,0,0,0,22,22,128,0,0,0,0,0,62,15,128,0,
+0,0,0,0,0,0,0,0,0,0,0,0,22,22,128,0,0,0,0,0,
+22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,
+0,0,0,0,22,22,128,0,0,0,0,0,22,22,128,0,0,0,0,0,
+22,22,128,0,0,0,0,0,0,0,0,0,0,0,0,0,226,18,128,0,
+0,0,0,0,68,18,128,0,0,0,0,0,34,18,128,0,0,0,0,0,
+42,18,128,0,0,0,0,0,50,18,128,0,0,0,0,0,22,22,128,0,
+0,0,0,0,58,18,128,0,232,3,0,0,0,0,0,0,0,0,0,0,
+67,43,43,32,114,117,110,116,105,109,101,32,97,98,111,114,116,0,0,0,
+102,114,101,101,105,110,103,32,97,114,114,97,121,32,110,111,116,32,97,108,
+108,111,99,97,116,101,100,32,98,121,32,97,110,32,97,114,114,97,121,32,
+110,101,119,32,111,112,101,114,97,116,105,111,110,0,0,0,116,101,114,109,
+105,110,97,116,101,40,41,32,99,97,108,108,101,100,32,98,121,32,116,104,
+101,32,101,120,99,101,112,116,105,111,110,32,104,97,110,100,108,105,110,103,
+32,109,101,99,104,97,110,105,115,109,0,0,114,101,116,117,114,110,101,100,
+32,102,114,111,109,32,97,32,117,115,101,114,45,100,101,102,105,110,101,100,
+32,116,101,114,109,105,110,97,116,101,40,41,32,114,111,117,116,105,110,101,
+0,0,0,0,109,97,105,110,40,41,32,99,97,108,108,101,100,32,109,111,
+114,101,32,116,104,97,110,32,111,110,99,101,0,0,0,0,97,32,112,117,
+114,101,32,118,105,114,116,117,97,108,32,102,117,110,99,116,105,111,110,32,
+119,97,115,32,99,97,108,108,101,100,0,0,105,110,118,97,108,105,100,32,
+100,121,110,97,109,105,99,32,99,97,115,116,0,0,0,0,105,110,118,97,
+108,105,100,32,116,121,112,101,105,100,32,111,112,101,114,97,116,105,111,110,
+0,0,0,0,105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,
+115,116,97,116,105,99,32,111,98,106,101,99,116,32,109,97,114,107,101,100,
+32,102,111,114,32,100,101,115,116,114,117,99,116,105,111,110,32,109,111,114,
+101,32,116,104,97,110,32,111,110,99,101,0,37,115,58,32,37,115,10,0,
+40,110,117,108,108,41,0,0,48,49,50,51,52,53,54,55,56,57,97,98,
+99,100,101,102,48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70,
+40,70,108,111,97,116,105,110,103,32,112,111,105,110,116,32,111,117,116,112,
+117,116,32,117,110,115,117,112,112,111,114,116,101,100,32,119,47,45,110,111,
+102,108,111,97,116,105,111,32,111,114,32,45,102,110,111,110,101,41,0,44,
+32,108,105,110,101,32,0,34,44,32,0,102,105,108,101,32,0,0,0,65,
+115,115,101,114,116,105,111,110,32,102,97,105,108,101,100,58,32,0,0,95,
+117,110,107,110,111,119,110,32,115,116,114,105,110,103,95,0,0,0,0,95,
+78,97,109,101,108,101,115,115,95,0,20,0,2,55,128,0,166,41,128,0,
+0,0,0,0,246,53,128,0,0,0,0,0,0,0,0,0,0,0,0,0,
+64,48,32,16,68,51,34,17,3,0,24,0,240,23,5,0,173,147,200,40,
+240,23,5,0,0,0,128,0,0,226,128,255,4,0,31,232,8,72,7,64,
+6,56,97,2,0,82,32,54,20,0,133,255,114,20,1,66,0,74,177,5,
+128,7,6,0,0,66,64,38,133,0,36,38,188,23,64,30,150,0,35,30,
+240,174,28,10,65,25,4,38,0,64,4,38,0,64,64,46,134,0,37,46,
+188,151,64,14,133,0,1,14,188,23,186,5,128,7,6,0,1,240,93,86,
+2,0,42,86,20,90,234,167,32,0,128,166,255,0,128,174,255,255,0,178,
+0,186,0,194,0,202,0,210,93,54,0,0,38,54,230,0,128,255,216,1,
+128,7,0,0,6,80,198,94,3,0,178,5,128,7,56,0,39,89,203,94,
+3,0,178,5,128,7,44,0,100,66,185,5,128,7,36,0,6,96,200,97,
+130,98,194,98,39,95,1,0,68,58,102,95,1,0,68,50,230,97,179,5,
+191,7,240,255,200,70,3,0,224,65,186,5,128,7,28,0,6,96,200,97,
+7,95,0,0,65,58,70,95,0,0,65,50,230,97,179,5,191,7,240,255,
+127,0,0,0,1,0,0,0,0,0,0,0,84,123,132,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,7,193,0,
+7,16,6,72,8,232,194,233,9,224,32,70,238,15,0,50,245,93,129,50,
+198,142,0,1,224,137,138,13,65,18,2,134,255,255,144,87,1,0,138,54,
+0,255,198,126,1,0,224,121,194,21,65,18,2,118,255,255,142,87,1,0,
+65,74,9,110,255,255,10,96,172,0,12,88,139,0,77,95,0,0,8,86,
+1,0,202,70,255,15,197,61,65,18,2,142,255,255,145,87,1,0,65,18,
+2,134,255,255,144,63,1,0,199,126,240,0,15,112,196,114,14,81,199,110,
+15,0,13,62,3,0,8,96,170,97,9,104,172,105,234,65,191,5,13,110,
+0,240,0,98,133,13,65,74,9,94,255,255,75,7,0,0,65,106,65,98,
+252,105,161,5,245,13,231,97,214,245,197,13,65,74,9,86,255,255,65,106,
+13,142,255,255,145,135,1,0,74,135,0,0,65,98,231,97,198,245,7,120,
+200,121,207,70,255,15,253,17,154,165,64,6,223,0,8,16,198,17,7,136,
+145,0,17,72,6,62,255,255,8,6,223,255,169,45,9,136,200,138,9,128,
+16,137,17,120,208,122,15,137,197,5,95,18,66,79,0,0,194,118,15,0,
+224,113,170,253,16,106,6,112,77,113,245,13,98,143,1,0,2,102,4,0,
+108,143,1,0,2,94,8,0,107,143,1,0,2,86,12,0,106,143,1,0,
+80,18,238,17,138,245,2,22,16,0,181,5,66,79,0,0,95,18,231,17,
+202,253,6,16,2,80,127,0,142,7,225,243,6,16,99,63,9,0,99,71,
+5,0,99,79,1,0,59,6,140,5,128,0,63,6,230,1,128,0,60,6,
+136,0,128,0,57,6,144,20,133,0,0,234,31,192,27,184,2,142,16,0,
+49,215,1,0,2,134,20,0,48,183,1,0,2,126,24,0,47,79,1,0,
+2,118,28,0,46,119,1,0,9,16,186,17,99,7,13,0,35,102,12,0,
+12,110,4,0,109,7,1,0,35,86,12,0,10,94,8,0,107,7,1,0,
+35,134,12,0,16,142,12,0,113,7,1,0,233,201,177,5,249,113,187,5,
+2,232,128,233,233,193,177,5,248,113,251,5,2,80,223,81,10,248,2,80,
+220,81,10,224,247,73,235,5,238,185,201,5,246,209,162,5,162,217,238,73,
+162,13,26,48,9,56,14,120,169,121,15,64,63,6,24,3,128,0,124,0,
+46,6,144,20,133,0,29,224,206,225,45,6,204,20,133,0,29,208,205,209,
+133,29,68,226,28,102,252,255,35,86,12,0,10,94,12,0,43,23,1,0,
+44,143,1,0,209,17,60,87,1,0,68,226,60,95,1,0,68,226,2,48,
+10,56,11,64,191,255,142,254,250,225,138,237,48,6,204,20,133,0,29,224,
+208,225,47,6,20,21,133,0,29,208,207,209,46,6,20,21,133,0,29,200,
+206,201,133,45,250,225,137,13,35,102,12,0,12,110,12,0,45,23,1,0,
+245,5,35,86,12,0,10,94,4,0,43,23,1,0,60,143,1,0,209,17,
+68,226,68,226,28,134,252,255,35,118,12,0,14,126,4,0,47,87,1,0,
+48,111,1,0,205,81,60,95,1,0,68,226,2,48,10,56,11,64,191,255,
+190,252,249,225,138,221,44,6,20,21,133,0,29,224,204,225,43,6,32,21,
+133,0,29,208,203,209,165,53,68,226,28,86,252,255,35,134,12,0,16,142,
+12,0,49,255,1,0,42,127,1,0,207,249,68,226,28,118,252,255,35,102,
+12,0,12,110,4,0,45,207,1,0,46,95,1,0,203,201,68,226,28,86,
+252,255,42,199,1,0,64,86,0,0,3,90,106,95,10,248,31,48,25,56,
+24,142,15,0,16,122,17,128,79,129,16,64,191,255,76,252,64,86,0,0,
+0,90,106,95,10,248,250,225,225,205,46,6,20,21,133,0,29,224,206,225,
+45,6,20,21,133,0,29,208,205,209,44,6,20,21,133,0,29,200,204,201,
+133,45,250,225,137,13,35,86,12,0,10,94,12,0,43,23,1,0,245,5,
+35,134,12,0,16,142,4,0,49,23,1,0,60,127,1,0,207,17,68,226,
+68,226,28,118,252,255,35,102,12,0,12,110,4,0,45,87,1,0,46,95,
+1,0,203,81,60,95,1,0,68,226,2,48,10,56,11,64,191,255,84,252,
+249,225,138,221,42,6,32,21,133,0,29,16,202,17,49,6,116,21,133,0,
+29,248,209,249,48,6,116,21,133,0,208,233,226,249,146,77,35,118,12,0,
+14,126,12,0,44,6,0,0,0,0,47,95,1,0,12,104,171,105,173,249,
+197,61,65,234,29,86,255,255,10,231,0,0,220,142,48,0,17,128,164,130,
+16,112,194,114,14,120,35,102,12,0,15,104,204,105,45,103,1,0,68,18,
+2,94,252,255,43,87,1,0,12,208,202,209,58,79,1,0,220,142,128,0,
+224,137,178,5,224,73,178,29,220,134,3,0,16,112,194,114,14,120,35,102,
+12,0,15,104,204,105,45,103,1,0,224,97,226,13,220,94,8,0,224,89,
+162,5,194,74,204,73,220,86,8,0,224,81,162,5,162,74,122,79,1,0,
+255,17,202,197,35,55,9,0,35,63,5,0,35,71,1,0,63,6,136,5,
+128,0,123,0,78,6,255,243,128,7,225,0,6,232,7,224,37,143,21,128,
+224,137,178,5,130,255,236,1,37,135,25,128,224,129,178,5,130,255,14,58,
+37,127,29,128,224,121,178,5,191,255,76,250,37,119,33,128,224,113,194,5,
+0,50,130,255,100,83,29,48,28,104,13,56,128,255,178,2,64,6,255,0,
+128,7,225,0,6,232,7,224,224,233,226,13,61,143,1,0,224,137,210,5,
+125,7,1,0,128,255,108,0,129,226,201,5,29,48,130,255,134,22,64,6,
+255,0,132,7,97,0,7,16,8,56,32,71,37,183,40,71,41,0,6,72,
+99,23,1,0,38,6,84,123,132,0,130,255,66,28,196,255,144,140,170,29,
+196,63,144,140,0,50,129,255,102,171,1,138,99,143,5,0,31,50,128,255,
+42,0,61,6,128,29,148,0,29,48,31,58,128,255,36,0,224,81,186,253,
+35,54,4,0,2,58,191,255,130,255,133,5,33,6,2,99,0,0,97,0,
+33,6,26,99,0,0,97,0,33,6,120,191,1,0,97,0,128,7,225,0,
+0,226,64,22,134,0,34,238,144,142,125,7,1,0,29,54,4,0,0,58,
+32,70,124,0,191,255,90,251,125,7,26,0,65,226,29,238,128,0,28,6,
+216,255,134,245,32,142,40,0,100,143,93,134,