From patchwork Sat Sep 30 01:37:51 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Mokhtar, Amr" X-Patchwork-Id: 29448 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id E6E6B1B1A4; Sat, 30 Sep 2017 03:38:05 +0200 (CEST) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by dpdk.org (Postfix) with ESMTP id 515AF1B160 for ; Sat, 30 Sep 2017 03:38:02 +0200 (CEST) Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga102.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 29 Sep 2017 18:38:01 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos; i="5.42,455,1500966000"; d="scan'208"; a="1020035440" Received: from silpixa00391537.ir.intel.com (HELO silpixa00391537.ger.corp.intel.com) ([10.237.222.189]) by orsmga003.jf.intel.com with ESMTP; 29 Sep 2017 18:37:59 -0700 From: Amr Mokhtar To: dev@dpdk.org Cc: niall.power@intel.com, chris.macnamara@intel.com, Amr Mokhtar Date: Sat, 30 Sep 2017 02:37:51 +0100 Message-Id: <1506735475-77078-2-git-send-email-amr.mokhtar@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1506735475-77078-1-git-send-email-amr.mokhtar@intel.com> References: <1506735475-77078-1-git-send-email-amr.mokhtar@intel.com> Subject: [dpdk-dev] [PATCH v1 2/6] bbdev: PMD drivers (null/turbo_sw) X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Signed-off-by: Amr Mokhtar --- drivers/Makefile | 2 + drivers/bbdev/Makefile | 41 + drivers/bbdev/null/Makefile | 54 + drivers/bbdev/null/bbdev_null.c | 350 +++++ drivers/bbdev/null/rte_pmd_bbdev_null_version.map | 3 + drivers/bbdev/turbo_sw/Makefile | 64 + drivers/bbdev/turbo_sw/bbdev_turbo_software.c | 1216 ++++++++++++++++++ .../bbdev/turbo_sw/bbdev_turbo_software_tables.h | 1344 ++++++++++++++++++++ .../turbo_sw/rte_pmd_bbdev_turbo_sw_version.map | 3 + 9 files changed, 3077 insertions(+) create mode 100644 drivers/bbdev/Makefile create mode 100644 drivers/bbdev/null/Makefile create mode 100644 drivers/bbdev/null/bbdev_null.c create mode 100644 drivers/bbdev/null/rte_pmd_bbdev_null_version.map create mode 100644 drivers/bbdev/turbo_sw/Makefile create mode 100644 drivers/bbdev/turbo_sw/bbdev_turbo_software.c create mode 100644 drivers/bbdev/turbo_sw/bbdev_turbo_software_tables.h create mode 100644 drivers/bbdev/turbo_sw/rte_pmd_bbdev_turbo_sw_version.map diff --git a/drivers/Makefile b/drivers/Makefile index 7fef66d..66f40eb 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -40,5 +40,7 @@ DIRS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += crypto DEPDIRS-crypto := mempool DIRS-$(CONFIG_RTE_LIBRTE_EVENTDEV) += event DEPDIRS-event := bus +DIRS-$(CONFIG_RTE_LIBRTE_BBDEV) += bbdev +DEPDIRS-bbdev := mempool include $(RTE_SDK)/mk/rte.subdir.mk diff --git a/drivers/bbdev/Makefile b/drivers/bbdev/Makefile new file mode 100644 index 0000000..cbdc403 --- /dev/null +++ b/drivers/bbdev/Makefile @@ -0,0 +1,41 @@ +# BSD LICENSE +# +# Copyright(c) 2017 Intel Corporation. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * 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. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT +# OWNER 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. + +include $(RTE_SDK)/mk/rte.vars.mk + +core-libs := librte_eal librte_mbuf librte_mempool librte_ring +core-libs += librte_bbdev librte_kvargs + +DIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_TURBO_SW) += turbo_sw +DEPDIRS-turbo_sw = $(core-libs) +DIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_NULL) += null +DEPDIRS-null = $(core-libs) + +include $(RTE_SDK)/mk/rte.subdir.mk diff --git a/drivers/bbdev/null/Makefile b/drivers/bbdev/null/Makefile new file mode 100644 index 0000000..d1eb31a --- /dev/null +++ b/drivers/bbdev/null/Makefile @@ -0,0 +1,54 @@ +# BSD LICENSE +# +# Copyright(c) 2017 Intel Corporation. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * 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. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT +# OWNER 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. + +include $(RTE_SDK)/mk/rte.vars.mk +# library name +LIB = librte_pmd_bbdev_null.a + +# build flags +CFLAGS += -O3 +CFLAGS += $(WERROR_FLAGS) + +# versioning export map +EXPORT_MAP := rte_pmd_bbdev_null_version.map + +# library version +LIBABIVER := 1 + +# library source files +SRCS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_NULL) += bbdev_null.c + +# library dependencies +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_NULL) += lib/librte_bbdev +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_NULL) += lib/librte_eal +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_NULL) += lib/librte_ring + +include $(RTE_SDK)/mk/rte.lib.mk + diff --git a/drivers/bbdev/null/bbdev_null.c b/drivers/bbdev/null/bbdev_null.c new file mode 100644 index 0000000..1d15708 --- /dev/null +++ b/drivers/bbdev/null/bbdev_null.c @@ -0,0 +1,350 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT + * OWNER 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. + */ +#include + +#include +#include +#include +#include +#include +#include + +#define DRIVER_NAME bbdev_null + +/* Initialisation params structure that can be used by null BBDEV driver */ +struct bbdev_null_params { + int socket_id; /*< Null BBDEV socket */ + uint16_t queues_num; /*< Null BBDEV queues number */ +}; + +/* Accecptable params for null BBDEV devices */ +#define BBDEV_NULL_MAX_NB_QUEUES_ARG "max_nb_queues" +#define BBDEV_NULL_SOCKET_ID_ARG "socket_id" + +static const char * const bbdev_null_valid_params[] = { + BBDEV_NULL_MAX_NB_QUEUES_ARG, + BBDEV_NULL_SOCKET_ID_ARG +}; + +/* private data structure */ +struct bbdev_private { + unsigned int max_nb_queues; /**< Max number of queues */ +}; + +/* queue */ +struct bbdev_queue { + struct rte_ring *processed_pkts; /* Ring for processed packets */ +} __rte_cache_aligned; + +/* Get device info */ +static void +info_get(struct rte_bbdev *dev, struct rte_bbdev_driver_info *dev_info) +{ + struct bbdev_private *internals = dev->data->dev_private; + + static const struct rte_bbdev_op_cap bbdev_capabilities[] = { + RTE_BBDEV_END_OF_CAPABILITIES_LIST(), + }; + + static struct rte_bbdev_conf default_conf; + + static struct rte_bbdev_queue_conf default_queue_conf = { + .queue_size = RTE_BBDEV_QUEUE_SIZE_LIMIT, + }; + + default_conf.socket = dev->data->socket_id; + default_queue_conf.socket = dev->data->socket_id; + + dev_info->driver_name = RTE_STR(DRIVER_NAME); + dev_info->max_num_queues = internals->max_nb_queues; + dev_info->queue_size_lim = RTE_BBDEV_QUEUE_SIZE_LIMIT; + dev_info->hardware_accelerated = false; + dev_info->max_queue_priority = 0; + dev_info->default_conf = default_conf; + dev_info->default_queue_conf = default_queue_conf; + dev_info->capabilities = bbdev_capabilities; + dev_info->cpu_flag_reqs = NULL; + dev_info->min_alignment = 0; + + rte_bbdev_log_debug("got device info from %u", dev->data->dev_id); +} + +/* Release queue */ +static int +q_release(struct rte_bbdev *dev, uint16_t q_id) +{ + struct bbdev_queue *q = dev->data->queues[q_id].queue_private; + + if (q != NULL) { + rte_ring_free(q->processed_pkts); + rte_free(q); + dev->data->queues[q_id].queue_private = NULL; + } + + rte_bbdev_log_debug("released device queue %u:%u", + dev->data->dev_id, q_id); + return 0; +} + +/* Setup a queue */ +static int +q_setup(struct rte_bbdev *dev, uint16_t q_id, + const struct rte_bbdev_queue_conf *queue_conf) +{ + struct bbdev_queue *q; + char ring_name[RTE_RING_NAMESIZE]; + snprintf(ring_name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME) "%u:%u", + dev->data->dev_id, q_id); + + /* Allocate the queue data structure. */ + q = rte_zmalloc_socket(RTE_STR(DRIVER_NAME), sizeof(*q), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q == NULL) { + rte_bbdev_log(ERR, "Failed to allocate queue memory"); + return -ENOMEM; + } + + q->processed_pkts = rte_ring_create(ring_name, queue_conf->queue_size, + queue_conf->socket, RING_F_SP_ENQ | RING_F_SC_DEQ); + if (q->processed_pkts == NULL) { + rte_bbdev_log(ERR, "Failed to create ring"); + goto free_q; + } + + dev->data->queues[q_id].queue_private = q; + rte_bbdev_log_debug("setup device queue %s", ring_name); + return 0; + +free_q: + rte_free(q); + return -EFAULT; +} + +static const struct rte_bbdev_ops pmd_ops = { + .configure = NULL, + .start = NULL, + .stop = NULL, + .close = NULL, + .info_get = info_get, + .stats_get = NULL, + .stats_reset = NULL, + .queue_setup = q_setup, + .queue_release = q_release, + .queue_start = NULL, + .queue_stop = NULL, + .queue_intr_enable = NULL, + .queue_intr_disable = NULL +}; + +/* Enqueue burst */ +static uint16_t +enqueue_ops(struct rte_bbdev_queue_data *q_data, struct rte_bbdev_op **ops, + uint16_t nb_ops) +{ + struct bbdev_queue *q = q_data->queue_private; + uint16_t nb_enqueued = rte_ring_enqueue_burst(q->processed_pkts, + (void **)ops, nb_ops, NULL); + + q_data->queue_stats.enqueue_err_count += nb_ops - nb_enqueued; + q_data->queue_stats.enqueued_count += nb_enqueued; + + return nb_enqueued; +} + +/* Dequeue burst */ +static uint16_t +dequeue_ops(struct rte_bbdev_queue_data *q_data, struct rte_bbdev_op **ops, + uint16_t nb_ops) +{ + struct bbdev_queue *q = q_data->queue_private; + uint16_t nb_dequeued = rte_ring_dequeue_burst(q->processed_pkts, + (void **)ops, nb_ops, NULL); + q_data->queue_stats.dequeued_count += nb_dequeued; + + return nb_dequeued; +} + +/* Parse 16bit integer from string argument */ +static inline int +parse_u16_arg(const char *key, const char *value, void *extra_args) +{ + uint16_t *u16 = extra_args; + unsigned int long result; + + if ((value == NULL) || (extra_args == NULL)) + return -EINVAL; + errno = 0; + result = strtoul(value, NULL, 0); + if ((result >= (1 << 16)) || (errno != 0)) { + rte_bbdev_log(ERR, "Invalid value %lu for %s", result, key); + return -ERANGE; + } + *u16 = (uint16_t)result; + return 0; +} + +/* Parse parameters used to create device */ +static int +parse_bbdev_null_params(struct bbdev_null_params *params, + const char *input_args) +{ + struct rte_kvargs *kvlist = NULL; + int ret = 0; + + if (params == NULL) + return -EINVAL; + if (input_args) { + kvlist = rte_kvargs_parse(input_args, bbdev_null_valid_params); + if (kvlist == NULL) + return -EFAULT; + + ret = rte_kvargs_process(kvlist, bbdev_null_valid_params[0], + &parse_u16_arg, ¶ms->queues_num); + if (ret < 0) + goto exit; + + ret = rte_kvargs_process(kvlist, bbdev_null_valid_params[1], + &parse_u16_arg, ¶ms->socket_id); + if (ret < 0) + goto exit; + + if (params->socket_id >= RTE_MAX_NUMA_NODES) { + rte_bbdev_log(ERR, "Invalid socket, must be < %u", + RTE_MAX_NUMA_NODES); + goto exit; + } + } + +exit: + if (kvlist) + rte_kvargs_free(kvlist); + return ret; +} + +/* Create device */ +static int +null_bbdev_create(struct rte_vdev_device *vdev, + struct bbdev_null_params *init_params) +{ + struct rte_bbdev *bbdev; + size_t dev_private_size = sizeof(struct bbdev_private); + struct bbdev_private *internals; + + vdev->device.numa_node = init_params->socket_id; + + bbdev = rte_bbdev_vdev_allocate(vdev, dev_private_size); + if (bbdev == NULL) { + rte_bbdev_log(ERR, "Failed to create %s", + rte_vdev_device_name(vdev)); + return -EFAULT; + } + + bbdev->dev_ops = &pmd_ops; + + /* register rx/tx burst functions for data path */ + bbdev->dequeue_ops = dequeue_ops; + bbdev->enqueue_ops = enqueue_ops; + internals = bbdev->data->dev_private; + internals->max_nb_queues = init_params->queues_num; + + return 0; +} + +/* Initialise device */ +static int +null_bbdev_probe(struct rte_vdev_device *vdev) +{ + struct bbdev_null_params init_params = { + rte_socket_id(), + RTE_BBDEV_DEFAULT_MAX_NB_QUEUES + }; + const char *name; + const char *input_args; + + if (!vdev) + return -EINVAL; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + input_args = rte_vdev_device_args(vdev); + parse_bbdev_null_params(&init_params, input_args); + + rte_bbdev_log_debug("Init %s on NUMA node %d with max queues: %d", + name, init_params.socket_id, init_params.queues_num); + + return null_bbdev_create(vdev, &init_params); +} + +/* Uninitialise device */ +static int +null_bbdev_remove(struct rte_vdev_device *vdev) +{ + struct rte_bbdev *bbdev; + const char *name; + + if (!vdev) + return -EINVAL; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + + bbdev = rte_bbdev_get_named_dev(name); + if (bbdev == NULL) + return -EINVAL; + + rte_free(bbdev->data->dev_private); + + return rte_bbdev_release(bbdev); +} + +static struct rte_vdev_driver bbdev_null_pmd_drv = { + .probe = null_bbdev_probe, + .remove = null_bbdev_remove +}; + +RTE_PMD_REGISTER_VDEV(DRIVER_NAME, bbdev_null_pmd_drv); +RTE_PMD_REGISTER_ALIAS(DRIVER_NAME, bbdev_null_pmd); +RTE_PMD_REGISTER_PARAM_STRING(DRIVER_NAME, + BBDEV_NULL_MAX_NB_QUEUES_ARG"= " + BBDEV_NULL_SOCKET_ID_ARG"="); + +int bbdev_logtype; +RTE_INIT(null_bbdev_init_log); +static void +null_bbdev_init_log(void) +{ + bbdev_logtype = rte_log_register("pmd.null_bbdev"); + if (bbdev_logtype >= 0) + rte_log_set_level(bbdev_logtype, RTE_LOG_NOTICE); +} diff --git a/drivers/bbdev/null/rte_pmd_bbdev_null_version.map b/drivers/bbdev/null/rte_pmd_bbdev_null_version.map new file mode 100644 index 0000000..a753031 --- /dev/null +++ b/drivers/bbdev/null/rte_pmd_bbdev_null_version.map @@ -0,0 +1,3 @@ +DPDK_17.11 { + local: *; +}; diff --git a/drivers/bbdev/turbo_sw/Makefile b/drivers/bbdev/turbo_sw/Makefile new file mode 100644 index 0000000..51ff401 --- /dev/null +++ b/drivers/bbdev/turbo_sw/Makefile @@ -0,0 +1,64 @@ +# BSD LICENSE +# +# Copyright(c) 2017 Intel Corporation. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * 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. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT +# OWNER 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. + +include $(RTE_SDK)/mk/rte.vars.mk + +ifeq ($(BBLIB_PATH),) +$(error "Please define BBLIB_PATH environment variable") +endif + +# library name +LIB = librte_pmd_bbdev_turbo_sw.a + +# build flags +CFLAGS += -O3 +CFLAGS += $(WERROR_FLAGS) + +# versioning export map +EXPORT_MAP := rte_pmd_bbdev_turbo_sw_version.map + +# external library dependencies +CFLAGS += -I$(BBLIB_PATH)/lib_common +CFLAGS += -I$(BBLIB_PATH)/lib_turbo +CFLAGS += -I$(BBLIB_PATH)/lib_crc +CFLAGS += -I$(BBLIB_PATH)/lib_rate_matching + +# library version +LIBABIVER := 1 + +# library source files +SRCS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_TURBO_SW) += bbdev_turbo_software.c + +# library dependencies +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_TURBO_SW) += lib/librte_bbdev +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_TURBO_SW) += lib/librte_eal +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BBDEV_TURBO_SW) += lib/librte_ring + +include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/bbdev/turbo_sw/bbdev_turbo_software.c b/drivers/bbdev/turbo_sw/bbdev_turbo_software.c new file mode 100644 index 0000000..020b138 --- /dev/null +++ b/drivers/bbdev/turbo_sw/bbdev_turbo_software.c @@ -0,0 +1,1216 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT + * OWNER 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. + */ +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "bbdev_turbo_software_tables.h" + +#define DRIVER_NAME turbo_sw + +#define MAX_CB_SIZE (6144) +#define MAX_NCB ((MAX_CB_SIZE + 4) * 3) + +/* private data structure */ +struct bbdev_private { + unsigned int max_nb_queues; /**< Max number of queues */ +}; + +/* Initialisation params structure that can be used by Turbo SW driver */ +struct turbo_sw_params { + int socket_id; /*< Turbo SW device socket */ + uint16_t queues_num; /*< Turbo SW device queues number */ +}; + +/* Accecptable params for Turbo SW devices */ +#define TURBO_SW_MAX_NB_QUEUES_ARG "max_nb_queues" +#define TURBO_SW_SOCKET_ID_ARG "socket_id" + +static const char * const turbo_sw_valid_params[] = { + TURBO_SW_MAX_NB_QUEUES_ARG, + TURBO_SW_SOCKET_ID_ARG +}; + +/* queue */ +struct turbo_sw_queue { + /* Ring for processed (encoded/decoded) operations which are ready to + * be dequeued. + */ + struct rte_ring *processed_pkts; + /* Stores output from turbo encoder */ + uint8_t *enc_out; + /* Stores output after rate-matching */ + uint8_t *rm_out; + /* Alpha gamma buf for bblib_turbo_decoder() function */ + int8_t *ag; + /* Temp buf for bblib_turbo_decoder() function */ + uint16_t *code_block; + /* Input buf for bblib_harqcombine_lte() function */ + uint8_t *harq_input; + /* Output buf for bblib_harqcombine_lte() function */ + uint8_t *harq_output; + /* Output buf for bblib_rate_dematching_lte() function */ + uint8_t *deint_output; + /* Output buf for bblib_turbodec_adapter_lte() function */ + uint8_t *adapter_output; + /* Operation type of this queue */ + enum rte_bbdev_op_type type; +} __rte_cache_aligned; + +/* Calculate index based on Table 5.1.3-3 from TS34.212 */ +static inline int32_t +compute_idx(uint16_t k) +{ + int32_t result = 0; + + if (k < 40 || k > MAX_CB_SIZE) + return -1; + + if (k > 2048) { + if ((k - 2048) % 64 != 0) + result = -1; + + result = 124 + (k - 2048) / 64; + } else if (k <= 512) { + if ((k - 40) % 8 != 0) + result = -1; + + result = (k - 40) / 8 + 1; + } else if (k <= 1024) { + if ((k - 512) % 16 != 0) + result = -1; + + result = 60 + (k - 512) / 16; + } else { /* 1024 < k <= 2048 */ + if ((k - 1024) % 32 != 0) + result = -1; + + result = 92 + (k - 1024) / 32; + } + + return result; +} + +/* Read flag value 0/1 from bitmap */ +static inline bool +check_bit(uint32_t bitmap, uint32_t bitmask) +{ + return bitmap & bitmask; +} + +/* Get device info */ +static void +info_get(struct rte_bbdev *dev, struct rte_bbdev_driver_info *dev_info) +{ + struct bbdev_private *internals = dev->data->dev_private; + + static const struct rte_bbdev_op_cap bbdev_capabilities[] = { + { + .type = RTE_BBDEV_OP_TURBO_DEC, + .cap.turbo_dec = { + .capability_flags = + RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE | + RTE_BBDEV_TURBO_RAW_INPUT_DATA, + .num_buffers_src = RTE_BBDEV_MAX_CODE_BLOCKS, + .num_buffers_hard_out = + RTE_BBDEV_MAX_CODE_BLOCKS, + .num_buffers_soft_out = 0, + } + }, + { + .type = RTE_BBDEV_OP_TURBO_ENC, + .cap.turbo_enc = { + .capability_flags = + RTE_BBDEV_TURBO_CRC_24B_ATTACH | + RTE_BBDEV_TURBO_RATE_MATCH | + RTE_BBDEV_TURBO_RV_INDEX_BYPASS, + .num_buffers_src = RTE_BBDEV_MAX_CODE_BLOCKS, + .num_buffers_dst = RTE_BBDEV_MAX_CODE_BLOCKS, + } + }, + RTE_BBDEV_END_OF_CAPABILITIES_LIST() + }; + + static struct rte_bbdev_conf default_conf; + + static struct rte_bbdev_queue_conf default_queue_conf = { + .queue_size = RTE_BBDEV_QUEUE_SIZE_LIMIT, + }; + + static const enum rte_cpu_flag_t cpu_flag = RTE_CPUFLAG_SSE4_2; + + default_conf.socket = dev->data->socket_id; + default_queue_conf.socket = dev->data->socket_id; + + dev_info->driver_name = RTE_STR(DRIVER_NAME); + dev_info->max_num_queues = internals->max_nb_queues; + dev_info->queue_size_lim = RTE_BBDEV_QUEUE_SIZE_LIMIT; + dev_info->hardware_accelerated = false; + dev_info->max_queue_priority = 0; + dev_info->default_conf = default_conf; + dev_info->default_queue_conf = default_queue_conf; + dev_info->capabilities = bbdev_capabilities; + dev_info->cpu_flag_reqs = &cpu_flag; + dev_info->min_alignment = 64; + + rte_bbdev_log_debug("got device info from %u\n", dev->data->dev_id); +} + +/* Release queue */ +static int +q_release(struct rte_bbdev *dev, uint16_t q_id) +{ + struct turbo_sw_queue *q = dev->data->queues[q_id].queue_private; + + if (q != NULL) { + rte_ring_free(q->processed_pkts); + rte_free(q->enc_out); + rte_free(q->rm_out); + rte_free(q->ag); + rte_free(q->code_block); + rte_free(q->harq_input); + rte_free(q->harq_output); + rte_free(q->deint_output); + rte_free(q->adapter_output); + rte_free(q); + dev->data->queues[q_id].queue_private = NULL; + } + + rte_bbdev_log_debug("released device queue %u:%u", + dev->data->dev_id, q_id); + return 0; +} + +/* Setup a queue */ +static int +q_setup(struct rte_bbdev *dev, uint16_t q_id, + const struct rte_bbdev_queue_conf *queue_conf) +{ + int ret; + struct turbo_sw_queue *q; + char name[RTE_RING_NAMESIZE]; + + /* Allocate the queue data structure. */ + q = rte_zmalloc_socket(RTE_STR(DRIVER_NAME), sizeof(*q), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q == NULL) { + rte_bbdev_log(ERR, "Failed to allocate queue memory"); + return -ENOMEM; + } + + /* Allocate memory for encoder output. */ + ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_enc_out%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->enc_out = rte_zmalloc_socket(name, + ((MAX_CB_SIZE >> 3) + 3) * sizeof(*q->enc_out) * 3, + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->enc_out == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for rate matching output. */ + ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_rm_out%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->rm_out = rte_zmalloc_socket(name, + ((MAX_CB_SIZE >> 3) + 3) * sizeof(*q->rm_out) * 3, + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->rm_out == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for Aplha Gamma temp buffer. */ + ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_ag%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->ag = rte_zmalloc_socket(name, + MAX_CB_SIZE * 10 * sizeof(*q->ag), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->ag == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for code block temp buffer. */ + ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"_cb%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->code_block = rte_zmalloc_socket(name, + (6144 >> 3) * sizeof(*q->code_block), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->code_block == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for HARQ input. */ + ret = snprintf(name, RTE_RING_NAMESIZE, + RTE_STR(DRIVER_NAME)"_harq_input%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->harq_input = rte_zmalloc_socket(name, + MAX_NCB * sizeof(*q->harq_input), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->harq_input == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for HARQ output. */ + ret = snprintf(name, RTE_RING_NAMESIZE, + RTE_STR(DRIVER_NAME)"_harq_output%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->harq_output = rte_zmalloc_socket(name, + MAX_NCB * sizeof(*q->harq_output), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->harq_output == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for Deinterleaver output. */ + ret = snprintf(name, RTE_RING_NAMESIZE, + RTE_STR(DRIVER_NAME)"_deint_output%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->deint_output = rte_zmalloc_socket(NULL, + MAX_NCB * sizeof(*q->deint_output), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->deint_output == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Allocate memory for Adapter output. */ + ret = snprintf(name, RTE_RING_NAMESIZE, + RTE_STR(DRIVER_NAME)"_adapter_output%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->adapter_output = rte_zmalloc_socket(NULL, + MAX_CB_SIZE * 6 * sizeof(*q->adapter_output), + RTE_CACHE_LINE_SIZE, queue_conf->socket); + if (q->adapter_output == NULL) { + rte_bbdev_log(ERR, + "Failed to allocate queue memory for %s", name); + goto free_q; + } + + /* Create ring for packets awaiting to be dequeued. */ + ret = snprintf(name, RTE_RING_NAMESIZE, RTE_STR(DRIVER_NAME)"%u:%u", + dev->data->dev_id, q_id); + if ((ret < 0) || (ret >= (int)RTE_RING_NAMESIZE)) { + rte_bbdev_log(ERR, + "Creating queue name for device %u queue %u failed", + dev->data->dev_id, q_id); + return -ENAMETOOLONG; + } + q->processed_pkts = rte_ring_create(name, queue_conf->queue_size, + queue_conf->socket, RING_F_SP_ENQ | RING_F_SC_DEQ); + if (q->processed_pkts == NULL) { + rte_bbdev_log(ERR, "Failed to create ring for %s", name); + goto free_q; + } + + q->type = queue_conf->op_type; + + dev->data->queues[q_id].queue_private = q; + rte_bbdev_log_debug("setup device queue %s", name); + return 0; + +free_q: + rte_ring_free(q->processed_pkts); + rte_free(q->enc_out); + rte_free(q->rm_out); + rte_free(q->ag); + rte_free(q->code_block); + rte_free(q->harq_input); + rte_free(q->harq_output); + rte_free(q->deint_output); + rte_free(q->adapter_output); + rte_free(q); + return -EFAULT; +} + +static const struct rte_bbdev_ops pmd_ops = { + .configure = NULL, + .start = NULL, + .stop = NULL, + .close = NULL, + .info_get = info_get, + .stats_get = NULL, + .stats_reset = NULL, + .queue_setup = q_setup, + .queue_release = q_release, + .queue_start = NULL, + .queue_stop = NULL, + .queue_intr_enable = NULL, + .queue_intr_disable = NULL +}; + +/* Checks if the encoder input buffer is correct. + * Returns 0 if it's valid, -1 otherwise. + */ +static inline int +is_enc_input_valid(uint16_t k, int32_t k_idx, uint16_t in_length) +{ + if (k_idx < 0) { + rte_bbdev_log(ERR, "K Index is invalid"); + return -1; + } + + if (in_length != (k >> 3)) { + rte_bbdev_log(ERR, + "Mismatch between input length (%u bytes) and K (%u bits)", + in_length, k); + return -1; + } + + if (in_length > (MAX_CB_SIZE >> 3)) { + rte_bbdev_log(ERR, "Input length (%u) is too big, max: %d", + in_length, (MAX_CB_SIZE >> 3)); + return -1; + } + + return 0; +} + +/* Checks if the decoder input buffer is correct. + * Returns 0 if it's valid, -1 otherwise. + */ +static inline int +is_dec_input_valid(int32_t k_idx, uint16_t in_length) +{ + if (k_idx < 0) { + rte_bbdev_log(ERR, "K index is invalid"); + return -1; + } + + if (in_length > MAX_NCB) { + rte_bbdev_log(ERR, "Input length (%u) is too big, max: %d", + in_length, MAX_NCB); + return -1; + } + + return 0; +} + +static inline void +process_enc_cb(struct turbo_sw_queue *q, struct rte_bbdev_op *op, + uint8_t cb_idx, uint8_t cb_total, uint16_t k, uint32_t e, + struct rte_mbuf *m_in, struct rte_mbuf *m_out, + uint16_t in_offset, uint16_t out_offset, uint16_t *total_left) +{ + int ret; + int16_t k_idx, in_length; + uint16_t m; + uint8_t *in, *out0, *out1, *out2, *tmp_out; + struct rte_bbdev_op_turbo_enc *enc = op->turbo_enc; + struct bblib_crc_request crc_req; + struct bblib_turbo_encoder_request turbo_req; + struct bblib_turbo_encoder_response turbo_resp; + struct bblib_rate_match_dl_request rm_req; + struct bblib_rate_match_dl_response rm_resp; + + k_idx = compute_idx(k); + + in_length = (*total_left >= (m_in->data_len - in_offset)) ? + m_in->data_len - in_offset : *total_left; + *total_left -= in_length; + + ret = is_enc_input_valid(k, k_idx, in_length); + if (ret != 0) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + return; + } + + in = rte_pktmbuf_mtod_offset(m_in, uint8_t *, in_offset); + + /* CRC24B */ + if (enc->op_flags & RTE_BBDEV_TURBO_CRC_24B_ATTACH) { + /* len is shortened by 3 bytes as CRC is attached to + * last 3 bytes. + */ + crc_req.data = in; + crc_req.len = in_length - 3; + if (bblib_lte_crc24b_gen(&crc_req) == -1) { + op->status |= 1 << RTE_BBDEV_CRC_ERROR; + rte_bbdev_log(ERR, "CRC24b generation failed"); + return; + } + } + + /* Turbo encoder */ + + /* Each bit layer output from turbo encoder is (k+4) bits long, i.e. + * input length + 4 tail bits. That's (k/8) + 1 bytes after rounding up. + * So dst_data's length should be 3*(k/8) + 3 bytes. + */ + out0 = q->enc_out; + out1 = RTE_PTR_ADD(out0, in_length + 1); + out2 = RTE_PTR_ADD(out1, in_length + 1); + + turbo_req.case_id = k_idx; + turbo_req.input_win = in; + turbo_req.length = in_length; + turbo_resp.output_win_0 = out0; + turbo_resp.output_win_1 = out1; + turbo_resp.output_win_2 = out2; + if (bblib_turbo_encoder(&turbo_req, &turbo_resp) != 0) { + op->status |= 1 << RTE_BBDEV_DRV_ERROR; + rte_bbdev_log(ERR, "Turbo Encoder failed"); + return; + } + + /* Rate-matching */ + if (enc->op_flags & RTE_BBDEV_TURBO_RATE_MATCH) { + /* index of current code block */ + rm_req.r = cb_idx; + /* total number of code block */ + rm_req.C = cb_total; + /* For DL - 1, UL - 0 */ + rm_req.direction = 1; + rm_req.Nsoft = enc->n_soft; + rm_req.KMIMO = enc->k_mimo; + rm_req.MDL_HARQ = enc->mdl_harq; + rm_req.G = enc->g; + rm_req.NL = enc->nl; + rm_req.Qm = enc->qm; + rm_req.rvidx = enc->rv_index; + rm_req.Kidx = k_idx - 1; + rm_req.nLen = k + 4; + rm_req.tin0 = out0; + rm_req.tin1 = out1; + rm_req.tin2 = out2; + rm_resp.output = q->rm_out; + rm_resp.OutputLen = (e >> 3); + if (enc->op_flags & RTE_BBDEV_TURBO_RV_INDEX_BYPASS) + rm_req.bypass_rvidx = 1; + else + rm_req.bypass_rvidx = 0; + + if (bblib_rate_match_dl(&rm_req, &rm_resp) != 0) { + op->status |= 1 << RTE_BBDEV_DRV_ERROR; + rte_bbdev_log(ERR, "Rate matching failed"); + return; + } + + /* copy rate-match output to turbo_enc entity */ + out0 = (uint8_t *)rte_pktmbuf_append(m_out, + rm_resp.OutputLen); + if (out0 == NULL) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + rte_bbdev_log(ERR, + "Too little space in output mbuf"); + return; + } + enc->output.length += rm_resp.OutputLen; + /* rte_bbdev_op_data.offset can be different than the offset + * of the appended bytes + */ + out0 = rte_pktmbuf_mtod_offset(m_out, uint8_t *, + out_offset); + rte_memcpy(out0, q->rm_out, rm_resp.OutputLen); + } else { + /* Rate matching is bypassed */ + + /* Completing last byte of out0 (where 4 tail bits are stored) + * by moving first 4 bits from out1 + */ + tmp_out = (uint8_t *) --out1; + *tmp_out = *tmp_out | ((*(tmp_out + 1) & 0xF0) >> 4); + tmp_out++; + /* Shifting out1 data by 4 bits to the left */ + for (m = 0; m < in_length; ++m) { + uint8_t *first = tmp_out; + uint8_t second = *(tmp_out + 1); + *first = (*first << 4) | ((second & 0xF0) >> 4); + tmp_out++; + } + /* Shifting out2 data by 8 bits to the left */ + for (m = 0; m < in_length + 1; ++m) { + *tmp_out = *(tmp_out + 1); + tmp_out++; + } + *tmp_out = 0; + + /* copy shifted output to turbo_enc entity */ + out0 = (uint8_t *)rte_pktmbuf_append(m_out, + in_length * 3 + 2); + if (out0 == NULL) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + rte_bbdev_log(ERR, + "Too little space in output mbuf"); + return; + } + enc->output.length += in_length * 3 + 2; + /* rte_bbdev_op_data.offset can be different than the + * offset of the appended bytes + */ + out0 = rte_pktmbuf_mtod_offset(m_out, uint8_t *, + out_offset); + rte_memcpy(out0, q->enc_out, in_length * 3 + 2); + } +} + +static inline void +enqueue_enc_one_op(struct turbo_sw_queue *q, struct rte_bbdev_op *op) +{ + uint8_t cb_idx = 0; + uint8_t cb_total, cab, c_neg; + uint16_t k_pos, k_neg, k; + uint32_t ea, eb, e; + struct rte_bbdev_op_turbo_enc *enc = op->turbo_enc; + uint16_t in_offset = enc->input.offset; + uint16_t out_offset = enc->output.offset; + struct rte_mbuf *m_in = enc->input.data; + struct rte_mbuf *m_out = enc->output.data; + struct rte_mbuf *m_out_next; + uint16_t total_left = enc->input.length; + + if (enc->code_block_mode == 0) { /* For Transport Block mode */ + k_pos = enc->tb_params.k_pos; + k_neg = enc->tb_params.k_neg; + ea = enc->tb_params.ea; + eb = enc->tb_params.eb; + cb_total = enc->tb_params.c; + cab = enc->tb_params.cab; + c_neg = enc->tb_params.c_neg; + } else { /* For Code Block mode */ + k_pos = enc->cb_params.k; + k_neg = enc->cb_params.k; + ea = enc->cb_params.e; + eb = enc->cb_params.e; + cb_total = 1; + cab = 1; + c_neg = 1; + } + + /* Clear op status */ + op->status = 0; + + if (m_in == NULL || m_out == NULL) { + rte_bbdev_log(ERR, "Invalid mbuf pointer"); + op->status = 1 << RTE_BBDEV_DATA_ERROR; + return; + } + + k = (cb_idx < c_neg) ? k_neg : k_pos; + e = (cb_idx < cab) ? ea : eb; + process_enc_cb(q, op, cb_idx, cb_total, k, e, m_in, m_out, in_offset, + out_offset, &total_left); + + for (cb_idx = 1; cb_idx < cb_total; ++cb_idx) { + k = (cb_idx < c_neg) ? k_neg : k_pos; + e = (cb_idx < cab) ? ea : eb; + + m_in = m_in->next; + m_out_next = rte_pktmbuf_alloc(m_out->pool); + if (m_in == NULL || m_out_next == NULL) { + rte_bbdev_log(ERR, "Invalid mbuf pointer"); + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + continue; + } + rte_pktmbuf_chain(m_out, m_out_next); + + process_enc_cb(q, op, cb_idx, cb_total, k, e, m_in, m_out_next, + 0, 0, &total_left); + } + + /* check if all input data was processed */ + if (total_left != 0) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + rte_bbdev_log(ERR, + "Mismatch between rte_bbdev_op_data.length and mbuf data"); + } +} + +static inline uint16_t +enqueue_enc_ops(struct turbo_sw_queue *q, struct rte_bbdev_op **ops, + uint16_t nb_ops) +{ + uint16_t i; + + for (i = 0; i < nb_ops; ++i) + enqueue_enc_one_op(q, ops[i]); + + return rte_ring_enqueue_burst(q->processed_pkts, (void **)ops, nb_ops, + NULL); +} + +static inline int32_t +calc_k0_without_null(int k0, int k_idx) +{ + int32_t null_num; + int32_t i; + + k_idx--; + null_num = kidx_null_num[k_idx]; + for (i = 0; i < null_num; ++i) + if (k0_null_num[k_idx][i] > k0) + break; + return k0 - i; +} + +static inline int32_t +calc_k0(int k, int rv_idx) +{ + int16_t temp; + int32_t ncb, k0; + int32_t r_tc_subblock = ceili(k+4, 32); + int32_t kpai = r_tc_subblock * 32; + int32_t kw = 3 * kpai; + + ncb = kw; + temp = ceili(ncb, 8 * r_tc_subblock); + k0 = r_tc_subblock * (2 * temp * rv_idx + 2); + + return k0; +} + +/* Remove null bytes starting from k0, return number of non-null bytes */ +static inline uint16_t +remove_null_bytes(const uint8_t *in, uint8_t *out, uint16_t k0, uint16_t len) +{ + uint16_t in_idx, out_idx; + + for (in_idx = k0, out_idx = 0; in_idx < len; ++in_idx) + if (in[in_idx] != 0x00) + out[out_idx++] = in[in_idx]; + + for (in_idx = 0; in_idx < k0; ++in_idx) + if (in[in_idx] != 0x00) + out[out_idx++] = in[in_idx]; + + return out_idx; +} + +static inline int +process_raw_buf_dec_op(struct turbo_sw_queue *q, + struct rte_bbdev_op_turbo_dec *dec, uint8_t *in, + uint16_t in_len, int32_t k_idx, uint16_t k, int8_t **out) +{ + struct bblib_turbo_adapter_ul_request adapter_req; + struct bblib_turbo_adapter_ul_response adapter_resp; + struct bblib_harq_combine_ul_request harq_req; + struct bblib_harq_combine_ul_response harq_resp; + struct bblib_deinterleave_ul_request deint_req; + struct bblib_deinterleave_ul_response deint_resp; + int32_t ncb_without_null, k0, k0_without_null; + + ncb_without_null = (k + 4) * 3; + k0 = calc_k0(k, dec->rv_index); + k0_without_null = calc_k0_without_null(k0, k_idx); + + /* Input contains raw RX data - E bytes. */ + harq_req.e = in_len; + /* Assume that it's never a retransmission. */ + harq_req.isretx = 0; + harq_req.k0withoutnull = k0_without_null; + harq_req.ncb = ncb_without_null; + harq_req.pdmout = in; + harq_resp.pharqbuffer = q->harq_output; + bblib_harq_combine_ul(&harq_req, &harq_resp); + + deint_req.pharqbuffer = q->harq_output; + deint_req.ncb = ncb_without_null; + deint_resp.pinteleavebuffer = q->deint_output; + bblib_deinterleave_ul(&deint_req, &deint_resp); + + adapter_req.isinverted = 0; + adapter_req.ncb = ncb_without_null; + adapter_req.pinteleavebuffer = q->deint_output; + adapter_resp.pharqout = q->adapter_output; + bblib_turbo_adapter_ul(&adapter_req, &adapter_resp); + + *out = (int8_t *)q->adapter_output; + return 0; +} + +static inline int +process_circular_buf_dec_op(struct turbo_sw_queue *q, + struct rte_bbdev_op_turbo_dec *dec, uint8_t *in, + uint16_t in_len, int32_t k_idx, int16_t k, int8_t **out) +{ + struct bblib_turbo_adapter_ul_request adapter_req; + struct bblib_turbo_adapter_ul_response adapter_resp; + int32_t ncb, ncb_without_null; + uint8_t *adapter_input = in; + + /* Input contains the cyclic buffer. */ + ncb = ncb_without_null = in_len; + + if (check_bit(dec->op_flags, RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE)) { + struct bblib_harq_combine_ul_request harq_req; + struct bblib_harq_combine_ul_response harq_resp; + struct bblib_deinterleave_ul_request deint_req; + struct bblib_deinterleave_ul_response deint_resp; + int32_t e, k0, k0_without_null; + + ncb_without_null = (k + 4) * 3; + k0 = calc_k0(k, dec->rv_index); + k0_without_null = calc_k0_without_null(k0, k_idx); + + e = remove_null_bytes(in, q->harq_input, k0, ncb); + + harq_req.e = e; + /* Assume that it's never a retransmission. */ + harq_req.isretx = 0; + harq_req.k0withoutnull = k0_without_null; + harq_req.ncb = ncb_without_null; + harq_req.pdmout = q->harq_input; + harq_resp.pharqbuffer = q->harq_output; + bblib_harq_combine_ul(&harq_req, &harq_resp); + + deint_req.pharqbuffer = q->harq_output; + deint_req.ncb = ncb_without_null; + deint_resp.pinteleavebuffer = q->deint_output; + bblib_deinterleave_ul(&deint_req, &deint_resp); + adapter_input = q->deint_output; + } + + adapter_req.isinverted = 0; + adapter_req.ncb = ncb_without_null; + adapter_req.pinteleavebuffer = adapter_input; + adapter_resp.pharqout = q->adapter_output; + bblib_turbo_adapter_ul(&adapter_req, &adapter_resp); + + *out = (int8_t *)q->adapter_output; + return 0; +} + +static inline void +process_dec_cb(struct turbo_sw_queue *q, struct rte_bbdev_op *op, + uint8_t cb_idx, uint16_t k, struct rte_mbuf *m_in, + struct rte_mbuf *m_out, uint16_t in_offset, uint16_t out_offset, + uint16_t *total_left) +{ + int ret; + int32_t k_idx; + uint16_t in_length; + uint32_t iter_cnt; + uint8_t *in, *out; + int8_t *dec_input; + struct bblib_turbo_decoder_request turbo_req; + struct bblib_turbo_decoder_response turbo_resp; + struct rte_bbdev_op_turbo_dec *dec = op->turbo_dec; + + k_idx = compute_idx(k); + + in_length = (*total_left >= (m_in->data_len - in_offset)) ? + m_in->data_len - in_offset : *total_left; + *total_left -= in_length; + + ret = is_dec_input_valid(k_idx, in_length); + if (ret != 0) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + return; + } + + in = rte_pktmbuf_mtod_offset(m_in, uint8_t *, in_offset); + + if (check_bit(dec->op_flags, RTE_BBDEV_TURBO_RAW_INPUT_DATA)) { + ret = process_raw_buf_dec_op(q, dec, in, in_length, + k_idx, k, &dec_input); + if (ret != 0) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + return; + } + } else { + ret = process_circular_buf_dec_op(q, dec, in, in_length, + k_idx, k, &dec_input); + if (ret != 0) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + return; + } + } + + out = (uint8_t *)rte_pktmbuf_append(m_out, (k >> 3)); + if (out == NULL) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + rte_bbdev_log(ERR, "Too little space in output mbuf"); + return; + } + /* rte_bbdev_op_data.offset can be different than the offset of the + * appended bytes + */ + out = rte_pktmbuf_mtod_offset(m_out, uint8_t *, out_offset); + turbo_req.c = cb_idx + 1; + turbo_req.input = dec_input; + turbo_req.k = k; + turbo_req.k_idx = k_idx; + turbo_req.max_iter_num = dec->iter_max; + turbo_resp.ag_buf = q->ag; + turbo_resp.cb_buf = q->code_block; + turbo_resp.output = out; + iter_cnt = bblib_turbo_decoder(&turbo_req, &turbo_resp); + + dec->hard_output.length += (k >> 3); + + if (iter_cnt > 0) + dec->iter_count = RTE_MAX(iter_cnt, dec->iter_count); + else { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + rte_bbdev_log(ERR, "Turbo Decoder failed"); + return; + } +} + +static inline void +enqueue_dec_one_op(struct turbo_sw_queue *q, struct rte_bbdev_op *op) +{ + uint8_t cb_idx = 0; + uint8_t cb_total, c_neg; + uint16_t k_pos, k_neg, k; + struct rte_bbdev_op_turbo_dec *dec = op->turbo_dec; + struct rte_mbuf *m_in = dec->input.data; + struct rte_mbuf *m_out = dec->hard_output.data; + struct rte_mbuf *m_out_next; + uint16_t total_left = dec->input.length; + uint16_t in_offset = dec->input.offset; + uint16_t out_offset = dec->hard_output.offset; + + if (dec->code_block_mode == 0) { /* For Transport Block mode */ + k_pos = dec->tb_params.k_pos; + k_neg = dec->tb_params.k_neg; + cb_total = dec->tb_params.c; + c_neg = dec->tb_params.c_neg; + } else { /* For Code Block mode */ + k_pos = dec->cb_params.k; + k_neg = dec->cb_params.k; + cb_total = 1; + c_neg = 1; + } + + /* Clear op status */ + op->status = 0; + + if (m_in == NULL || m_out == NULL) { + rte_bbdev_log(ERR, "Invalid mbuf pointer"); + op->status = 1 << RTE_BBDEV_DATA_ERROR; + return; + } + + k = (cb_idx < c_neg) ? k_neg : k_pos; + process_dec_cb(q, op, cb_idx, k, m_in, m_out, in_offset, out_offset, + &total_left); + + for (cb_idx = 1; cb_idx < cb_total; ++cb_idx) { + k = (cb_idx < c_neg) ? k_neg : k_pos; + + m_in = m_in->next; + m_out_next = rte_pktmbuf_alloc(m_out->pool); + if (m_in == NULL || m_out_next == NULL) { + rte_bbdev_log(ERR, "Invalid mbuf pointer"); + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + return; + } + rte_pktmbuf_chain(m_out, m_out_next); + + process_dec_cb(q, op, cb_idx, k, m_in, m_out, in_offset, + out_offset, &total_left); + } + if (total_left != 0) { + op->status |= 1 << RTE_BBDEV_DATA_ERROR; + rte_bbdev_log(ERR, + "Mismatch between rte_bbdev_op_data.length and mbuf data"); + } +} + +static inline uint16_t +enqueue_dec_ops(struct turbo_sw_queue *q, struct rte_bbdev_op **ops, + uint16_t nb_ops) +{ + uint16_t i; + + for (i = 0; i < nb_ops; ++i) + enqueue_dec_one_op(q, ops[i]); + + return rte_ring_enqueue_burst(q->processed_pkts, (void **)ops, nb_ops, + NULL); +} + +/* Enqueue burst */ +static uint16_t +enqueue_ops(struct rte_bbdev_queue_data *q_data, struct rte_bbdev_op **ops, + uint16_t nb_ops) +{ + void *queue = q_data->queue_private; + struct turbo_sw_queue *q = queue; + uint16_t nb_enqueued = 0; + + switch (q->type) { + case RTE_BBDEV_OP_TURBO_ENC: + nb_enqueued = enqueue_enc_ops(q, ops, nb_ops); + break; + case RTE_BBDEV_OP_TURBO_DEC: + nb_enqueued = enqueue_dec_ops(q, ops, nb_ops); + break; + default: + rte_bbdev_log(ERR, "Operation type is incorrect"); + break; + } + + q_data->queue_stats.enqueue_err_count += nb_ops - nb_enqueued; + q_data->queue_stats.enqueued_count += nb_enqueued; + + return nb_enqueued; +} + +/* Dequeue burst */ +static uint16_t +dequeue_ops(struct rte_bbdev_queue_data *q_data, struct rte_bbdev_op **ops, + uint16_t nb_ops) +{ + struct turbo_sw_queue *q = q_data->queue_private; + uint16_t nb_dequeued = rte_ring_dequeue_burst(q->processed_pkts, + (void **)ops, nb_ops, NULL); + q_data->queue_stats.dequeued_count += nb_dequeued; + + return nb_dequeued; +} + +/* Parse 16bit integer from string argument */ +static inline int +parse_u16_arg(const char *key, const char *value, void *extra_args) +{ + uint16_t *u16 = extra_args; + unsigned int long result; + + if ((value == NULL) || (extra_args == NULL)) + return -EINVAL; + errno = 0; + result = strtoul(value, NULL, 0); + if ((result >= (1 << 16)) || (errno != 0)) { + rte_bbdev_log(ERR, "Invalid value %lu for %s", result, key); + return -ERANGE; + } + *u16 = (uint16_t)result; + return 0; +} + +/* Parse parameters used to create device */ +static int +parse_turbo_sw_params(struct turbo_sw_params *params, const char *input_args) +{ + struct rte_kvargs *kvlist = NULL; + int ret = 0; + + if (params == NULL) + return -EINVAL; + if (input_args) { + kvlist = rte_kvargs_parse(input_args, turbo_sw_valid_params); + if (kvlist == NULL) + return -EFAULT; + + ret = rte_kvargs_process(kvlist, turbo_sw_valid_params[0], + &parse_u16_arg, ¶ms->queues_num); + if (ret < 0) + goto exit; + + ret = rte_kvargs_process(kvlist, turbo_sw_valid_params[1], + &parse_u16_arg, ¶ms->socket_id); + if (ret < 0) + goto exit; + + if (params->socket_id >= RTE_MAX_NUMA_NODES) { + rte_bbdev_log(ERR, "Invalid socket, must be < %u", + RTE_MAX_NUMA_NODES); + goto exit; + } + } + +exit: + if (kvlist) + rte_kvargs_free(kvlist); + return ret; +} + +/* Create device */ +static int +turbo_sw_bbdev_create(struct rte_vdev_device *vdev, + struct turbo_sw_params *init_params) +{ + struct rte_bbdev *bbdev; + size_t dev_private_size = sizeof(struct bbdev_private); + struct bbdev_private *internals; + + vdev->device.numa_node = init_params->socket_id; + + bbdev = rte_bbdev_vdev_allocate(vdev, dev_private_size); + if (bbdev == NULL) { + rte_bbdev_log(ERR, "Failed to create %s", + rte_vdev_device_name(vdev)); + return -EFAULT; + } + + bbdev->dev_ops = &pmd_ops; + + /* register rx/tx burst functions for data path */ + bbdev->dequeue_ops = dequeue_ops; + bbdev->enqueue_ops = enqueue_ops; + internals = bbdev->data->dev_private; + internals->max_nb_queues = init_params->queues_num; + + return 0; +} + +/* Initialise device */ +static int +turbo_sw_bbdev_probe(struct rte_vdev_device *vdev) +{ + struct turbo_sw_params init_params = { + rte_socket_id(), + RTE_BBDEV_DEFAULT_MAX_NB_QUEUES + }; + const char *name; + const char *input_args; + + if (!vdev) + return -EINVAL; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + input_args = rte_vdev_device_args(vdev); + parse_turbo_sw_params(&init_params, input_args); + + rte_bbdev_log_debug( + "Initialising %s on NUMA node %d with max queues: %d\n", + name, init_params.socket_id, init_params.queues_num); + + return turbo_sw_bbdev_create(vdev, &init_params); +} + +/* Uninitialise device */ +static int +turbo_sw_bbdev_remove(struct rte_vdev_device *vdev) +{ + struct rte_bbdev *bbdev; + const char *name; + + if (!vdev) + return -EINVAL; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + + bbdev = rte_bbdev_get_named_dev(name); + if (bbdev == NULL) + return -EINVAL; + + rte_free(bbdev->data->dev_private); + + return rte_bbdev_release(bbdev); +} + +static struct rte_vdev_driver bbdev_turbo_sw_pmd_drv = { + .probe = turbo_sw_bbdev_probe, + .remove = turbo_sw_bbdev_remove +}; + +RTE_PMD_REGISTER_VDEV(DRIVER_NAME, bbdev_turbo_sw_pmd_drv); +RTE_PMD_REGISTER_ALIAS(DRIVER_NAME, bbdev_turbo_sw_pmd); +RTE_PMD_REGISTER_PARAM_STRING(DRIVER_NAME, + TURBO_SW_MAX_NB_QUEUES_ARG"= " + TURBO_SW_SOCKET_ID_ARG"="); + +int bbdev_logtype; +RTE_INIT(null_bbdev_init_log); +static void +null_bbdev_init_log(void) +{ + bbdev_logtype = rte_log_register("pmd.turbo_sw"); + if (bbdev_logtype >= 0) + rte_log_set_level(bbdev_logtype, RTE_LOG_NOTICE); +} diff --git a/drivers/bbdev/turbo_sw/bbdev_turbo_software_tables.h b/drivers/bbdev/turbo_sw/bbdev_turbo_software_tables.h new file mode 100644 index 0000000..3262ca2 --- /dev/null +++ b/drivers/bbdev/turbo_sw/bbdev_turbo_software_tables.h @@ -0,0 +1,1344 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT + * OWNER 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. + */ + +#ifndef TURBO_SW_TABLES_H +#define TURBO_SW_TABLES_H + +#include + +#include +#include "bbdev_turbo_software_tables.h" + +/* Number of NULL bytes for each K index */ +const int32_t kidx_null_num[188] __rte_cache_aligned = { + 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, + 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, + 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, 12, 84, 60, 36, + 12, 84, 60, 36, 12, 84, 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, + 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, 36, 84, + 36, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84 +}; + +/* Indexes of NULL bytes incremented by 1 for each K index */ +const int32_t k0_null_num[188][84] __rte_cache_aligned = { + { 1, 3, 5, 9, 13, 17, 19, 21, 25, 29, 33, 35, 37, 41, 45, 49, 51, 53, + 57, 61, 65, 66, 69, 70, 73, 74, 81, 82, 89, 90, 97, 98, 101, 102, 105, + 106, 113, 114, 121, 122, 129, 130, 133, 134, 137, 138, 145, 146, 153, + 154, 161, 162, 165, 169, 170, 177, 178, 185, 186, 192, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 5, 9, 17, 21, 25, 33, 37, 41, 49, 53, 57, 65, 66, 73, 74, 81, 82, + 97, 98, 105, 106, 113, 114, 129, 130, 137, 138, 145, 146, 161, 162, + 169, 177, 178, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 17, 33, 49, 65, 66, 97, 98, 129, 130, 161, 192, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 4, 7, 10, 13, 16, 19, 25, 28, 31, 34, 37, 40, 43, 49, 52, 55, 58, + 61, 64, 67, 73, 76, 79, 82, 85, 88, 91, 97, 98, 103, 104, 109, 110, + 115, 116, 121, 122, 127, 128, 133, 134, 145, 146, 151, 152, 157, 158, + 163, 164, 169, 170, 175, 176, 181, 182, 193, 194, 199, 200, 205, 206, + 211, 212, 217, 218, 223, 224, 229, 230, 241, 242, 247, 248, 253, 254, + 259, 265, 266, 271, 272, 277, 278, 288 }, + { 1, 4, 7, 13, 19, 25, 28, 31, 37, 43, 49, 52, 55, 61, 67, 73, 76, 79, + 85, 91, 97, 98, 103, 104, 109, 110, 121, 122, 133, 134, 145, 146, 151, + 152, 157, 158, 169, 170, 181, 182, 193, 194, 199, 200, 205, 206, 217, + 218, 229, 230, 241, 242, 247, 253, 254, 265, 266, 277, 278, 288, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 7, 13, 25, 31, 37, 49, 55, 61, 73, 79, 85, 97, 98, 109, 110, 121, + 122, 145, 146, 157, 158, 169, 170, 193, 194, 205, 206, 217, 218, 241, + 242, 253, 265, 266, 288, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 25, 49, 73, 97, 98, 145, 146, 193, 194, 241, 288, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 5, 9, 13, 17, 21, 25, 33, 37, 41, 45, 49, 53, 57, 65, 69, 73, 77, + 81, 85, 89, 97, 101, 105, 109, 113, 117, 121, 129, 130, 137, 138, 145, + 146, 153, 154, 161, 162, 169, 170, 177, 178, 193, 194, 201, 202, 209, + 210, 217, 218, 225, 226, 233, 234, 241, 242, 257, 258, 265, 266, 273, + 274, 281, 282, 289, 290, 297, 298, 305, 306, 321, 322, 329, 330, 337, + 338, 345, 353, 354, 361, 362, 369, 370, 384 }, + { 1, 5, 9, 17, 25, 33, 37, 41, 49, 57, 65, 69, 73, 81, 89, 97, 101, 105, + 113, 121, 129, 130, 137, 138, 145, 146, 161, 162, 177, 178, 193, 194, + 201, 202, 209, 210, 225, 226, 241, 242, 257, 258, 265, 266, 273, 274, + 289, 290, 305, 306, 321, 322, 329, 337, 338, 353, 354, 369, 370, 384, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + { 1, 9, 17, 33, 41, 49, 65, 73, 81, 97, 105, 113, 129, 130, 145, 146, + 161, 162, 193, 194, 209, 210, 225, 226, 257, 258, 273, 274, 289, 290, + 321, 322, 337, 353, 354, 384, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 33, 65, 97, 129, 130, 193, 194, 257, 258, 321, 384, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 6, 11, 16, 21, 26, 31, 41, 46, 51, 56, 61, 66, 71, 81, 86, 91, 96, + 101, 106, 111, 121, 126, 131, 136, 141, 146, 151, 161, 162, 171, 172, + 181, 182, 191, 192, 201, 202, 211, 212, 221, 222, 241, 242, 251, 252, + 261, 262, 271, 272, 281, 282, 291, 292, 301, 302, 321, 322, 331, 332, + 341, 342, 351, 352, 361, 362, 371, 372, 381, 382, 401, 402, 411, 412, + 421, 422, 431, 441, 442, 451, 452, 461, 462, 480 }, + { 1, 6, 11, 21, 31, 41, 46, 51, 61, 71, 81, 86, 91, 101, 111, 121, 126, + 131, 141, 151, 161, 162, 171, 172, 181, 182, 201, 202, 221, 222, 241, + 242, 251, 252, 261, 262, 281, 282, 301, 302, 321, 322, 331, 332, 341, + 342, 361, 362, 381, 382, 401, 402, 411, 421, 422, 441, 442, 461, 462, + 480, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0 }, + { 1, 11, 21, 41, 51, 61, 81, 91, 101, 121, 131, 141, 161, 162, 181, 182, + 201, 202, 241, 242, 261, 262, 281, 282, 321, 322, 341, 342, 361, 362, + 401, 402, 421, 441, 442, 480, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 41, 81, 121, 161, 162, 241, 242, 321, 322, 401, 480, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 7, 13, 19, 25, 31, 37, 49, 55, 61, 67, 73, 79, 85, 97, 103, 109, + 115, 121, 127, 133, 145, 151, 157, 163, 169, 175, 181, 193, 194, 205, + 206, 217, 218, 229, 230, 241, 242, 253, 254, 265, 266, 289, 290, 301, + 302, 313, 314, 325, 326, 337, 338, 349, 350, 361, 362, 385, 386, 397, + 398, 409, 410, 421, 422, 433, 434, 445, 446, 457, 458, 481, 482, 493, + 494, 505, 506, 517, 529, 530, 541, 542, 553, 554, 576 }, + { 1, 7, 13, 25, 37, 49, 55, 61, 73, 85, 97, 103, 109, 121, 133, 145, + 151, 157, 169, 181, 193, 194, 205, 206, 217, 218, 241, 242, 265, 266, + 289, 290, 301, 302, 313, 314, 337, 338, 361, 362, 385, 386, 397, 398, + 409, 410, 433, 434, 457, 458, 481, 482, 493, 505, 506, 529, 530, 553, + 554, 576, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 }, + { 1, 13, 25, 49, 61, 73, 97, 109, 121, 145, 157, 169, 193, 194, 217, + 218, 241, 242, 289, 290, 313, 314, 337, 338, 385, 386, 409, 410, 433, + 434, 481, 482, 505, 529, 530, 576, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 49, 97, 145, 193, 194, 289, 290, 385, 386, 481, 576, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 8, 15, 22, 29, 36, 43, 57, 64, 71, 78, 85, 92, 99, 113, 120, 127, + 134, 141, 148, 155, 169, 176, 183, 190, 197, 204, 211, 225, 226, 239, + 240, 253, 254, 267, 268, 281, 282, 295, 296, 309, 310, 337, 338, 351, + 352, 365, 366, 379, 380, 393, 394, 407, 408, 421, 422, 449, 450, 463, + 464, 477, 478, 491, 492, 505, 506, 519, 520, 533, 534, 561, 562, 575, + 576, 589, 590, 603, 617, 618, 631, 632, 645, 646, 672 }, + { 1, 8, 15, 29, 43, 57, 64, 71, 85, 99, 113, 120, 127, 141, 155, 169, + 176, 183, 197, 211, 225, 226, 239, 240, 253, 254, 281, 282, 309, 310, + 337, 338, 351, 352, 365, 366, 393, 394, 421, 422, 449, 450, 463, 464, + 477, 478, 505, 506, 533, 534, 561, 562, 575, 589, 590, 617, 618, 645, + 646, 672, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 }, + { 1, 15, 29, 57, 71, 85, 113, 127, 141, 169, 183, 197, 225, 226, 253, + 254, 281, 282, 337, 338, 365, 366, 393, 394, 449, 450, 477, 478, 505, + 506, 561, 562, 589, 617, 618, 672, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 57, 113, 169, 225, 226, 337, 338, 449, 450, 561, 672, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 9, 17, 25, 33, 41, 49, 65, 73, 81, 89, 97, 105, 113, 129, 137, 145, + 153, 161, 169, 177, 193, 201, 209, 217, 225, 233, 241, 257, 258, 273, + 274, 289, 290, 305, 306, 321, 322, 337, 338, 353, 354, 385, 386, 401, + 402, 417, 418, 433, 434, 449, 450, 465, 466, 481, 482, 513, 514, 529, + 530, 545, 546, 561, 562, 577, 578, 593, 594, 609, 610, 641, 642, 657, + 658, 673, 674, 689, 705, 706, 721, 722, 737, 738, 768 }, + { 1, 9, 17, 33, 49, 65, 73, 81, 97, 113, 129, 137, 145, 161, 177, 193, + 201, 209, 225, 241, 257, 258, 273, 274, 289, 290, 321, 322, 353, 354, + 385, 386, 401, 402, 417, 418, 449, 450, 481, 482, 513, 514, 529, 530, + 545, 546, 577, 578, 609, 610, 641, 642, 657, 673, 674, 705, 706, 737, + 738, 768, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 }, + { 1, 17, 33, 65, 81, 97, 129, 145, 161, 193, 209, 225, 257, 258, 289, + 290, 321, 322, 385, 386, 417, 418, 449, 450, 513, 514, 545, 546, 577, + 578, 641, 642, 673, 705, 706, 768, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 65, 129, 193, 257, 258, 385, 386, 513, 514, 641, 768, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 10, 19, 28, 37, 46, 55, 73, 82, 91, 100, 109, 118, 127, 145, 154, + 163, 172, 181, 190, 199, 217, 226, 235, 244, 253, 262, 271, 289, 290, + 307, 308, 325, 326, 343, 344, 361, 362, 379, 380, 397, 398, 433, 434, + 451, 452, 469, 470, 487, 488, 505, 506, 523, 524, 541, 542, 577, 578, + 595, 596, 613, 614, 631, 632, 649, 650, 667, 668, 685, 686, 721, 722, + 739, 740, 757, 758, 775, 793, 794, 811, 812, 829, 830, 864 }, + { 1, 10, 19, 37, 55, 73, 82, 91, 109, 127, 145, 154, 163, 181, 199, 217, + 226, 235, 253, 271, 289, 290, 307, 308, 325, 326, 361, 362, 397, 398, + 433, 434, 451, 452, 469, 470, 505, 506, 541, 542, 577, 578, 595, 596, + 613, 614, 649, 650, 685, 686, 721, 722, 739, 757, 758, 793, 794, 829, + 830, 864, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 }, + { 1, 19, 37, 73, 91, 109, 145, 163, 181, 217, 235, 253, 289, 290, 325, + 326, 361, 362, 433, 434, 469, 470, 505, 506, 577, 578, 613, 614, 649, + 650, 721, 722, 757, 793, 794, 864, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 73, 145, 217, 289, 290, 433, 434, 577, 578, 721, 864, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 11, 21, 31, 41, 51, 61, 81, 91, 101, 111, 121, 131, 141, 161, 171, + 181, 191, 201, 211, 221, 241, 251, 261, 271, 281, 291, 301, 321, 322, + 341, 342, 361, 362, 381, 382, 401, 402, 421, 422, 441, 442, 481, 482, + 501, 502, 521, 522, 541, 542, 561, 562, 581, 582, 601, 602, 641, 642, + 661, 662, 681, 682, 701, 702, 721, 722, 741, 742, 761, 762, 801, 802, + 821, 822, 841, 842, 861, 881, 882, 901, 902, 921, 922, 960 }, + { 1, 11, 21, 41, 61, 81, 91, 101, 121, 141, 161, 171, 181, 201, 221, + 241, 251, 261, 281, 301, 321, 322, 341, 342, 361, 362, 401, 402, 441, + 442, 481, 482, 501, 502, 521, 522, 561, 562, 601, 602, 641, 642, 661, + 662, 681, 682, 721, 722, 761, 762, 801, 802, 821, 841, 842, 881, 882, + 921, 922, 960, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 }, + { 1, 21, 41, 81, 101, 121, 161, 181, 201, 241, 261, 281, 321, 322, 361, + 362, 401, 402, 481, 482, 521, 522, 561, 562, 641, 642, 681, 682, 721, + 722, 801, 802, 841, 881, 882, 960, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 81, 161, 241, 321, 322, 481, 482, 641, 642, 801, 960, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 12, 23, 34, 45, 56, 67, 89, 100, 111, 122, 133, 144, 155, 177, 188, + 199, 210, 221, 232, 243, 265, 276, 287, 298, 309, 320, 331, 353, 354, + 375, 376, 397, 398, 419, 420, 441, 442, 463, 464, 485, 486, 529, 530, + 551, 552, 573, 574, 595, 596, 617, 618, 639, 640, 661, 662, 705, 706, + 727, 728, 749, 750, 771, 772, 793, 794, 815, 816, 837, 838, 881, 882, + 903, 904, 925, 926, 947, 969, 970, 991, 992, 1013, 1014, 1056 }, + { 1, 12, 23, 45, 67, 89, 100, 111, 133, 155, 177, 188, 199, 221, 243, + 265, 276, 287, 309, 331, 353, 354, 375, 376, 397, 398, 441, 442, 485, + 486, 529, 530, 551, 552, 573, 574, 617, 618, 661, 662, 705, 706, 727, + 728, 749, 750, 793, 794, 837, 838, 881, 882, 903, 925, 926, 969, 970, + 1013, 1014, 1056, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0 }, + { 1, 23, 45, 89, 111, 133, 177, 199, 221, 265, 287, 309, 353, 354, 397, + 398, 441, 442, 529, 530, 573, 574, 617, 618, 705, 706, 749, 750, 793, + 794, 881, 882, 925, 969, 970, 1056, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 89, 177, 265, 353, 354, 529, 530, 705, 706, 881, 1056, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 13, 25, 37, 49, 61, 73, 97, 109, 121, 133, 145, 157, 169, 193, 205, + 217, 229, 241, 253, 265, 289, 301, 313, 325, 337, 349, 361, 385, 386, + 409, 410, 433, 434, 457, 458, 481, 482, 505, 506, 529, 530, 577, 578, + 601, 602, 625, 626, 649, 650, 673, 674, 697, 698, 721, 722, 769, 770, + 793, 794, 817, 818, 841, 842, 865, 866, 889, 890, 913, 914, 961, 962, + 985, 986, 1009, 1010, 1033, 1057, 1058, 1081, 1082, 1105, 1106, + 1152 }, + { 1, 13, 25, 49, 73, 97, 109, 121, 145, 169, 193, 205, 217, 241, 265, + 289, 301, 313, 337, 361, 385, 386, 409, 410, 433, 434, 481, 482, 529, + 530, 577, 578, 601, 602, 625, 626, 673, 674, 721, 722, 769, 770, 793, + 794, 817, 818, 865, 866, 913, 914, 961, 962, 985, 1009, 1010, 1057, + 1058, 1105, 1106, 1152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 25, 49, 97, 121, 145, 193, 217, 241, 289, 313, 337, 385, 386, 433, + 434, 481, 482, 577, 578, 625, 626, 673, 674, 769, 770, 817, 818, 865, + 866, 961, 962, 1009, 1057, 1058, 1152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 97, 193, 289, 385, 386, 577, 578, 769, 770, 961, 1152, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 14, 27, 40, 53, 66, 79, 105, 118, 131, 144, 157, 170, 183, 209, + 222, 235, 248, 261, 274, 287, 313, 326, 339, 352, 365, 378, 391, 417, + 418, 443, 444, 469, 470, 495, 496, 521, 522, 547, 548, 573, 574, 625, + 626, 651, 652, 677, 678, 703, 704, 729, 730, 755, 756, 781, 782, 833, + 834, 859, 860, 885, 886, 911, 912, 937, 938, 963, 964, 989, 990, 1041, + 1042, 1067, 1068, 1093, 1094, 1119, 1145, 1146, 1171, 1172, 1197, + 1198, 1248 }, + { 1, 14, 27, 53, 79, 105, 118, 131, 157, 183, 209, 222, 235, 261, 287, + 313, 326, 339, 365, 391, 417, 418, 443, 444, 469, 470, 521, 522, 573, + 574, 625, 626, 651, 652, 677, 678, 729, 730, 781, 782, 833, 834, 859, + 860, 885, 886, 937, 938, 989, 990, 1041, 1042, 1067, 1093, 1094, 1145, + 1146, 1197, 1198, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 27, 53, 105, 131, 157, 209, 235, 261, 313, 339, 365, 417, 418, 469, + 470, 521, 522, 625, 626, 677, 678, 729, 730, 833, 834, 885, 886, 937, + 938, 1041, 1042, 1093, 1145, 1146, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 105, 209, 313, 417, 418, 625, 626, 833, 834, 1041, 1248, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 15, 29, 43, 57, 71, 85, 113, 127, 141, 155, 169, 183, 197, 225, + 239, 253, 267, 281, 295, 309, 337, 351, 365, 379, 393, 407, 421, 449, + 450, 477, 478, 505, 506, 533, 534, 561, 562, 589, 590, 617, 618, 673, + 674, 701, 702, 729, 730, 757, 758, 785, 786, 813, 814, 841, 842, 897, + 898, 925, 926, 953, 954, 981, 982, 1009, 1010, 1037, 1038, 1065, 1066, + 1121, 1122, 1149, 1150, 1177, 1178, 1205, 1233, 1234, 1261, 1262, + 1289, 1290, 1344 }, + { 1, 15, 29, 57, 85, 113, 127, 141, 169, 197, 225, 239, 253, 281, 309, + 337, 351, 365, 393, 421, 449, 450, 477, 478, 505, 506, 561, 562, 617, + 618, 673, 674, 701, 702, 729, 730, 785, 786, 841, 842, 897, 898, 925, + 926, 953, 954, 1009, 1010, 1065, 1066, 1121, 1122, 1149, 1177, 1178, + 1233, 1234, 1289, 1290, 1344, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 29, 57, 113, 141, 169, 225, 253, 281, 337, 365, 393, 449, 450, 505, + 506, 561, 562, 673, 674, 729, 730, 785, 786, 897, 898, 953, 954, 1009, + 1010, 1121, 1122, 1177, 1233, 1234, 1344, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 113, 225, 337, 449, 450, 673, 674, 897, 898, 1121, 1344, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 16, 31, 46, 61, 76, 91, 121, 136, 151, 166, 181, 196, 211, 241, + 256, 271, 286, 301, 316, 331, 361, 376, 391, 406, 421, 436, 451, 481, + 482, 511, 512, 541, 542, 571, 572, 601, 602, 631, 632, 661, 662, 721, + 722, 751, 752, 781, 782, 811, 812, 841, 842, 871, 872, 901, 902, 961, + 962, 991, 992, 1021, 1022, 1051, 1052, 1081, 1082, 1111, 1112, 1141, + 1142, 1201, 1202, 1231, 1232, 1261, 1262, 1291, 1321, 1322, 1351, + 1352, 1381, 1382, 1440 }, + { 1, 16, 31, 61, 91, 121, 136, 151, 181, 211, 241, 256, 271, 301, 331, + 361, 376, 391, 421, 451, 481, 482, 511, 512, 541, 542, 601, 602, 661, + 662, 721, 722, 751, 752, 781, 782, 841, 842, 901, 902, 961, 962, 991, + 992, 1021, 1022, 1081, 1082, 1141, 1142, 1201, 1202, 1231, 1261, 1262, + 1321, 1322, 1381, 1382, 1440, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 31, 61, 121, 151, 181, 241, 271, 301, 361, 391, 421, 481, 482, 541, + 542, 601, 602, 721, 722, 781, 782, 841, 842, 961, 962, 1021, 1022, + 1081, 1082, 1201, 1202, 1261, 1321, 1322, 1440, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 121, 241, 361, 481, 482, 721, 722, 961, 962, 1201, 1440, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 17, 33, 49, 65, 81, 97, 129, 145, 161, 177, 193, 209, 225, 257, + 273, 289, 305, 321, 337, 353, 385, 401, 417, 433, 449, 465, 481, 513, + 514, 545, 546, 577, 578, 609, 610, 641, 642, 673, 674, 705, 706, 769, + 770, 801, 802, 833, 834, 865, 866, 897, 898, 929, 930, 961, 962, 1025, + 1026, 1057, 1058, 1089, 1090, 1121, 1122, 1153, 1154, 1185, 1186, + 1217, 1218, 1281, 1282, 1313, 1314, 1345, 1346, 1377, 1409, 1410, + 1441, 1442, 1473, 1474, 1536 }, + { 1, 17, 33, 65, 97, 129, 145, 161, 193, 225, 257, 273, 289, 321, 353, + 385, 401, 417, 449, 481, 513, 514, 545, 546, 577, 578, 641, 642, 705, + 706, 769, 770, 801, 802, 833, 834, 897, 898, 961, 962, 1025, 1026, + 1057, 1058, 1089, 1090, 1153, 1154, 1217, 1218, 1281, 1282, 1313, + 1345, 1346, 1409, 1410, 1473, 1474, 1536, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 33, 65, 129, 161, 193, 257, 289, 321, 385, 417, 449, 513, 514, 577, + 578, 641, 642, 769, 770, 833, 834, 897, 898, 1025, 1026, 1089, 1090, + 1153, 1154, 1281, 1282, 1345, 1409, 1410, 1536, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 129, 257, 385, 513, 514, 769, 770, 1025, 1026, 1281, 1536, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 18, 35, 52, 69, 86, 103, 137, 154, 171, 188, 205, 222, 239, 273, + 290, 307, 324, 341, 358, 375, 409, 426, 443, 460, 477, 494, 511, 545, + 546, 579, 580, 613, 614, 647, 648, 681, 682, 715, 716, 749, 750, 817, + 818, 851, 852, 885, 886, 919, 920, 953, 954, 987, 988, 1021, 1022, + 1089, 1090, 1123, 1124, 1157, 1158, 1191, 1192, 1225, 1226, 1259, + 1260, 1293, 1294, 1361, 1362, 1395, 1396, 1429, 1430, 1463, 1497, + 1498, 1531, 1532, 1565, 1566, 1632 }, + { 1, 35, 69, 137, 171, 205, 273, 307, 341, 409, 443, 477, 545, 546, 613, + 614, 681, 682, 817, 818, 885, 886, 953, 954, 1089, 1090, 1157, 1158, + 1225, 1226, 1361, 1362, 1429, 1497, 1498, 1632, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 19, 37, 55, 73, 91, 109, 145, 163, 181, 199, 217, 235, 253, 289, + 307, 325, 343, 361, 379, 397, 433, 451, 469, 487, 505, 523, 541, 577, + 578, 613, 614, 649, 650, 685, 686, 721, 722, 757, 758, 793, 794, 865, + 866, 901, 902, 937, 938, 973, 974, 1009, 1010, 1045, 1046, 1081, 1082, + 1153, 1154, 1189, 1190, 1225, 1226, 1261, 1262, 1297, 1298, 1333, + 1334, 1369, 1370, 1441, 1442, 1477, 1478, 1513, 1514, 1549, 1585, + 1586, 1621, 1622, 1657, 1658, 1728 }, + { 1, 37, 73, 145, 181, 217, 289, 325, 361, 433, 469, 505, 577, 578, 649, + 650, 721, 722, 865, 866, 937, 938, 1009, 1010, 1153, 1154, 1225, 1226, + 1297, 1298, 1441, 1442, 1513, 1585, 1586, 1728, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 20, 39, 58, 77, 96, 115, 153, 172, 191, 210, 229, 248, 267, 305, + 324, 343, 362, 381, 400, 419, 457, 476, 495, 514, 533, 552, 571, 609, + 610, 647, 648, 685, 686, 723, 724, 761, 762, 799, 800, 837, 838, 913, + 914, 951, 952, 989, 990, 1027, 1028, 1065, 1066, 1103, 1104, 1141, + 1142, 1217, 1218, 1255, 1256, 1293, 1294, 1331, 1332, 1369, 1370, + 1407, 1408, 1445, 1446, 1521, 1522, 1559, 1560, 1597, 1598, 1635, + 1673, 1674, 1711, 1712, 1749, 1750, 1824 }, + { 1, 39, 77, 153, 191, 229, 305, 343, 381, 457, 495, 533, 609, 610, 685, + 686, 761, 762, 913, 914, 989, 990, 1065, 1066, 1217, 1218, 1293, 1294, + 1369, 1370, 1521, 1522, 1597, 1673, 1674, 1824, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 21, 41, 61, 81, 101, 121, 161, 181, 201, 221, 241, 261, 281, 321, + 341, 361, 381, 401, 421, 441, 481, 501, 521, 541, 561, 581, 601, 641, + 642, 681, 682, 721, 722, 761, 762, 801, 802, 841, 842, 881, 882, 961, + 962, 1001, 1002, 1041, 1042, 1081, 1082, 1121, 1122, 1161, 1162, 1201, + 1202, 1281, 1282, 1321, 1322, 1361, 1362, 1401, 1402, 1441, 1442, + 1481, 1482, 1521, 1522, 1601, 1602, 1641, 1642, 1681, 1682, 1721, + 1761, 1762, 1801, 1802, 1841, 1842, 1920 }, + { 1, 41, 81, 161, 201, 241, 321, 361, 401, 481, 521, 561, 641, 642, 721, + 722, 801, 802, 961, 962, 1041, 1042, 1121, 1122, 1281, 1282, 1361, + 1362, 1441, 1442, 1601, 1602, 1681, 1761, 1762, 1920, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 22, 43, 64, 85, 106, 127, 169, 190, 211, 232, 253, 274, 295, 337, + 358, 379, 400, 421, 442, 463, 505, 526, 547, 568, 589, 610, 631, 673, + 674, 715, 716, 757, 758, 799, 800, 841, 842, 883, 884, 925, 926, 1009, + 1010, 1051, 1052, 1093, 1094, 1135, 1136, 1177, 1178, 1219, 1220, + 1261, 1262, 1345, 1346, 1387, 1388, 1429, 1430, 1471, 1472, 1513, + 1514, 1555, 1556, 1597, 1598, 1681, 1682, 1723, 1724, 1765, 1766, + 1807, 1849, 1850, 1891, 1892, 1933, 1934, 2016 }, + { 1, 43, 85, 169, 211, 253, 337, 379, 421, 505, 547, 589, 673, 674, 757, + 758, 841, 842, 1009, 1010, 1093, 1094, 1177, 1178, 1345, 1346, 1429, + 1430, 1513, 1514, 1681, 1682, 1765, 1849, 1850, 2016, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 23, 45, 67, 89, 111, 133, 177, 199, 221, 243, 265, 287, 309, 353, + 375, 397, 419, 441, 463, 485, 529, 551, 573, 595, 617, 639, 661, 705, + 706, 749, 750, 793, 794, 837, 838, 881, 882, 925, 926, 969, 970, 1057, + 1058, 1101, 1102, 1145, 1146, 1189, 1190, 1233, 1234, 1277, 1278, + 1321, 1322, 1409, 1410, 1453, 1454, 1497, 1498, 1541, 1542, 1585, + 1586, 1629, 1630, 1673, 1674, 1761, 1762, 1805, 1806, 1849, 1850, + 1893, 1937, 1938, 1981, 1982, 2025, 2026, 2112 }, + { 1, 45, 89, 177, 221, 265, 353, 397, 441, 529, 573, 617, 705, 706, 793, + 794, 881, 882, 1057, 1058, 1145, 1146, 1233, 1234, 1409, 1410, 1497, + 1498, 1585, 1586, 1761, 1762, 1849, 1937, 1938, 2112, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 24, 47, 70, 93, 116, 139, 185, 208, 231, 254, 277, 300, 323, 369, + 392, 415, 438, 461, 484, 507, 553, 576, 599, 622, 645, 668, 691, 737, + 738, 783, 784, 829, 830, 875, 876, 921, 922, 967, 968, 1013, 1014, + 1105, 1106, 1151, 1152, 1197, 1198, 1243, 1244, 1289, 1290, 1335, + 1336, 1381, 1382, 1473, 1474, 1519, 1520, 1565, 1566, 1611, 1612, + 1657, 1658, 1703, 1704, 1749, 1750, 1841, 1842, 1887, 1888, 1933, + 1934, 1979, 2025, 2026, 2071, 2072, 2117, 2118, 2208 }, + { 1, 47, 93, 185, 231, 277, 369, 415, 461, 553, 599, 645, 737, 738, 829, + 830, 921, 922, 1105, 1106, 1197, 1198, 1289, 1290, 1473, 1474, 1565, + 1566, 1657, 1658, 1841, 1842, 1933, 2025, 2026, 2208, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 25, 49, 73, 97, 121, 145, 193, 217, 241, 265, 289, 313, 337, 385, + 409, 433, 457, 481, 505, 529, 577, 601, 625, 649, 673, 697, 721, 769, + 770, 817, 818, 865, 866, 913, 914, 961, 962, 1009, 1010, 1057, 1058, + 1153, 1154, 1201, 1202, 1249, 1250, 1297, 1298, 1345, 1346, 1393, + 1394, 1441, 1442, 1537, 1538, 1585, 1586, 1633, 1634, 1681, 1682, + 1729, 1730, 1777, 1778, 1825, 1826, 1921, 1922, 1969, 1970, 2017, + 2018, 2065, 2113, 2114, 2161, 2162, 2209, 2210, 2304 }, + { 1, 49, 97, 193, 241, 289, 385, 433, 481, 577, 625, 673, 769, 770, 865, + 866, 961, 962, 1153, 1154, 1249, 1250, 1345, 1346, 1537, 1538, 1633, + 1634, 1729, 1730, 1921, 1922, 2017, 2113, 2114, 2304, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 26, 51, 76, 101, 126, 151, 201, 226, 251, 276, 301, 326, 351, 401, + 426, 451, 476, 501, 526, 551, 601, 626, 651, 676, 701, 726, 751, 801, + 802, 851, 852, 901, 902, 951, 952, 1001, 1002, 1051, 1052, 1101, 1102, + 1201, 1202, 1251, 1252, 1301, 1302, 1351, 1352, 1401, 1402, 1451, + 1452, 1501, 1502, 1601, 1602, 1651, 1652, 1701, 1702, 1751, 1752, + 1801, 1802, 1851, 1852, 1901, 1902, 2001, 2002, 2051, 2052, 2101, + 2102, 2151, 2201, 2202, 2251, 2252, 2301, 2302, 2400 }, + { 1, 51, 101, 201, 251, 301, 401, 451, 501, 601, 651, 701, 801, 802, + 901, 902, 1001, 1002, 1201, 1202, 1301, 1302, 1401, 1402, 1601, 1602, + 1701, 1702, 1801, 1802, 2001, 2002, 2101, 2201, 2202, 2400, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 27, 53, 79, 105, 131, 157, 209, 235, 261, 287, 313, 339, 365, 417, + 443, 469, 495, 521, 547, 573, 625, 651, 677, 703, 729, 755, 781, 833, + 834, 885, 886, 937, 938, 989, 990, 1041, 1042, 1093, 1094, 1145, 1146, + 1249, 1250, 1301, 1302, 1353, 1354, 1405, 1406, 1457, 1458, 1509, + 1510, 1561, 1562, 1665, 1666, 1717, 1718, 1769, 1770, 1821, 1822, + 1873, 1874, 1925, 1926, 1977, 1978, 2081, 2082, 2133, 2134, 2185, + 2186, 2237, 2289, 2290, 2341, 2342, 2393, 2394, 2496 }, + { 1, 53, 105, 209, 261, 313, 417, 469, 521, 625, 677, 729, 833, 834, + 937, 938, 1041, 1042, 1249, 1250, 1353, 1354, 1457, 1458, 1665, 1666, + 1769, 1770, 1873, 1874, 2081, 2082, 2185, 2289, 2290, 2496, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 28, 55, 82, 109, 136, 163, 217, 244, 271, 298, 325, 352, 379, 433, + 460, 487, 514, 541, 568, 595, 649, 676, 703, 730, 757, 784, 811, 865, + 866, 919, 920, 973, 974, 1027, 1028, 1081, 1082, 1135, 1136, 1189, + 1190, 1297, 1298, 1351, 1352, 1405, 1406, 1459, 1460, 1513, 1514, + 1567, 1568, 1621, 1622, 1729, 1730, 1783, 1784, 1837, 1838, 1891, + 1892, 1945, 1946, 1999, 2000, 2053, 2054, 2161, 2162, 2215, 2216, + 2269, 2270, 2323, 2377, 2378, 2431, 2432, 2485, 2486, 2592 }, + { 1, 55, 109, 217, 271, 325, 433, 487, 541, 649, 703, 757, 865, 866, + 973, 974, 1081, 1082, 1297, 1298, 1405, 1406, 1513, 1514, 1729, 1730, + 1837, 1838, 1945, 1946, 2161, 2162, 2269, 2377, 2378, 2592, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 29, 57, 85, 113, 141, 169, 225, 253, 281, 309, 337, 365, 393, 449, + 477, 505, 533, 561, 589, 617, 673, 701, 729, 757, 785, 813, 841, 897, + 898, 953, 954, 1009, 1010, 1065, 1066, 1121, 1122, 1177, 1178, 1233, + 1234, 1345, 1346, 1401, 1402, 1457, 1458, 1513, 1514, 1569, 1570, + 1625, 1626, 1681, 1682, 1793, 1794, 1849, 1850, 1905, 1906, 1961, + 1962, 2017, 2018, 2073, 2074, 2129, 2130, 2241, 2242, 2297, 2298, + 2353, 2354, 2409, 2465, 2466, 2521, 2522, 2577, 2578, 2688 }, + { 1, 57, 113, 225, 281, 337, 449, 505, 561, 673, 729, 785, 897, 898, + 1009, 1010, 1121, 1122, 1345, 1346, 1457, 1458, 1569, 1570, 1793, + 1794, 1905, 1906, 2017, 2018, 2241, 2242, 2353, 2465, 2466, 2688, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + { 1, 30, 59, 88, 117, 146, 175, 233, 262, 291, 320, 349, 378, 407, 465, + 494, 523, 552, 581, 610, 639, 697, 726, 755, 784, 813, 842, 871, 929, + 930, 987, 988, 1045, 1046, 1103, 1104, 1161, 1162, 1219, 1220, 1277, + 1278, 1393, 1394, 1451, 1452, 1509, 1510, 1567, 1568, 1625, 1626, + 1683, 1684, 1741, 1742, 1857, 1858, 1915, 1916, 1973, 1974, 2031, + 2032, 2089, 2090, 2147, 2148, 2205, 2206, 2321, 2322, 2379, 2380, + 2437, 2438, 2495, 2553, 2554, 2611, 2612, 2669, 2670, 2784 }, + { 1, 59, 117, 233, 291, 349, 465, 523, 581, 697, 755, 813, 929, 930, + 1045, 1046, 1161, 1162, 1393, 1394, 1509, 1510, 1625, 1626, 1857, + 1858, 1973, 1974, 2089, 2090, 2321, 2322, 2437, 2553, 2554, 2784, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + { 1, 31, 61, 91, 121, 151, 181, 241, 271, 301, 331, 361, 391, 421, 481, + 511, 541, 571, 601, 631, 661, 721, 751, 781, 811, 841, 871, 901, 961, + 962, 1021, 1022, 1081, 1082, 1141, 1142, 1201, 1202, 1261, 1262, 1321, + 1322, 1441, 1442, 1501, 1502, 1561, 1562, 1621, 1622, 1681, 1682, + 1741, 1742, 1801, 1802, 1921, 1922, 1981, 1982, 2041, 2042, 2101, + 2102, 2161, 2162, 2221, 2222, 2281, 2282, 2401, 2402, 2461, 2462, + 2521, 2522, 2581, 2641, 2642, 2701, 2702, 2761, 2762, 2880 }, + { 1, 61, 121, 241, 301, 361, 481, 541, 601, 721, 781, 841, 961, 962, + 1081, 1082, 1201, 1202, 1441, 1442, 1561, 1562, 1681, 1682, 1921, + 1922, 2041, 2042, 2161, 2162, 2401, 2402, 2521, 2641, 2642, 2880, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0 }, + { 1, 32, 63, 94, 125, 156, 187, 249, 280, 311, 342, 373, 404, 435, 497, + 528, 559, 590, 621, 652, 683, 745, 776, 807, 838, 869, 900, 931, 993, + 994, 1055, 1056, 1117, 1118, 1179, 1180, 1241, 1242, 1303, 1304, 1365, + 1366, 1489, 1490, 1551, 1552, 1613, 1614, 1675, 1676, 1737, 1738, + 1799, 1800, 1861, 1862, 1985, 1986, 2047, 2048, 2109, 2110, 2171, + 2172, 2233, 2234, 2295, 2296, 2357, 2358, 2481, 2482, 2543, 2544, + 2605, 2606, 2667, 2729, 2730, 2791, 2792, 2853, 2854, 2976 }, + { 1, 63, 125, 249, 311, 373, 497, 559, 621, 745, 807, 869, 993, 994, + 1117, 1118, 1241, 1242, 1489, 1490, 1613, 1614, 1737, 1738, 1985, + 1986, 2109, 2110, 2233, 2234, 2481, 2482, 2605, 2729, 2730, 2976, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + { 1, 33, 65, 97, 129, 161, 193, 257, 289, 321, 353, 385, 417, 449, 513, + 545, 577, 609, 641, 673, 705, 769, 801, 833, 865, 897, 929, 961, 1025, + 1026, 1089, 1090, 1153, 1154, 1217, 1218, 1281, 1282, 1345, 1346, + 1409, 1410, 1537, 1538, 1601, 1602, 1665, 1666, 1729, 1730, 1793, + 1794, 1857, 1858, 1921, 1922, 2049, 2050, 2113, 2114, 2177, 2178, + 2241, 2242, 2305, 2306, 2369, 2370, 2433, 2434, 2561, 2562, 2625, + 2626, 2689, 2690, 2753, 2817, 2818, 2881, 2882, 2945, 2946, 3072 }, + { 1, 65, 129, 257, 321, 385, 513, 577, 641, 769, 833, 897, 1025, 1026, + 1153, 1154, 1281, 1282, 1537, 1538, 1665, 1666, 1793, 1794, 2049, + 2050, 2177, 2178, 2305, 2306, 2561, 2562, 2689, 2817, 2818, 3072, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + { 1, 34, 67, 100, 133, 166, 199, 265, 298, 331, 364, 397, 430, 463, 529, + 562, 595, 628, 661, 694, 727, 793, 826, 859, 892, 925, 958, 991, 1057, + 1058, 1123, 1124, 1189, 1190, 1255, 1256, 1321, 1322, 1387, 1388, + 1453, 1454, 1585, 1586, 1651, 1652, 1717, 1718, 1783, 1784, 1849, + 1850, 1915, 1916, 1981, 1982, 2113, 2114, 2179, 2180, 2245, 2246, + 2311, 2312, 2377, 2378, 2443, 2444, 2509, 2510, 2641, 2642, 2707, + 2708, 2773, 2774, 2839, 2905, 2906, 2971, 2972, 3037, 3038, 3168 }, + { 1, 35, 69, 103, 137, 171, 205, 273, 307, 341, 375, 409, 443, 477, 545, + 579, 613, 647, 681, 715, 749, 817, 851, 885, 919, 953, 987, 1021, + 1089, 1090, 1157, 1158, 1225, 1226, 1293, 1294, 1361, 1362, 1429, + 1430, 1497, 1498, 1633, 1634, 1701, 1702, 1769, 1770, 1837, 1838, + 1905, 1906, 1973, 1974, 2041, 2042, 2177, 2178, 2245, 2246, 2313, + 2314, 2381, 2382, 2449, 2450, 2517, 2518, 2585, 2586, 2721, 2722, + 2789, 2790, 2857, 2858, 2925, 2993, 2994, 3061, 3062, 3129, 3130, + 3264 }, + { 1, 36, 71, 106, 141, 176, 211, 281, 316, 351, 386, 421, 456, 491, 561, + 596, 631, 666, 701, 736, 771, 841, 876, 911, 946, 981, 1016, 1051, + 1121, 1122, 1191, 1192, 1261, 1262, 1331, 1332, 1401, 1402, 1471, + 1472, 1541, 1542, 1681, 1682, 1751, 1752, 1821, 1822, 1891, 1892, + 1961, 1962, 2031, 2032, 2101, 2102, 2241, 2242, 2311, 2312, 2381, + 2382, 2451, 2452, 2521, 2522, 2591, 2592, 2661, 2662, 2801, 2802, + 2871, 2872, 2941, 2942, 3011, 3081, 3082, 3151, 3152, 3221, 3222, + 3360 }, + { 1, 37, 73, 109, 145, 181, 217, 289, 325, 361, 397, 433, 469, 505, 577, + 613, 649, 685, 721, 757, 793, 865, 901, 937, 973, 1009, 1045, 1081, + 1153, 1154, 1225, 1226, 1297, 1298, 1369, 1370, 1441, 1442, 1513, + 1514, 1585, 1586, 1729, 1730, 1801, 1802, 1873, 1874, 1945, 1946, + 2017, 2018, 2089, 2090, 2161, 2162, 2305, 2306, 2377, 2378, 2449, + 2450, 2521, 2522, 2593, 2594, 2665, 2666, 2737, 2738, 2881, 2882, + 2953, 2954, 3025, 3026, 3097, 3169, 3170, 3241, 3242, 3313, 3314, + 3456 }, + { 1, 38, 75, 112, 149, 186, 223, 297, 334, 371, 408, 445, 482, 519, 593, + 630, 667, 704, 741, 778, 815, 889, 926, 963, 1000, 1037, 1074, 1111, + 1185, 1186, 1259, 1260, 1333, 1334, 1407, 1408, 1481, 1482, 1555, + 1556, 1629, 1630, 1777, 1778, 1851, 1852, 1925, 1926, 1999, 2000, + 2073, 2074, 2147, 2148, 2221, 2222, 2369, 2370, 2443, 2444, 2517, + 2518, 2591, 2592, 2665, 2666, 2739, 2740, 2813, 2814, 2961, 2962, + 3035, 3036, 3109, 3110, 3183, 3257, 3258, 3331, 3332, 3405, 3406, + 3552 }, + { 1, 39, 77, 115, 153, 191, 229, 305, 343, 381, 419, 457, 495, 533, 609, + 647, 685, 723, 761, 799, 837, 913, 951, 989, 1027, 1065, 1103, 1141, + 1217, 1218, 1293, 1294, 1369, 1370, 1445, 1446, 1521, 1522, 1597, + 1598, 1673, 1674, 1825, 1826, 1901, 1902, 1977, 1978, 2053, 2054, + 2129, 2130, 2205, 2206, 2281, 2282, 2433, 2434, 2509, 2510, 2585, + 2586, 2661, 2662, 2737, 2738, 2813, 2814, 2889, 2890, 3041, 3042, + 3117, 3118, 3193, 3194, 3269, 3345, 3346, 3421, 3422, 3497, 3498, + 3648 }, + { 1, 40, 79, 118, 157, 196, 235, 313, 352, 391, 430, 469, 508, 547, 625, + 664, 703, 742, 781, 820, 859, 937, 976, 1015, 1054, 1093, 1132, 1171, + 1249, 1250, 1327, 1328, 1405, 1406, 1483, 1484, 1561, 1562, 1639, + 1640, 1717, 1718, 1873, 1874, 1951, 1952, 2029, 2030, 2107, 2108, + 2185, 2186, 2263, 2264, 2341, 2342, 2497, 2498, 2575, 2576, 2653, + 2654, 2731, 2732, 2809, 2810, 2887, 2888, 2965, 2966, 3121, 3122, + 3199, 3200, 3277, 3278, 3355, 3433, 3434, 3511, 3512, 3589, 3590, + 3744 }, + { 1, 41, 81, 121, 161, 201, 241, 321, 361, 401, 441, 481, 521, 561, 641, + 681, 721, 761, 801, 841, 881, 961, 1001, 1041, 1081, 1121, 1161, 1201, + 1281, 1282, 1361, 1362, 1441, 1442, 1521, 1522, 1601, 1602, 1681, + 1682, 1761, 1762, 1921, 1922, 2001, 2002, 2081, 2082, 2161, 2162, + 2241, 2242, 2321, 2322, 2401, 2402, 2561, 2562, 2641, 2642, 2721, + 2722, 2801, 2802, 2881, 2882, 2961, 2962, 3041, 3042, 3201, 3202, + 3281, 3282, 3361, 3362, 3441, 3521, 3522, 3601, 3602, 3681, 3682, + 3840 }, + { 1, 42, 83, 124, 165, 206, 247, 329, 370, 411, 452, 493, 534, 575, 657, + 698, 739, 780, 821, 862, 903, 985, 1026, 1067, 1108, 1149, 1190, 1231, + 1313, 1314, 1395, 1396, 1477, 1478, 1559, 1560, 1641, 1642, 1723, + 1724, 1805, 1806, 1969, 1970, 2051, 2052, 2133, 2134, 2215, 2216, + 2297, 2298, 2379, 2380, 2461, 2462, 2625, 2626, 2707, 2708, 2789, + 2790, 2871, 2872, 2953, 2954, 3035, 3036, 3117, 3118, 3281, 3282, + 3363, 3364, 3445, 3446, 3527, 3609, 3610, 3691, 3692, 3773, 3774, + 3936 }, + { 1, 43, 85, 127, 169, 211, 253, 337, 379, 421, 463, 505, 547, 589, 673, + 715, 757, 799, 841, 883, 925, 1009, 1051, 1093, 1135, 1177, 1219, + 1261, 1345, 1346, 1429, 1430, 1513, 1514, 1597, 1598, 1681, 1682, + 1765, 1766, 1849, 1850, 2017, 2018, 2101, 2102, 2185, 2186, 2269, + 2270, 2353, 2354, 2437, 2438, 2521, 2522, 2689, 2690, 2773, 2774, + 2857, 2858, 2941, 2942, 3025, 3026, 3109, 3110, 3193, 3194, 3361, + 3362, 3445, 3446, 3529, 3530, 3613, 3697, 3698, 3781, 3782, 3865, + 3866, 4032 }, + { 1, 44, 87, 130, 173, 216, 259, 345, 388, 431, 474, 517, 560, 603, 689, + 732, 775, 818, 861, 904, 947, 1033, 1076, 1119, 1162, 1205, 1248, + 1291, 1377, 1378, 1463, 1464, 1549, 1550, 1635, 1636, 1721, 1722, + 1807, 1808, 1893, 1894, 2065, 2066, 2151, 2152, 2237, 2238, 2323, + 2324, 2409, 2410, 2495, 2496, 2581, 2582, 2753, 2754, 2839, 2840, + 2925, 2926, 3011, 3012, 3097, 3098, 3183, 3184, 3269, 3270, 3441, + 3442, 3527, 3528, 3613, 3614, 3699, 3785, 3786, 3871, 3872, 3957, + 3958, 4128 }, + { 1, 45, 89, 133, 177, 221, 265, 353, 397, 441, 485, 529, 573, 617, 705, + 749, 793, 837, 881, 925, 969, 1057, 1101, 1145, 1189, 1233, 1277, + 1321, 1409, 1410, 1497, 1498, 1585, 1586, 1673, 1674, 1761, 1762, + 1849, 1850, 1937, 1938, 2113, 2114, 2201, 2202, 2289, 2290, 2377, + 2378, 2465, 2466, 2553, 2554, 2641, 2642, 2817, 2818, 2905, 2906, + 2993, 2994, 3081, 3082, 3169, 3170, 3257, 3258, 3345, 3346, 3521, + 3522, 3609, 3610, 3697, 3698, 3785, 3873, 3874, 3961, 3962, 4049, + 4050, 4224 }, + { 1, 46, 91, 136, 181, 226, 271, 361, 406, 451, 496, 541, 586, 631, 721, + 766, 811, 856, 901, 946, 991, 1081, 1126, 1171, 1216, 1261, 1306, + 1351, 1441, 1442, 1531, 1532, 1621, 1622, 1711, 1712, 1801, 1802, + 1891, 1892, 1981, 1982, 2161, 2162, 2251, 2252, 2341, 2342, 2431, + 2432, 2521, 2522, 2611, 2612, 2701, 2702, 2881, 2882, 2971, 2972, + 3061, 3062, 3151, 3152, 3241, 3242, 3331, 3332, 3421, 3422, 3601, + 3602, 3691, 3692, 3781, 3782, 3871, 3961, 3962, 4051, 4052, 4141, + 4142, 4320 }, + { 1, 47, 93, 139, 185, 231, 277, 369, 415, 461, 507, 553, 599, 645, 737, + 783, 829, 875, 921, 967, 1013, 1105, 1151, 1197, 1243, 1289, 1335, + 1381, 1473, 1474, 1565, 1566, 1657, 1658, 1749, 1750, 1841, 1842, + 1933, 1934, 2025, 2026, 2209, 2210, 2301, 2302, 2393, 2394, 2485, + 2486, 2577, 2578, 2669, 2670, 2761, 2762, 2945, 2946, 3037, 3038, + 3129, 3130, 3221, 3222, 3313, 3314, 3405, 3406, 3497, 3498, 3681, + 3682, 3773, 3774, 3865, 3866, 3957, 4049, 4050, 4141, 4142, 4233, + 4234, 4416 }, + { 1, 48, 95, 142, 189, 236, 283, 377, 424, 471, 518, 565, 612, 659, 753, + 800, 847, 894, 941, 988, 1035, 1129, 1176, 1223, 1270, 1317, 1364, + 1411, 1505, 1506, 1599, 1600, 1693, 1694, 1787, 1788, 1881, 1882, + 1975, 1976, 2069, 2070, 2257, 2258, 2351, 2352, 2445, 2446, 2539, + 2540, 2633, 2634, 2727, 2728, 2821, 2822, 3009, 3010, 3103, 3104, + 3197, 3198, 3291, 3292, 3385, 3386, 3479, 3480, 3573, 3574, 3761, + 3762, 3855, 3856, 3949, 3950, 4043, 4137, 4138, 4231, 4232, 4325, + 4326, 4512 }, + { 1, 49, 97, 145, 193, 241, 289, 385, 433, 481, 529, 577, 625, 673, 769, + 817, 865, 913, 961, 1009, 1057, 1153, 1201, 1249, 1297, 1345, 1393, + 1441, 1537, 1538, 1633, 1634, 1729, 1730, 1825, 1826, 1921, 1922, + 2017, 2018, 2113, 2114, 2305, 2306, 2401, 2402, 2497, 2498, 2593, + 2594, 2689, 2690, 2785, 2786, 2881, 2882, 3073, 3074, 3169, 3170, + 3265, 3266, 3361, 3362, 3457, 3458, 3553, 3554, 3649, 3650, 3841, + 3842, 3937, 3938, 4033, 4034, 4129, 4225, 4226, 4321, 4322, 4417, + 4418, 4608 }, + { 1, 50, 99, 148, 197, 246, 295, 393, 442, 491, 540, 589, 638, 687, 785, + 834, 883, 932, 981, 1030, 1079, 1177, 1226, 1275, 1324, 1373, 1422, + 1471, 1569, 1570, 1667, 1668, 1765, 1766, 1863, 1864, 1961, 1962, + 2059, 2060, 2157, 2158, 2353, 2354, 2451, 2452, 2549, 2550, 2647, + 2648, 2745, 2746, 2843, 2844, 2941, 2942, 3137, 3138, 3235, 3236, + 3333, 3334, 3431, 3432, 3529, 3530, 3627, 3628, 3725, 3726, 3921, + 3922, 4019, 4020, 4117, 4118, 4215, 4313, 4314, 4411, 4412, 4509, + 4510, 4704 }, + { 1, 51, 101, 151, 201, 251, 301, 401, 451, 501, 551, 601, 651, 701, + 801, 851, 901, 951, 1001, 1051, 1101, 1201, 1251, 1301, 1351, 1401, + 1451, 1501, 1601, 1602, 1701, 1702, 1801, 1802, 1901, 1902, 2001, + 2002, 2101, 2102, 2201, 2202, 2401, 2402, 2501, 2502, 2601, 2602, + 2701, 2702, 2801, 2802, 2901, 2902, 3001, 3002, 3201, 3202, 3301, + 3302, 3401, 3402, 3501, 3502, 3601, 3602, 3701, 3702, 3801, 3802, + 4001, 4002, 4101, 4102, 4201, 4202, 4301, 4401, 4402, 4501, 4502, + 4601, 4602, 4800 }, + { 1, 52, 103, 154, 205, 256, 307, 409, 460, 511, 562, 613, 664, 715, + 817, 868, 919, 970, 1021, 1072, 1123, 1225, 1276, 1327, 1378, 1429, + 1480, 1531, 1633, 1634, 1735, 1736, 1837, 1838, 1939, 1940, 2041, + 2042, 2143, 2144, 2245, 2246, 2449, 2450, 2551, 2552, 2653, 2654, + 2755, 2756, 2857, 2858, 2959, 2960, 3061, 3062, 3265, 3266, 3367, + 3368, 3469, 3470, 3571, 3572, 3673, 3674, 3775, 3776, 3877, 3878, + 4081, 4082, 4183, 4184, 4285, 4286, 4387, 4489, 4490, 4591, 4592, + 4693, 4694, 4896 }, + { 1, 53, 105, 157, 209, 261, 313, 417, 469, 521, 573, 625, 677, 729, + 833, 885, 937, 989, 1041, 1093, 1145, 1249, 1301, 1353, 1405, 1457, + 1509, 1561, 1665, 1666, 1769, 1770, 1873, 1874, 1977, 1978, 2081, + 2082, 2185, 2186, 2289, 2290, 2497, 2498, 2601, 2602, 2705, 2706, + 2809, 2810, 2913, 2914, 3017, 3018, 3121, 3122, 3329, 3330, 3433, + 3434, 3537, 3538, 3641, 3642, 3745, 3746, 3849, 3850, 3953, 3954, + 4161, 4162, 4265, 4266, 4369, 4370, 4473, 4577, 4578, 4681, 4682, + 4785, 4786, 4992 }, + { 1, 54, 107, 160, 213, 266, 319, 425, 478, 531, 584, 637, 690, 743, + 849, 902, 955, 1008, 1061, 1114, 1167, 1273, 1326, 1379, 1432, 1485, + 1538, 1591, 1697, 1698, 1803, 1804, 1909, 1910, 2015, 2016, 2121, + 2122, 2227, 2228, 2333, 2334, 2545, 2546, 2651, 2652, 2757, 2758, + 2863, 2864, 2969, 2970, 3075, 3076, 3181, 3182, 3393, 3394, 3499, + 3500, 3605, 3606, 3711, 3712, 3817, 3818, 3923, 3924, 4029, 4030, + 4241, 4242, 4347, 4348, 4453, 4454, 4559, 4665, 4666, 4771, 4772, + 4877, 4878, 5088 }, + { 1, 55, 109, 163, 217, 271, 325, 433, 487, 541, 595, 649, 703, 757, + 865, 919, 973, 1027, 1081, 1135, 1189, 1297, 1351, 1405, 1459, 1513, + 1567, 1621, 1729, 1730, 1837, 1838, 1945, 1946, 2053, 2054, 2161, + 2162, 2269, 2270, 2377, 2378, 2593, 2594, 2701, 2702, 2809, 2810, + 2917, 2918, 3025, 3026, 3133, 3134, 3241, 3242, 3457, 3458, 3565, + 3566, 3673, 3674, 3781, 3782, 3889, 3890, 3997, 3998, 4105, 4106, + 4321, 4322, 4429, 4430, 4537, 4538, 4645, 4753, 4754, 4861, 4862, + 4969, 4970, 5184 }, + { 1, 56, 111, 166, 221, 276, 331, 441, 496, 551, 606, 661, 716, 771, + 881, 936, 991, 1046, 1101, 1156, 1211, 1321, 1376, 1431, 1486, 1541, + 1596, 1651, 1761, 1762, 1871, 1872, 1981, 1982, 2091, 2092, 2201, + 2202, 2311, 2312, 2421, 2422, 2641, 2642, 2751, 2752, 2861, 2862, + 2971, 2972, 3081, 3082, 3191, 3192, 3301, 3302, 3521, 3522, 3631, + 3632, 3741, 3742, 3851, 3852, 3961, 3962, 4071, 4072, 4181, 4182, + 4401, 4402, 4511, 4512, 4621, 4622, 4731, 4841, 4842, 4951, 4952, + 5061, 5062, 5280 }, + { 1, 57, 113, 169, 225, 281, 337, 449, 505, 561, 617, 673, 729, 785, + 897, 953, 1009, 1065, 1121, 1177, 1233, 1345, 1401, 1457, 1513, 1569, + 1625, 1681, 1793, 1794, 1905, 1906, 2017, 2018, 2129, 2130, 2241, + 2242, 2353, 2354, 2465, 2466, 2689, 2690, 2801, 2802, 2913, 2914, + 3025, 3026, 3137, 3138, 3249, 3250, 3361, 3362, 3585, 3586, 3697, + 3698, 3809, 3810, 3921, 3922, 4033, 4034, 4145, 4146, 4257, 4258, + 4481, 4482, 4593, 4594, 4705, 4706, 4817, 4929, 4930, 5041, 5042, + 5153, 5154, 5376 }, + { 1, 58, 115, 172, 229, 286, 343, 457, 514, 571, 628, 685, 742, 799, + 913, 970, 1027, 1084, 1141, 1198, 1255, 1369, 1426, 1483, 1540, 1597, + 1654, 1711, 1825, 1826, 1939, 1940, 2053, 2054, 2167, 2168, 2281, + 2282, 2395, 2396, 2509, 2510, 2737, 2738, 2851, 2852, 2965, 2966, + 3079, 3080, 3193, 3194, 3307, 3308, 3421, 3422, 3649, 3650, 3763, + 3764, 3877, 3878, 3991, 3992, 4105, 4106, 4219, 4220, 4333, 4334, + 4561, 4562, 4675, 4676, 4789, 4790, 4903, 5017, 5018, 5131, 5132, + 5245, 5246, 5472 }, + { 1, 59, 117, 175, 233, 291, 349, 465, 523, 581, 639, 697, 755, 813, + 929, 987, 1045, 1103, 1161, 1219, 1277, 1393, 1451, 1509, 1567, 1625, + 1683, 1741, 1857, 1858, 1973, 1974, 2089, 2090, 2205, 2206, 2321, + 2322, 2437, 2438, 2553, 2554, 2785, 2786, 2901, 2902, 3017, 3018, + 3133, 3134, 3249, 3250, 3365, 3366, 3481, 3482, 3713, 3714, 3829, + 3830, 3945, 3946, 4061, 4062, 4177, 4178, 4293, 4294, 4409, 4410, + 4641, 4642, 4757, 4758, 4873, 4874, 4989, 5105, 5106, 5221, 5222, + 5337, 5338, 5568 }, + { 1, 60, 119, 178, 237, 296, 355, 473, 532, 591, 650, 709, 768, 827, + 945, 1004, 1063, 1122, 1181, 1240, 1299, 1417, 1476, 1535, 1594, 1653, + 1712, 1771, 1889, 1890, 2007, 2008, 2125, 2126, 2243, 2244, 2361, + 2362, 2479, 2480, 2597, 2598, 2833, 2834, 2951, 2952, 3069, 3070, + 3187, 3188, 3305, 3306, 3423, 3424, 3541, 3542, 3777, 3778, 3895, + 3896, 4013, 4014, 4131, 4132, 4249, 4250, 4367, 4368, 4485, 4486, + 4721, 4722, 4839, 4840, 4957, 4958, 5075, 5193, 5194, 5311, 5312, + 5429, 5430, 5664 }, + { 1, 61, 121, 181, 241, 301, 361, 481, 541, 601, 661, 721, 781, 841, + 961, 1021, 1081, 1141, 1201, 1261, 1321, 1441, 1501, 1561, 1621, 1681, + 1741, 1801, 1921, 1922, 2041, 2042, 2161, 2162, 2281, 2282, 2401, + 2402, 2521, 2522, 2641, 2642, 2881, 2882, 3001, 3002, 3121, 3122, + 3241, 3242, 3361, 3362, 3481, 3482, 3601, 3602, 3841, 3842, 3961, + 3962, 4081, 4082, 4201, 4202, 4321, 4322, 4441, 4442, 4561, 4562, + 4801, 4802, 4921, 4922, 5041, 5042, 5161, 5281, 5282, 5401, 5402, + 5521, 5522, 5760 }, + { 1, 62, 123, 184, 245, 306, 367, 489, 550, 611, 672, 733, 794, 855, + 977, 1038, 1099, 1160, 1221, 1282, 1343, 1465, 1526, 1587, 1648, 1709, + 1770, 1831, 1953, 1954, 2075, 2076, 2197, 2198, 2319, 2320, 2441, + 2442, 2563, 2564, 2685, 2686, 2929, 2930, 3051, 3052, 3173, 3174, + 3295, 3296, 3417, 3418, 3539, 3540, 3661, 3662, 3905, 3906, 4027, + 4028, 4149, 4150, 4271, 4272, 4393, 4394, 4515, 4516, 4637, 4638, + 4881, 4882, 5003, 5004, 5125, 5126, 5247, 5369, 5370, 5491, 5492, + 5613, 5614, 5856 }, + { 1, 63, 125, 187, 249, 311, 373, 497, 559, 621, 683, 745, 807, 869, + 993, 1055, 1117, 1179, 1241, 1303, 1365, 1489, 1551, 1613, 1675, 1737, + 1799, 1861, 1985, 1986, 2109, 2110, 2233, 2234, 2357, 2358, 2481, + 2482, 2605, 2606, 2729, 2730, 2977, 2978, 3101, 3102, 3225, 3226, + 3349, 3350, 3473, 3474, 3597, 3598, 3721, 3722, 3969, 3970, 4093, + 4094, 4217, 4218, 4341, 4342, 4465, 4466, 4589, 4590, 4713, 4714, + 4961, 4962, 5085, 5086, 5209, 5210, 5333, 5457, 5458, 5581, 5582, + 5705, 5706, 5952 }, + { 1, 64, 127, 190, 253, 316, 379, 505, 568, 631, 694, 757, 820, 883, + 1009, 1072, 1135, 1198, 1261, 1324, 1387, 1513, 1576, 1639, 1702, + 1765, 1828, 1891, 2017, 2018, 2143, 2144, 2269, 2270, 2395, 2396, + 2521, 2522, 2647, 2648, 2773, 2774, 3025, 3026, 3151, 3152, 3277, + 3278, 3403, 3404, 3529, 3530, 3655, 3656, 3781, 3782, 4033, 4034, + 4159, 4160, 4285, 4286, 4411, 4412, 4537, 4538, 4663, 4664, 4789, + 4790, 5041, 5042, 5167, 5168, 5293, 5294, 5419, 5545, 5546, 5671, + 5672, 5797, 5798, 6048 }, + { 1, 65, 129, 193, 257, 321, 385, 513, 577, 641, 705, 769, 833, 897, + 1025, 1089, 1153, 1217, 1281, 1345, 1409, 1537, 1601, 1665, 1729, + 1793, 1857, 1921, 2049, 2050, 2177, 2178, 2305, 2306, 2433, 2434, + 2561, 2562, 2689, 2690, 2817, 2818, 3073, 3074, 3201, 3202, 3329, + 3330, 3457, 3458, 3585, 3586, 3713, 3714, 3841, 3842, 4097, 4098, + 4225, 4226, 4353, 4354, 4481, 4482, 4609, 4610, 4737, 4738, 4865, + 4866, 5121, 5122, 5249, 5250, 5377, 5378, 5505, 5633, 5634, 5761, + 5762, 5889, 5890, 6144 }, + { 1, 66, 131, 196, 261, 326, 391, 521, 586, 651, 716, 781, 846, 911, + 1041, 1106, 1171, 1236, 1301, 1366, 1431, 1561, 1626, 1691, 1756, + 1821, 1886, 1951, 2081, 2082, 2211, 2212, 2341, 2342, 2471, 2472, + 2601, 2602, 2731, 2732, 2861, 2862, 3121, 3122, 3251, 3252, 3381, + 3382, 3511, 3512, 3641, 3642, 3771, 3772, 3901, 3902, 4161, 4162, + 4291, 4292, 4421, 4422, 4551, 4552, 4681, 4682, 4811, 4812, 4941, + 4942, 5201, 5202, 5331, 5332, 5461, 5462, 5591, 5721, 5722, 5851, + 5852, 5981, 5982, 6240 }, + { 1, 68, 135, 202, 269, 336, 403, 537, 604, 671, 738, 805, 872, 939, + 1073, 1140, 1207, 1274, 1341, 1408, 1475, 1609, 1676, 1743, 1810, + 1877, 1944, 2011, 2145, 2146, 2279, 2280, 2413, 2414, 2547, 2548, + 2681, 2682, 2815, 2816, 2949, 2950, 3217, 3218, 3351, 3352, 3485, + 3486, 3619, 3620, 3753, 3754, 3887, 3888, 4021, 4022, 4289, 4290, + 4423, 4424, 4557, 4558, 4691, 4692, 4825, 4826, 4959, 4960, 5093, + 5094, 5361, 5362, 5495, 5496, 5629, 5630, 5763, 5897, 5898, 6031, + 6032, 6165, 6166, 6432 }, + { 1, 70, 139, 208, 277, 346, 415, 553, 622, 691, 760, 829, 898, 967, + 1105, 1174, 1243, 1312, 1381, 1450, 1519, 1657, 1726, 1795, 1864, + 1933, 2002, 2071, 2209, 2210, 2347, 2348, 2485, 2486, 2623, 2624, + 2761, 2762, 2899, 2900, 3037, 3038, 3313, 3314, 3451, 3452, 3589, + 3590, 3727, 3728, 3865, 3866, 4003, 4004, 4141, 4142, 4417, 4418, + 4555, 4556, 4693, 4694, 4831, 4832, 4969, 4970, 5107, 5108, 5245, + 5246, 5521, 5522, 5659, 5660, 5797, 5798, 5935, 6073, 6074, 6211, + 6212, 6349, 6350, 6624 }, + { 1, 72, 143, 214, 285, 356, 427, 569, 640, 711, 782, 853, 924, 995, + 1137, 1208, 1279, 1350, 1421, 1492, 1563, 1705, 1776, 1847, 1918, + 1989, 2060, 2131, 2273, 2274, 2415, 2416, 2557, 2558, 2699, 2700, + 2841, 2842, 2983, 2984, 3125, 3126, 3409, 3410, 3551, 3552, 3693, + 3694, 3835, 3836, 3977, 3978, 4119, 4120, 4261, 4262, 4545, 4546, + 4687, 4688, 4829, 4830, 4971, 4972, 5113, 5114, 5255, 5256, 5397, + 5398, 5681, 5682, 5823, 5824, 5965, 5966, 6107, 6249, 6250, 6391, + 6392, 6533, 6534, 6816 }, + { 1, 74, 147, 220, 293, 366, 439, 585, 658, 731, 804, 877, 950, 1023, + 1169, 1242, 1315, 1388, 1461, 1534, 1607, 1753, 1826, 1899, 1972, + 2045, 2118, 2191, 2337, 2338, 2483, 2484, 2629, 2630, 2775, 2776, + 2921, 2922, 3067, 3068, 3213, 3214, 3505, 3506, 3651, 3652, 3797, + 3798, 3943, 3944, 4089, 4090, 4235, 4236, 4381, 4382, 4673, 4674, + 4819, 4820, 4965, 4966, 5111, 5112, 5257, 5258, 5403, 5404, 5549, + 5550, 5841, 5842, 5987, 5988, 6133, 6134, 6279, 6425, 6426, 6571, + 6572, 6717, 6718, 7008 }, + { 1, 76, 151, 226, 301, 376, 451, 601, 676, 751, 826, 901, 976, 1051, + 1201, 1276, 1351, 1426, 1501, 1576, 1651, 1801, 1876, 1951, 2026, + 2101, 2176, 2251, 2401, 2402, 2551, 2552, 2701, 2702, 2851, 2852, + 3001, 3002, 3151, 3152, 3301, 3302, 3601, 3602, 3751, 3752, 3901, + 3902, 4051, 4052, 4201, 4202, 4351, 4352, 4501, 4502, 4801, 4802, + 4951, 4952, 5101, 5102, 5251, 5252, 5401, 5402, 5551, 5552, 5701, + 5702, 6001, 6002, 6151, 6152, 6301, 6302, 6451, 6601, 6602, 6751, + 6752, 6901, 6902, 7200 }, + { 1, 78, 155, 232, 309, 386, 463, 617, 694, 771, 848, 925, 1002, 1079, + 1233, 1310, 1387, 1464, 1541, 1618, 1695, 1849, 1926, 2003, 2080, + 2157, 2234, 2311, 2465, 2466, 2619, 2620, 2773, 2774, 2927, 2928, + 3081, 3082, 3235, 3236, 3389, 3390, 3697, 3698, 3851, 3852, 4005, + 4006, 4159, 4160, 4313, 4314, 4467, 4468, 4621, 4622, 4929, 4930, + 5083, 5084, 5237, 5238, 5391, 5392, 5545, 5546, 5699, 5700, 5853, + 5854, 6161, 6162, 6315, 6316, 6469, 6470, 6623, 6777, 6778, 6931, + 6932, 7085, 7086, 7392 }, + { 1, 80, 159, 238, 317, 396, 475, 633, 712, 791, 870, 949, 1028, 1107, + 1265, 1344, 1423, 1502, 1581, 1660, 1739, 1897, 1976, 2055, 2134, + 2213, 2292, 2371, 2529, 2530, 2687, 2688, 2845, 2846, 3003, 3004, + 3161, 3162, 3319, 3320, 3477, 3478, 3793, 3794, 3951, 3952, 4109, + 4110, 4267, 4268, 4425, 4426, 4583, 4584, 4741, 4742, 5057, 5058, + 5215, 5216, 5373, 5374, 5531, 5532, 5689, 5690, 5847, 5848, 6005, + 6006, 6321, 6322, 6479, 6480, 6637, 6638, 6795, 6953, 6954, 7111, + 7112, 7269, 7270, 7584 }, + { 1, 82, 163, 244, 325, 406, 487, 649, 730, 811, 892, 973, 1054, 1135, + 1297, 1378, 1459, 1540, 1621, 1702, 1783, 1945, 2026, 2107, 2188, + 2269, 2350, 2431, 2593, 2594, 2755, 2756, 2917, 2918, 3079, 3080, + 3241, 3242, 3403, 3404, 3565, 3566, 3889, 3890, 4051, 4052, 4213, + 4214, 4375, 4376, 4537, 4538, 4699, 4700, 4861, 4862, 5185, 5186, + 5347, 5348, 5509, 5510, 5671, 5672, 5833, 5834, 5995, 5996, 6157, + 6158, 6481, 6482, 6643, 6644, 6805, 6806, 6967, 7129, 7130, 7291, + 7292, 7453, 7454, 7776 }, + { 1, 84, 167, 250, 333, 416, 499, 665, 748, 831, 914, 997, 1080, 1163, + 1329, 1412, 1495, 1578, 1661, 1744, 1827, 1993, 2076, 2159, 2242, + 2325, 2408, 2491, 2657, 2658, 2823, 2824, 2989, 2990, 3155, 3156, + 3321, 3322, 3487, 3488, 3653, 3654, 3985, 3986, 4151, 4152, 4317, + 4318, 4483, 4484, 4649, 4650, 4815, 4816, 4981, 4982, 5313, 5314, + 5479, 5480, 5645, 5646, 5811, 5812, 5977, 5978, 6143, 6144, 6309, + 6310, 6641, 6642, 6807, 6808, 6973, 6974, 7139, 7305, 7306, 7471, + 7472, 7637, 7638, 7968 }, + { 1, 86, 171, 256, 341, 426, 511, 681, 766, 851, 936, 1021, 1106, 1191, + 1361, 1446, 1531, 1616, 1701, 1786, 1871, 2041, 2126, 2211, 2296, + 2381, 2466, 2551, 2721, 2722, 2891, 2892, 3061, 3062, 3231, 3232, + 3401, 3402, 3571, 3572, 3741, 3742, 4081, 4082, 4251, 4252, 4421, + 4422, 4591, 4592, 4761, 4762, 4931, 4932, 5101, 5102, 5441, 5442, + 5611, 5612, 5781, 5782, 5951, 5952, 6121, 6122, 6291, 6292, 6461, + 6462, 6801, 6802, 6971, 6972, 7141, 7142, 7311, 7481, 7482, 7651, + 7652, 7821, 7822, 8160 }, + { 1, 88, 175, 262, 349, 436, 523, 697, 784, 871, 958, 1045, 1132, 1219, + 1393, 1480, 1567, 1654, 1741, 1828, 1915, 2089, 2176, 2263, 2350, + 2437, 2524, 2611, 2785, 2786, 2959, 2960, 3133, 3134, 3307, 3308, + 3481, 3482, 3655, 3656, 3829, 3830, 4177, 4178, 4351, 4352, 4525, + 4526, 4699, 4700, 4873, 4874, 5047, 5048, 5221, 5222, 5569, 5570, + 5743, 5744, 5917, 5918, 6091, 6092, 6265, 6266, 6439, 6440, 6613, + 6614, 6961, 6962, 7135, 7136, 7309, 7310, 7483, 7657, 7658, 7831, + 7832, 8005, 8006, 8352 }, + { 1, 90, 179, 268, 357, 446, 535, 713, 802, 891, 980, 1069, 1158, 1247, + 1425, 1514, 1603, 1692, 1781, 1870, 1959, 2137, 2226, 2315, 2404, + 2493, 2582, 2671, 2849, 2850, 3027, 3028, 3205, 3206, 3383, 3384, + 3561, 3562, 3739, 3740, 3917, 3918, 4273, 4274, 4451, 4452, 4629, + 4630, 4807, 4808, 4985, 4986, 5163, 5164, 5341, 5342, 5697, 5698, + 5875, 5876, 6053, 6054, 6231, 6232, 6409, 6410, 6587, 6588, 6765, + 6766, 7121, 7122, 7299, 7300, 7477, 7478, 7655, 7833, 7834, 8011, + 8012, 8189, 8190, 8544 }, + { 1, 92, 183, 274, 365, 456, 547, 729, 820, 911, 1002, 1093, 1184, 1275, + 1457, 1548, 1639, 1730, 1821, 1912, 2003, 2185, 2276, 2367, 2458, + 2549, 2640, 2731, 2913, 2914, 3095, 3096, 3277, 3278, 3459, 3460, + 3641, 3642, 3823, 3824, 4005, 4006, 4369, 4370, 4551, 4552, 4733, + 4734, 4915, 4916, 5097, 5098, 5279, 5280, 5461, 5462, 5825, 5826, + 6007, 6008, 6189, 6190, 6371, 6372, 6553, 6554, 6735, 6736, 6917, + 6918, 7281, 7282, 7463, 7464, 7645, 7646, 7827, 8009, 8010, 8191, + 8192, 8373, 8374, 8736 }, + { 1, 94, 187, 280, 373, 466, 559, 745, 838, 931, 1024, 1117, 1210, 1303, + 1489, 1582, 1675, 1768, 1861, 1954, 2047, 2233, 2326, 2419, 2512, + 2605, 2698, 2791, 2977, 2978, 3163, 3164, 3349, 3350, 3535, 3536, + 3721, 3722, 3907, 3908, 4093, 4094, 4465, 4466, 4651, 4652, 4837, + 4838, 5023, 5024, 5209, 5210, 5395, 5396, 5581, 5582, 5953, 5954, + 6139, 6140, 6325, 6326, 6511, 6512, 6697, 6698, 6883, 6884, 7069, + 7070, 7441, 7442, 7627, 7628, 7813, 7814, 7999, 8185, 8186, 8371, + 8372, 8557, 8558, 8928 }, + { 1, 96, 191, 286, 381, 476, 571, 761, 856, 951, 1046, 1141, 1236, 1331, + 1521, 1616, 1711, 1806, 1901, 1996, 2091, 2281, 2376, 2471, 2566, + 2661, 2756, 2851, 3041, 3042, 3231, 3232, 3421, 3422, 3611, 3612, + 3801, 3802, 3991, 3992, 4181, 4182, 4561, 4562, 4751, 4752, 4941, + 4942, 5131, 5132, 5321, 5322, 5511, 5512, 5701, 5702, 6081, 6082, + 6271, 6272, 6461, 6462, 6651, 6652, 6841, 6842, 7031, 7032, 7221, + 7222, 7601, 7602, 7791, 7792, 7981, 7982, 8171, 8361, 8362, 8551, + 8552, 8741, 8742, 9120 }, + { 1, 98, 195, 292, 389, 486, 583, 777, 874, 971, 1068, 1165, 1262, 1359, + 1553, 1650, 1747, 1844, 1941, 2038, 2135, 2329, 2426, 2523, 2620, + 2717, 2814, 2911, 3105, 3106, 3299, 3300, 3493, 3494, 3687, 3688, + 3881, 3882, 4075, 4076, 4269, 4270, 4657, 4658, 4851, 4852, 5045, + 5046, 5239, 5240, 5433, 5434, 5627, 5628, 5821, 5822, 6209, 6210, + 6403, 6404, 6597, 6598, 6791, 6792, 6985, 6986, 7179, 7180, 7373, + 7374, 7761, 7762, 7955, 7956, 8149, 8150, 8343, 8537, 8538, 8731, + 8732, 8925, 8926, 9312 }, + { 1, 100, 199, 298, 397, 496, 595, 793, 892, 991, 1090, 1189, 1288, + 1387, 1585, 1684, 1783, 1882, 1981, 2080, 2179, 2377, 2476, 2575, + 2674, 2773, 2872, 2971, 3169, 3170, 3367, 3368, 3565, 3566, 3763, + 3764, 3961, 3962, 4159, 4160, 4357, 4358, 4753, 4754, 4951, 4952, + 5149, 5150, 5347, 5348, 5545, 5546, 5743, 5744, 5941, 5942, 6337, + 6338, 6535, 6536, 6733, 6734, 6931, 6932, 7129, 7130, 7327, 7328, + 7525, 7526, 7921, 7922, 8119, 8120, 8317, 8318, 8515, 8713, 8714, + 8911, 8912, 9109, 9110, 9504 }, + { 1, 102, 203, 304, 405, 506, 607, 809, 910, 1011, 1112, 1213, 1314, + 1415, 1617, 1718, 1819, 1920, 2021, 2122, 2223, 2425, 2526, 2627, + 2728, 2829, 2930, 3031, 3233, 3234, 3435, 3436, 3637, 3638, 3839, + 3840, 4041, 4042, 4243, 4244, 4445, 4446, 4849, 4850, 5051, 5052, + 5253, 5254, 5455, 5456, 5657, 5658, 5859, 5860, 6061, 6062, 6465, + 6466, 6667, 6668, 6869, 6870, 7071, 7072, 7273, 7274, 7475, 7476, + 7677, 7678, 8081, 8082, 8283, 8284, 8485, 8486, 8687, 8889, 8890, + 9091, 9092, 9293, 9294, 9696 }, + { 1, 104, 207, 310, 413, 516, 619, 825, 928, 1031, 1134, 1237, 1340, + 1443, 1649, 1752, 1855, 1958, 2061, 2164, 2267, 2473, 2576, 2679, + 2782, 2885, 2988, 3091, 3297, 3298, 3503, 3504, 3709, 3710, 3915, + 3916, 4121, 4122, 4327, 4328, 4533, 4534, 4945, 4946, 5151, 5152, + 5357, 5358, 5563, 5564, 5769, 5770, 5975, 5976, 6181, 6182, 6593, + 6594, 6799, 6800, 7005, 7006, 7211, 7212, 7417, 7418, 7623, 7624, + 7829, 7830, 8241, 8242, 8447, 8448, 8653, 8654, 8859, 9065, 9066, + 9271, 9272, 9477, 9478, 9888 }, + { 1, 106, 211, 316, 421, 526, 631, 841, 946, 1051, 1156, 1261, 1366, + 1471, 1681, 1786, 1891, 1996, 2101, 2206, 2311, 2521, 2626, 2731, + 2836, 2941, 3046, 3151, 3361, 3362, 3571, 3572, 3781, 3782, 3991, + 3992, 4201, 4202, 4411, 4412, 4621, 4622, 5041, 5042, 5251, 5252, + 5461, 5462, 5671, 5672, 5881, 5882, 6091, 6092, 6301, 6302, 6721, + 6722, 6931, 6932, 7141, 7142, 7351, 7352, 7561, 7562, 7771, 7772, + 7981, 7982, 8401, 8402, 8611, 8612, 8821, 8822, 9031, 9241, 9242, + 9451, 9452, 9661, 9662, 10080 }, + { 1, 108, 215, 322, 429, 536, 643, 857, 964, 1071, 1178, 1285, 1392, + 1499, 1713, 1820, 1927, 2034, 2141, 2248, 2355, 2569, 2676, 2783, + 2890, 2997, 3104, 3211, 3425, 3426, 3639, 3640, 3853, 3854, 4067, + 4068, 4281, 4282, 4495, 4496, 4709, 4710, 5137, 5138, 5351, 5352, + 5565, 5566, 5779, 5780, 5993, 5994, 6207, 6208, 6421, 6422, 6849, + 6850, 7063, 7064, 7277, 7278, 7491, 7492, 7705, 7706, 7919, 7920, + 8133, 8134, 8561, 8562, 8775, 8776, 8989, 8990, 9203, 9417, 9418, + 9631, 9632, 9845, 9846, 10272 }, + { 1, 110, 219, 328, 437, 546, 655, 873, 982, 1091, 1200, 1309, 1418, + 1527, 1745, 1854, 1963, 2072, 2181, 2290, 2399, 2617, 2726, 2835, + 2944, 3053, 3162, 3271, 3489, 3490, 3707, 3708, 3925, 3926, 4143, + 4144, 4361, 4362, 4579, 4580, 4797, 4798, 5233, 5234, 5451, 5452, + 5669, 5670, 5887, 5888, 6105, 6106, 6323, 6324, 6541, 6542, 6977, + 6978, 7195, 7196, 7413, 7414, 7631, 7632, 7849, 7850, 8067, 8068, + 8285, 8286, 8721, 8722, 8939, 8940, 9157, 9158, 9375, 9593, 9594, + 9811, 9812, 10029, 10030, 10464 }, + { 1, 112, 223, 334, 445, 556, 667, 889, 1000, 1111, 1222, 1333, 1444, + 1555, 1777, 1888, 1999, 2110, 2221, 2332, 2443, 2665, 2776, 2887, + 2998, 3109, 3220, 3331, 3553, 3554, 3775, 3776, 3997, 3998, 4219, + 4220, 4441, 4442, 4663, 4664, 4885, 4886, 5329, 5330, 5551, 5552, + 5773, 5774, 5995, 5996, 6217, 6218, 6439, 6440, 6661, 6662, 7105, + 7106, 7327, 7328, 7549, 7550, 7771, 7772, 7993, 7994, 8215, 8216, + 8437, 8438, 8881, 8882, 9103, 9104, 9325, 9326, 9547, 9769, 9770, + 9991, 9992, 10213, 10214, 10656 }, + { 1, 114, 227, 340, 453, 566, 679, 905, 1018, 1131, 1244, 1357, 1470, + 1583, 1809, 1922, 2035, 2148, 2261, 2374, 2487, 2713, 2826, 2939, + 3052, 3165, 3278, 3391, 3617, 3618, 3843, 3844, 4069, 4070, 4295, + 4296, 4521, 4522, 4747, 4748, 4973, 4974, 5425, 5426, 5651, 5652, + 5877, 5878, 6103, 6104, 6329, 6330, 6555, 6556, 6781, 6782, 7233, + 7234, 7459, 7460, 7685, 7686, 7911, 7912, 8137, 8138, 8363, 8364, + 8589, 8590, 9041, 9042, 9267, 9268, 9493, 9494, 9719, 9945, 9946, + 10171, 10172, 10397, 10398, 10848 }, + { 1, 116, 231, 346, 461, 576, 691, 921, 1036, 1151, 1266, 1381, 1496, + 1611, 1841, 1956, 2071, 2186, 2301, 2416, 2531, 2761, 2876, 2991, + 3106, 3221, 3336, 3451, 3681, 3682, 3911, 3912, 4141, 4142, 4371, + 4372, 4601, 4602, 4831, 4832, 5061, 5062, 5521, 5522, 5751, 5752, + 5981, 5982, 6211, 6212, 6441, 6442, 6671, 6672, 6901, 6902, 7361, + 7362, 7591, 7592, 7821, 7822, 8051, 8052, 8281, 8282, 8511, 8512, + 8741, 8742, 9201, 9202, 9431, 9432, 9661, 9662, 9891, 10121, 10122, + 10351, 10352, 10581, 10582, 11040 }, + { 1, 118, 235, 352, 469, 586, 703, 937, 1054, 1171, 1288, 1405, 1522, + 1639, 1873, 1990, 2107, 2224, 2341, 2458, 2575, 2809, 2926, 3043, + 3160, 3277, 3394, 3511, 3745, 3746, 3979, 3980, 4213, 4214, 4447, + 4448, 4681, 4682, 4915, 4916, 5149, 5150, 5617, 5618, 5851, 5852, + 6085, 6086, 6319, 6320, 6553, 6554, 6787, 6788, 7021, 7022, 7489, + 7490, 7723, 7724, 7957, 7958, 8191, 8192, 8425, 8426, 8659, 8660, + 8893, 8894, 9361, 9362, 9595, 9596, 9829, 9830, 10063, 10297, 10298, + 10531, 10532, 10765, 10766, 11232 }, + { 1, 120, 239, 358, 477, 596, 715, 953, 1072, 1191, 1310, 1429, 1548, + 1667, 1905, 2024, 2143, 2262, 2381, 2500, 2619, 2857, 2976, 3095, + 3214, 3333, 3452, 3571, 3809, 3810, 4047, 4048, 4285, 4286, 4523, + 4524, 4761, 4762, 4999, 5000, 5237, 5238, 5713, 5714, 5951, 5952, + 6189, 6190, 6427, 6428, 6665, 6666, 6903, 6904, 7141, 7142, 7617, + 7618, 7855, 7856, 8093, 8094, 8331, 8332, 8569, 8570, 8807, 8808, + 9045, 9046, 9521, 9522, 9759, 9760, 9997, 9998, 10235, 10473, 10474, + 10711, 10712, 10949, 10950, 11424 }, + { 1, 122, 243, 364, 485, 606, 727, 969, 1090, 1211, 1332, 1453, 1574, + 1695, 1937, 2058, 2179, 2300, 2421, 2542, 2663, 2905, 3026, 3147, + 3268, 3389, 3510, 3631, 3873, 3874, 4115, 4116, 4357, 4358, 4599, + 4600, 4841, 4842, 5083, 5084, 5325, 5326, 5809, 5810, 6051, 6052, + 6293, 6294, 6535, 6536, 6777, 6778, 7019, 7020, 7261, 7262, 7745, + 7746, 7987, 7988, 8229, 8230, 8471, 8472, 8713, 8714, 8955, 8956, + 9197, 9198, 9681, 9682, 9923, 9924, 10165, 10166, 10407, 10649, 10650, + 10891, 10892, 11133, 11134, 11616 }, + { 1, 124, 247, 370, 493, 616, 739, 985, 1108, 1231, 1354, 1477, 1600, + 1723, 1969, 2092, 2215, 2338, 2461, 2584, 2707, 2953, 3076, 3199, + 3322, 3445, 3568, 3691, 3937, 3938, 4183, 4184, 4429, 4430, 4675, + 4676, 4921, 4922, 5167, 5168, 5413, 5414, 5905, 5906, 6151, 6152, + 6397, 6398, 6643, 6644, 6889, 6890, 7135, 7136, 7381, 7382, 7873, + 7874, 8119, 8120, 8365, 8366, 8611, 8612, 8857, 8858, 9103, 9104, + 9349, 9350, 9841, 9842, 10087, 10088, 10333, 10334, 10579, 10825, + 10826, 11071, 11072, 11317, 11318, 11808 }, + { 1, 126, 251, 376, 501, 626, 751, 1001, 1126, 1251, 1376, 1501, 1626, + 1751, 2001, 2126, 2251, 2376, 2501, 2626, 2751, 3001, 3126, 3251, + 3376, 3501, 3626, 3751, 4001, 4002, 4251, 4252, 4501, 4502, 4751, + 4752, 5001, 5002, 5251, 5252, 5501, 5502, 6001, 6002, 6251, 6252, + 6501, 6502, 6751, 6752, 7001, 7002, 7251, 7252, 7501, 7502, 8001, + 8002, 8251, 8252, 8501, 8502, 8751, 8752, 9001, 9002, 9251, 9252, + 9501, 9502, 10001, 10002, 10251, 10252, 10501, 10502, 10751, 11001, + 11002, 11251, 11252, 11501, 11502, 12000 }, + { 1, 128, 255, 382, 509, 636, 763, 1017, 1144, 1271, 1398, 1525, 1652, + 1779, 2033, 2160, 2287, 2414, 2541, 2668, 2795, 3049, 3176, 3303, + 3430, 3557, 3684, 3811, 4065, 4066, 4319, 4320, 4573, 4574, 4827, + 4828, 5081, 5082, 5335, 5336, 5589, 5590, 6097, 6098, 6351, 6352, + 6605, 6606, 6859, 6860, 7113, 7114, 7367, 7368, 7621, 7622, 8129, + 8130, 8383, 8384, 8637, 8638, 8891, 8892, 9145, 9146, 9399, 9400, + 9653, 9654, 10161, 10162, 10415, 10416, 10669, 10670, 10923, 11177, + 11178, 11431, 11432, 11685, 11686, 12192 }, + { 1, 130, 259, 388, 517, 646, 775, 1033, 1162, 1291, 1420, 1549, 1678, + 1807, 2065, 2194, 2323, 2452, 2581, 2710, 2839, 3097, 3226, 3355, + 3484, 3613, 3742, 3871, 4129, 4130, 4387, 4388, 4645, 4646, 4903, + 4904, 5161, 5162, 5419, 5420, 5677, 5678, 6193, 6194, 6451, 6452, + 6709, 6710, 6967, 6968, 7225, 7226, 7483, 7484, 7741, 7742, 8257, + 8258, 8515, 8516, 8773, 8774, 9031, 9032, 9289, 9290, 9547, 9548, + 9805, 9806, 10321, 10322, 10579, 10580, 10837, 10838, 11095, 11353, + 11354, 11611, 11612, 11869, 11870, 12384 }, + { 1, 132, 263, 394, 525, 656, 787, 1049, 1180, 1311, 1442, 1573, 1704, + 1835, 2097, 2228, 2359, 2490, 2621, 2752, 2883, 3145, 3276, 3407, + 3538, 3669, 3800, 3931, 4193, 4194, 4455, 4456, 4717, 4718, 4979, + 4980, 5241, 5242, 5503, 5504, 5765, 5766, 6289, 6290, 6551, 6552, + 6813, 6814, 7075, 7076, 7337, 7338, 7599, 7600, 7861, 7862, 8385, + 8386, 8647, 8648, 8909, 8910, 9171, 9172, 9433, 9434, 9695, 9696, + 9957, 9958, 10481, 10482, 10743, 10744, 11005, 11006, 11267, 11529, + 11530, 11791, 11792, 12053, 12054, 12576 }, + { 1, 134, 267, 400, 533, 666, 799, 1065, 1198, 1331, 1464, 1597, 1730, + 1863, 2129, 2262, 2395, 2528, 2661, 2794, 2927, 3193, 3326, 3459, + 3592, 3725, 3858, 3991, 4257, 4258, 4523, 4524, 4789, 4790, 5055, + 5056, 5321, 5322, 5587, 5588, 5853, 5854, 6385, 6386, 6651, 6652, + 6917, 6918, 7183, 7184, 7449, 7450, 7715, 7716, 7981, 7982, 8513, + 8514, 8779, 8780, 9045, 9046, 9311, 9312, 9577, 9578, 9843, 9844, + 10109, 10110, 10641, 10642, 10907, 10908, 11173, 11174, 11439, 11705, + 11706, 11971, 11972, 12237, 12238, 12768 }, + { 1, 136, 271, 406, 541, 676, 811, 1081, 1216, 1351, 1486, 1621, 1756, + 1891, 2161, 2296, 2431, 2566, 2701, 2836, 2971, 3241, 3376, 3511, + 3646, 3781, 3916, 4051, 4321, 4322, 4591, 4592, 4861, 4862, 5131, + 5132, 5401, 5402, 5671, 5672, 5941, 5942, 6481, 6482, 6751, 6752, + 7021, 7022, 7291, 7292, 7561, 7562, 7831, 7832, 8101, 8102, 8641, + 8642, 8911, 8912, 9181, 9182, 9451, 9452, 9721, 9722, 9991, 9992, + 10261, 10262, 10801, 10802, 11071, 11072, 11341, 11342, 11611, 11881, + 11882, 12151, 12152, 12421, 12422, 12960 }, + { 1, 138, 275, 412, 549, 686, 823, 1097, 1234, 1371, 1508, 1645, 1782, + 1919, 2193, 2330, 2467, 2604, 2741, 2878, 3015, 3289, 3426, 3563, + 3700, 3837, 3974, 4111, 4385, 4386, 4659, 4660, 4933, 4934, 5207, + 5208, 5481, 5482, 5755, 5756, 6029, 6030, 6577, 6578, 6851, 6852, + 7125, 7126, 7399, 7400, 7673, 7674, 7947, 7948, 8221, 8222, 8769, + 8770, 9043, 9044, 9317, 9318, 9591, 9592, 9865, 9866, 10139, 10140, + 10413, 10414, 10961, 10962, 11235, 11236, 11509, 11510, 11783, 12057, + 12058, 12331, 12332, 12605, 12606, 13152 }, + { 1, 140, 279, 418, 557, 696, 835, 1113, 1252, 1391, 1530, 1669, 1808, + 1947, 2225, 2364, 2503, 2642, 2781, 2920, 3059, 3337, 3476, 3615, + 3754, 3893, 4032, 4171, 4449, 4450, 4727, 4728, 5005, 5006, 5283, + 5284, 5561, 5562, 5839, 5840, 6117, 6118, 6673, 6674, 6951, 6952, + 7229, 7230, 7507, 7508, 7785, 7786, 8063, 8064, 8341, 8342, 8897, + 8898, 9175, 9176, 9453, 9454, 9731, 9732, 10009, 10010, 10287, 10288, + 10565, 10566, 11121, 11122, 11399, 11400, 11677, 11678, 11955, 12233, + 12234, 12511, 12512, 12789, 12790, 13344 }, + { 1, 142, 283, 424, 565, 706, 847, 1129, 1270, 1411, 1552, 1693, 1834, + 1975, 2257, 2398, 2539, 2680, 2821, 2962, 3103, 3385, 3526, 3667, + 3808, 3949, 4090, 4231, 4513, 4514, 4795, 4796, 5077, 5078, 5359, + 5360, 5641, 5642, 5923, 5924, 6205, 6206, 6769, 6770, 7051, 7052, + 7333, 7334, 7615, 7616, 7897, 7898, 8179, 8180, 8461, 8462, 9025, + 9026, 9307, 9308, 9589, 9590, 9871, 9872, 10153, 10154, 10435, 10436, + 10717, 10718, 11281, 11282, 11563, 11564, 11845, 11846, 12127, 12409, + 12410, 12691, 12692, 12973, 12974, 13536 }, + { 1, 144, 287, 430, 573, 716, 859, 1145, 1288, 1431, 1574, 1717, 1860, + 2003, 2289, 2432, 2575, 2718, 2861, 3004, 3147, 3433, 3576, 3719, + 3862, 4005, 4148, 4291, 4577, 4578, 4863, 4864, 5149, 5150, 5435, + 5436, 5721, 5722, 6007, 6008, 6293, 6294, 6865, 6866, 7151, 7152, + 7437, 7438, 7723, 7724, 8009, 8010, 8295, 8296, 8581, 8582, 9153, + 9154, 9439, 9440, 9725, 9726, 10011, 10012, 10297, 10298, 10583, + 10584, 10869, 10870, 11441, 11442, 11727, 11728, 12013, 12014, 12299, + 12585, 12586, 12871, 12872, 13157, 13158, 13728 }, + { 1, 146, 291, 436, 581, 726, 871, 1161, 1306, 1451, 1596, 1741, 1886, + 2031, 2321, 2466, 2611, 2756, 2901, 3046, 3191, 3481, 3626, 3771, + 3916, 4061, 4206, 4351, 4641, 4642, 4931, 4932, 5221, 5222, 5511, + 5512, 5801, 5802, 6091, 6092, 6381, 6382, 6961, 6962, 7251, 7252, + 7541, 7542, 7831, 7832, 8121, 8122, 8411, 8412, 8701, 8702, 9281, + 9282, 9571, 9572, 9861, 9862, 10151, 10152, 10441, 10442, 10731, + 10732, 11021, 11022, 11601, 11602, 11891, 11892, 12181, 12182, 12471, + 12761, 12762, 13051, 13052, 13341, 13342, 13920 }, + { 1, 148, 295, 442, 589, 736, 883, 1177, 1324, 1471, 1618, 1765, 1912, + 2059, 2353, 2500, 2647, 2794, 2941, 3088, 3235, 3529, 3676, 3823, + 3970, 4117, 4264, 4411, 4705, 4706, 4999, 5000, 5293, 5294, 5587, + 5588, 5881, 5882, 6175, 6176, 6469, 6470, 7057, 7058, 7351, 7352, + 7645, 7646, 7939, 7940, 8233, 8234, 8527, 8528, 8821, 8822, 9409, + 9410, 9703, 9704, 9997, 9998, 10291, 10292, 10585, 10586, 10879, + 10880, 11173, 11174, 11761, 11762, 12055, 12056, 12349, 12350, 12643, + 12937, 12938, 13231, 13232, 13525, 13526, 14112 }, + { 1, 150, 299, 448, 597, 746, 895, 1193, 1342, 1491, 1640, 1789, 1938, + 2087, 2385, 2534, 2683, 2832, 2981, 3130, 3279, 3577, 3726, 3875, + 4024, 4173, 4322, 4471, 4769, 4770, 5067, 5068, 5365, 5366, 5663, + 5664, 5961, 5962, 6259, 6260, 6557, 6558, 7153, 7154, 7451, 7452, + 7749, 7750, 8047, 8048, 8345, 8346, 8643, 8644, 8941, 8942, 9537, + 9538, 9835, 9836, 10133, 10134, 10431, 10432, 10729, 10730, 11027, + 11028, 11325, 11326, 11921, 11922, 12219, 12220, 12517, 12518, 12815, + 13113, 13114, 13411, 13412, 13709, 13710, 14304 }, + { 1, 152, 303, 454, 605, 756, 907, 1209, 1360, 1511, 1662, 1813, 1964, + 2115, 2417, 2568, 2719, 2870, 3021, 3172, 3323, 3625, 3776, 3927, + 4078, 4229, 4380, 4531, 4833, 4834, 5135, 5136, 5437, 5438, 5739, + 5740, 6041, 6042, 6343, 6344, 6645, 6646, 7249, 7250, 7551, 7552, + 7853, 7854, 8155, 8156, 8457, 8458, 8759, 8760, 9061, 9062, 9665, + 9666, 9967, 9968, 10269, 10270, 10571, 10572, 10873, 10874, 11175, + 11176, 11477, 11478, 12081, 12082, 12383, 12384, 12685, 12686, 12987, + 13289, 13290, 13591, 13592, 13893, 13894, 14496 }, + { 1, 154, 307, 460, 613, 766, 919, 1225, 1378, 1531, 1684, 1837, 1990, + 2143, 2449, 2602, 2755, 2908, 3061, 3214, 3367, 3673, 3826, 3979, + 4132, 4285, 4438, 4591, 4897, 4898, 5203, 5204, 5509, 5510, 5815, + 5816, 6121, 6122, 6427, 6428, 6733, 6734, 7345, 7346, 7651, 7652, + 7957, 7958, 8263, 8264, 8569, 8570, 8875, 8876, 9181, 9182, 9793, + 9794, 10099, 10100, 10405, 10406, 10711, 10712, 11017, 11018, 11323, + 11324, 11629, 11630, 12241, 12242, 12547, 12548, 12853, 12854, 13159, + 13465, 13466, 13771, 13772, 14077, 14078, 14688 }, + { 1, 156, 311, 466, 621, 776, 931, 1241, 1396, 1551, 1706, 1861, 2016, + 2171, 2481, 2636, 2791, 2946, 3101, 3256, 3411, 3721, 3876, 4031, + 4186, 4341, 4496, 4651, 4961, 4962, 5271, 5272, 5581, 5582, 5891, + 5892, 6201, 6202, 6511, 6512, 6821, 6822, 7441, 7442, 7751, 7752, + 8061, 8062, 8371, 8372, 8681, 8682, 8991, 8992, 9301, 9302, 9921, + 9922, 10231, 10232, 10541, 10542, 10851, 10852, 11161, 11162, 11471, + 11472, 11781, 11782, 12401, 12402, 12711, 12712, 13021, 13022, 13331, + 13641, 13642, 13951, 13952, 14261, 14262, 14880 }, + { 1, 158, 315, 472, 629, 786, 943, 1257, 1414, 1571, 1728, 1885, 2042, + 2199, 2513, 2670, 2827, 2984, 3141, 3298, 3455, 3769, 3926, 4083, + 4240, 4397, 4554, 4711, 5025, 5026, 5339, 5340, 5653, 5654, 5967, + 5968, 6281, 6282, 6595, 6596, 6909, 6910, 7537, 7538, 7851, 7852, + 8165, 8166, 8479, 8480, 8793, 8794, 9107, 9108, 9421, 9422, 10049, + 10050, 10363, 10364, 10677, 10678, 10991, 10992, 11305, 11306, 11619, + 11620, 11933, 11934, 12561, 12562, 12875, 12876, 13189, 13190, 13503, + 13817, 13818, 14131, 14132, 14445, 14446, 15072 }, + { 1, 160, 319, 478, 637, 796, 955, 1273, 1432, 1591, 1750, 1909, 2068, + 2227, 2545, 2704, 2863, 3022, 3181, 3340, 3499, 3817, 3976, 4135, + 4294, 4453, 4612, 4771, 5089, 5090, 5407, 5408, 5725, 5726, 6043, + 6044, 6361, 6362, 6679, 6680, 6997, 6998, 7633, 7634, 7951, 7952, + 8269, 8270, 8587, 8588, 8905, 8906, 9223, 9224, 9541, 9542, 10177, + 10178, 10495, 10496, 10813, 10814, 11131, 11132, 11449, 11450, 11767, + 11768, 12085, 12086, 12721, 12722, 13039, 13040, 13357, 13358, 13675, + 13993, 13994, 14311, 14312, 14629, 14630, 15264 }, + { 1, 162, 323, 484, 645, 806, 967, 1289, 1450, 1611, 1772, 1933, 2094, + 2255, 2577, 2738, 2899, 3060, 3221, 3382, 3543, 3865, 4026, 4187, + 4348, 4509, 4670, 4831, 5153, 5154, 5475, 5476, 5797, 5798, 6119, + 6120, 6441, 6442, 6763, 6764, 7085, 7086, 7729, 7730, 8051, 8052, + 8373, 8374, 8695, 8696, 9017, 9018, 9339, 9340, 9661, 9662, 10305, + 10306, 10627, 10628, 10949, 10950, 11271, 11272, 11593, 11594, 11915, + 11916, 12237, 12238, 12881, 12882, 13203, 13204, 13525, 13526, 13847, + 14169, 14170, 14491, 14492, 14813, 14814, 15456 }, + { 1, 164, 327, 490, 653, 816, 979, 1305, 1468, 1631, 1794, 1957, 2120, + 2283, 2609, 2772, 2935, 3098, 3261, 3424, 3587, 3913, 4076, 4239, + 4402, 4565, 4728, 4891, 5217, 5218, 5543, 5544, 5869, 5870, 6195, + 6196, 6521, 6522, 6847, 6848, 7173, 7174, 7825, 7826, 8151, 8152, + 8477, 8478, 8803, 8804, 9129, 9130, 9455, 9456, 9781, 9782, 10433, + 10434, 10759, 10760, 11085, 11086, 11411, 11412, 11737, 11738, 12063, + 12064, 12389, 12390, 13041, 13042, 13367, 13368, 13693, 13694, 14019, + 14345, 14346, 14671, 14672, 14997, 14998, 15648 }, + { 1, 166, 331, 496, 661, 826, 991, 1321, 1486, 1651, 1816, 1981, 2146, + 2311, 2641, 2806, 2971, 3136, 3301, 3466, 3631, 3961, 4126, 4291, + 4456, 4621, 4786, 4951, 5281, 5282, 5611, 5612, 5941, 5942, 6271, + 6272, 6601, 6602, 6931, 6932, 7261, 7262, 7921, 7922, 8251, 8252, + 8581, 8582, 8911, 8912, 9241, 9242, 9571, 9572, 9901, 9902, 10561, + 10562, 10891, 10892, 11221, 11222, 11551, 11552, 11881, 11882, 12211, + 12212, 12541, 12542, 13201, 13202, 13531, 13532, 13861, 13862, 14191, + 14521, 14522, 14851, 14852, 15181, 15182, 15840 }, + { 1, 168, 335, 502, 669, 836, 1003, 1337, 1504, 1671, 1838, 2005, 2172, + 2339, 2673, 2840, 3007, 3174, 3341, 3508, 3675, 4009, 4176, 4343, + 4510, 4677, 4844, 5011, 5345, 5346, 5679, 5680, 6013, 6014, 6347, + 6348, 6681, 6682, 7015, 7016, 7349, 7350, 8017, 8018, 8351, 8352, + 8685, 8686, 9019, 9020, 9353, 9354, 9687, 9688, 10021, 10022, 10689, + 10690, 11023, 11024, 11357, 11358, 11691, 11692, 12025, 12026, 12359, + 12360, 12693, 12694, 13361, 13362, 13695, 13696, 14029, 14030, 14363, + 14697, 14698, 15031, 15032, 15365, 15366, 16032 }, + { 1, 170, 339, 508, 677, 846, 1015, 1353, 1522, 1691, 1860, 2029, 2198, + 2367, 2705, 2874, 3043, 3212, 3381, 3550, 3719, 4057, 4226, 4395, + 4564, 4733, 4902, 5071, 5409, 5410, 5747, 5748, 6085, 6086, 6423, + 6424, 6761, 6762, 7099, 7100, 7437, 7438, 8113, 8114, 8451, 8452, + 8789, 8790, 9127, 9128, 9465, 9466, 9803, 9804, 10141, 10142, 10817, + 10818, 11155, 11156, 11493, 11494, 11831, 11832, 12169, 12170, 12507, + 12508, 12845, 12846, 13521, 13522, 13859, 13860, 14197, 14198, 14535, + 14873, 14874, 15211, 15212, 15549, 15550, 16224 }, + { 1, 172, 343, 514, 685, 856, 1027, 1369, 1540, 1711, 1882, 2053, 2224, + 2395, 2737, 2908, 3079, 3250, 3421, 3592, 3763, 4105, 4276, 4447, + 4618, 4789, 4960, 5131, 5473, 5474, 5815, 5816, 6157, 6158, 6499, + 6500, 6841, 6842, 7183, 7184, 7525, 7526, 8209, 8210, 8551, 8552, + 8893, 8894, 9235, 9236, 9577, 9578, 9919, 9920, 10261, 10262, 10945, + 10946, 11287, 11288, 11629, 11630, 11971, 11972, 12313, 12314, 12655, + 12656, 12997, 12998, 13681, 13682, 14023, 14024, 14365, 14366, 14707, + 15049, 15050, 15391, 15392, 15733, 15734, 16416 }, + { 1, 174, 347, 520, 693, 866, 1039, 1385, 1558, 1731, 1904, 2077, 2250, + 2423, 2769, 2942, 3115, 3288, 3461, 3634, 3807, 4153, 4326, 4499, + 4672, 4845, 5018, 5191, 5537, 5538, 5883, 5884, 6229, 6230, 6575, + 6576, 6921, 6922, 7267, 7268, 7613, 7614, 8305, 8306, 8651, 8652, + 8997, 8998, 9343, 9344, 9689, 9690, 10035, 10036, 10381, 10382, 11073, + 11074, 11419, 11420, 11765, 11766, 12111, 12112, 12457, 12458, 12803, + 12804, 13149, 13150, 13841, 13842, 14187, 14188, 14533, 14534, 14879, + 15225, 15226, 15571, 15572, 15917, 15918, 16608 }, + { 1, 176, 351, 526, 701, 876, 1051, 1401, 1576, 1751, 1926, 2101, 2276, + 2451, 2801, 2976, 3151, 3326, 3501, 3676, 3851, 4201, 4376, 4551, + 4726, 4901, 5076, 5251, 5601, 5602, 5951, 5952, 6301, 6302, 6651, + 6652, 7001, 7002, 7351, 7352, 7701, 7702, 8401, 8402, 8751, 8752, + 9101, 9102, 9451, 9452, 9801, 9802, 10151, 10152, 10501, 10502, 11201, + 11202, 11551, 11552, 11901, 11902, 12251, 12252, 12601, 12602, 12951, + 12952, 13301, 13302, 14001, 14002, 14351, 14352, 14701, 14702, 15051, + 15401, 15402, 15751, 15752, 16101, 16102, 16800 }, + { 1, 178, 355, 532, 709, 886, 1063, 1417, 1594, 1771, 1948, 2125, 2302, + 2479, 2833, 3010, 3187, 3364, 3541, 3718, 3895, 4249, 4426, 4603, + 4780, 4957, 5134, 5311, 5665, 5666, 6019, 6020, 6373, 6374, 6727, + 6728, 7081, 7082, 7435, 7436, 7789, 7790, 8497, 8498, 8851, 8852, + 9205, 9206, 9559, 9560, 9913, 9914, 10267, 10268, 10621, 10622, 11329, + 11330, 11683, 11684, 12037, 12038, 12391, 12392, 12745, 12746, 13099, + 13100, 13453, 13454, 14161, 14162, 14515, 14516, 14869, 14870, 15223, + 15577, 15578, 15931, 15932, 16285, 16286, 16992 }, + { 1, 180, 359, 538, 717, 896, 1075, 1433, 1612, 1791, 1970, 2149, 2328, + 2507, 2865, 3044, 3223, 3402, 3581, 3760, 3939, 4297, 4476, 4655, + 4834, 5013, 5192, 5371, 5729, 5730, 6087, 6088, 6445, 6446, 6803, + 6804, 7161, 7162, 7519, 7520, 7877, 7878, 8593, 8594, 8951, 8952, + 9309, 9310, 9667, 9668, 10025, 10026, 10383, 10384, 10741, 10742, + 11457, 11458, 11815, 11816, 12173, 12174, 12531, 12532, 12889, 12890, + 13247, 13248, 13605, 13606, 14321, 14322, 14679, 14680, 15037, 15038, + 15395, 15753, 15754, 16111, 16112, 16469, 16470, 17184 }, + { 1, 182, 363, 544, 725, 906, 1087, 1449, 1630, 1811, 1992, 2173, 2354, + 2535, 2897, 3078, 3259, 3440, 3621, 3802, 3983, 4345, 4526, 4707, + 4888, 5069, 5250, 5431, 5793, 5794, 6155, 6156, 6517, 6518, 6879, + 6880, 7241, 7242, 7603, 7604, 7965, 7966, 8689, 8690, 9051, 9052, + 9413, 9414, 9775, 9776, 10137, 10138, 10499, 10500, 10861, 10862, + 11585, 11586, 11947, 11948, 12309, 12310, 12671, 12672, 13033, 13034, + 13395, 13396, 13757, 13758, 14481, 14482, 14843, 14844, 15205, 15206, + 15567, 15929, 15930, 16291, 16292, 16653, 16654, 17376 }, + { 1, 184, 367, 550, 733, 916, 1099, 1465, 1648, 1831, 2014, 2197, 2380, + 2563, 2929, 3112, 3295, 3478, 3661, 3844, 4027, 4393, 4576, 4759, + 4942, 5125, 5308, 5491, 5857, 5858, 6223, 6224, 6589, 6590, 6955, + 6956, 7321, 7322, 7687, 7688, 8053, 8054, 8785, 8786, 9151, 9152, + 9517, 9518, 9883, 9884, 10249, 10250, 10615, 10616, 10981, 10982, + 11713, 11714, 12079, 12080, 12445, 12446, 12811, 12812, 13177, 13178, + 13543, 13544, 13909, 13910, 14641, 14642, 15007, 15008, 15373, 15374, + 15739, 16105, 16106, 16471, 16472, 16837, 16838, 17568 }, + { 1, 186, 371, 556, 741, 926, 1111, 1481, 1666, 1851, 2036, 2221, 2406, + 2591, 2961, 3146, 3331, 3516, 3701, 3886, 4071, 4441, 4626, 4811, + 4996, 5181, 5366, 5551, 5921, 5922, 6291, 6292, 6661, 6662, 7031, + 7032, 7401, 7402, 7771, 7772, 8141, 8142, 8881, 8882, 9251, 9252, + 9621, 9622, 9991, 9992, 10361, 10362, 10731, 10732, 11101, 11102, + 11841, 11842, 12211, 12212, 12581, 12582, 12951, 12952, 13321, 13322, + 13691, 13692, 14061, 14062, 14801, 14802, 15171, 15172, 15541, 15542, + 15911, 16281, 16282, 16651, 16652, 17021, 17022, 17760 }, + { 1, 188, 375, 562, 749, 936, 1123, 1497, 1684, 1871, 2058, 2245, 2432, + 2619, 2993, 3180, 3367, 3554, 3741, 3928, 4115, 4489, 4676, 4863, + 5050, 5237, 5424, 5611, 5985, 5986, 6359, 6360, 6733, 6734, 7107, + 7108, 7481, 7482, 7855, 7856, 8229, 8230, 8977, 8978, 9351, 9352, + 9725, 9726, 10099, 10100, 10473, 10474, 10847, 10848, 11221, 11222, + 11969, 11970, 12343, 12344, 12717, 12718, 13091, 13092, 13465, 13466, + 13839, 13840, 14213, 14214, 14961, 14962, 15335, 15336, 15709, 15710, + 16083, 16457, 16458, 16831, 16832, 17205, 17206, 17952 }, + { 1, 190, 379, 568, 757, 946, 1135, 1513, 1702, 1891, 2080, 2269, 2458, + 2647, 3025, 3214, 3403, 3592, 3781, 3970, 4159, 4537, 4726, 4915, + 5104, 5293, 5482, 5671, 6049, 6050, 6427, 6428, 6805, 6806, 7183, + 7184, 7561, 7562, 7939, 7940, 8317, 8318, 9073, 9074, 9451, 9452, + 9829, 9830, 10207, 10208, 10585, 10586, 10963, 10964, 11341, 11342, + 12097, 12098, 12475, 12476, 12853, 12854, 13231, 13232, 13609, 13610, + 13987, 13988, 14365, 14366, 15121, 15122, 15499, 15500, 15877, 15878, + 16255, 16633, 16634, 17011, 17012, 17389, 17390, 18144 }, + { 1, 192, 383, 574, 765, 956, 1147, 1529, 1720, 1911, 2102, 2293, 2484, + 2675, 3057, 3248, 3439, 3630, 3821, 4012, 4203, 4585, 4776, 4967, + 5158, 5349, 5540, 5731, 6113, 6114, 6495, 6496, 6877, 6878, 7259, + 7260, 7641, 7642, 8023, 8024, 8405, 8406, 9169, 9170, 9551, 9552, + 9933, 9934, 10315, 10316, 10697, 10698, 11079, 11080, 11461, 11462, + 12225, 12226, 12607, 12608, 12989, 12990, 13371, 13372, 13753, 13754, + 14135, 14136, 14517, 14518, 15281, 15282, 15663, 15664, 16045, 16046, + 16427, 16809, 16810, 17191, 17192, 17573, 17574, 18336 }, + { 1, 194, 387, 580, 773, 966, 1159, 1545, 1738, 1931, 2124, 2317, 2510, + 2703, 3089, 3282, 3475, 3668, 3861, 4054, 4247, 4633, 4826, 5019, + 5212, 5405, 5598, 5791, 6177, 6178, 6563, 6564, 6949, 6950, 7335, + 7336, 7721, 7722, 8107, 8108, 8493, 8494, 9265, 9266, 9651, 9652, + 10037, 10038, 10423, 10424, 10809, 10810, 11195, 11196, 11581, 11582, + 12353, 12354, 12739, 12740, 13125, 13126, 13511, 13512, 13897, 13898, + 14283, 14284, 14669, 14670, 15441, 15442, 15827, 15828, 16213, 16214, + 16599, 16985, 16986, 17371, 17372, 17757, 17758, 18528 } +}; + +#endif diff --git a/drivers/bbdev/turbo_sw/rte_pmd_bbdev_turbo_sw_version.map b/drivers/bbdev/turbo_sw/rte_pmd_bbdev_turbo_sw_version.map new file mode 100644 index 0000000..a753031 --- /dev/null +++ b/drivers/bbdev/turbo_sw/rte_pmd_bbdev_turbo_sw_version.map @@ -0,0 +1,3 @@ +DPDK_17.11 { + local: *; +};