diff options
author | JP Abgrall <jpa@google.com> | 2014-02-10 20:23:42 -0800 |
---|---|---|
committer | JP Abgrall <jpa@google.com> | 2014-02-12 22:32:58 +0000 |
commit | aa5c5f3dbf05e6ceb406a8cb52b4da481fcaa1fd (patch) | |
tree | e368799b69c0bb2920e9b35090a7c192d6f7081c | |
parent | 511eca30a483e912c274e1d8ba3a0f8f081e2227 (diff) | |
download | libpcap-aa5c5f3dbf05e6ceb406a8cb52b4da481fcaa1fd.tar.gz |
Get libpcap 1.5.2+ to compile on Android.
Fix an incorrect mempcopy().
Pre-generate: scanner.c scanner.h grammar.c
bpf_filter.c (symlink) version.c version.h
Change-Id: I8d86864c2b4eabd96ce9b0013bd9f31807fb6efd
-rw-r--r-- | Android.mk | 22 | ||||
-rw-r--r-- | CleanSpec.mk | 49 | ||||
l--------- | bpf_filter.c | 1 | ||||
-rw-r--r-- | config.h | 338 | ||||
-rw-r--r-- | grammar.c | 3976 | ||||
-rw-r--r-- | pcap-linux.c | 2 | ||||
-rw-r--r-- | scanner.c | 4819 | ||||
-rw-r--r-- | scanner.h | 6 | ||||
-rw-r--r-- | tokdefs.h | 316 | ||||
-rw-r--r-- | version.c | 1 | ||||
-rw-r--r-- | version.h | 1 |
11 files changed, 9530 insertions, 1 deletions
diff --git a/Android.mk b/Android.mk new file mode 100644 index 00000000..2d82baff --- /dev/null +++ b/Android.mk @@ -0,0 +1,22 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +libpcap_PSRC = pcap-linux.c pcap-usb-linux.c pcap-can-linux.c pcap-netfilter-linux.c +libpcap_FSRC = fad-gifc.c +libpcap_CSRC = pcap.c inet.c gencode.c optimize.c nametoaddr.c etherent.c \ + savefile.c sf-pcap.c sf-pcap-ng.c pcap-common.c \ + bpf_image.c bpf_dump.c +libpcap_GENSRC = scanner.c grammar.c bpf_filter.c version.c + +libpcap_SRC = $(libpcap_PSRC) $(libpcap_FSRC) $(libpcap_CSRC) $(libpcap_GENSRC) + + +LOCAL_SRC_FILES:=\ + $(libpcap_SRC) + +LOCAL_CFLAGS:=-O2 -g +LOCAL_CFLAGS+=-DHAVE_CONFIG_H -D_U_="__attribute__((unused))" -Dlinux -D__GLIBC__ -D_GNU_SOURCE + +LOCAL_MODULE:= libpcap + +include $(BUILD_STATIC_LIBRARY) diff --git a/CleanSpec.mk b/CleanSpec.mk new file mode 100644 index 00000000..b84e1b65 --- /dev/null +++ b/CleanSpec.mk @@ -0,0 +1,49 @@ +# Copyright (C) 2007 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# If you don't need to do a full clean build but would like to touch +# a file or delete some intermediate files, add a clean step to the end +# of the list. These steps will only be run once, if they haven't been +# run before. +# +# E.g.: +# $(call add-clean-step, touch -c external/sqlite/sqlite3.h) +# $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates) +# +# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with +# files that are missing or have been moved. +# +# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory. +# Use $(OUT_DIR) to refer to the "out" directory. +# +# If you need to re-do something that's already mentioned, just copy +# the command and add it to the bottom of the list. E.g., if a change +# that you made last week required touching a file and a change you +# made today requires touching the same file, just copy the old +# touch step and add it to the end of the list. +# +# ************************************************ +# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST +# ************************************************ + +# For example: +#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates) +#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates) +#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f) +#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*) + +# ************************************************ +# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST +# ************************************************ diff --git a/bpf_filter.c b/bpf_filter.c new file mode 120000 index 00000000..0605488a --- /dev/null +++ b/bpf_filter.c @@ -0,0 +1 @@ +./bpf/net/bpf_filter.c
\ No newline at end of file diff --git a/config.h b/config.h new file mode 100644 index 00000000..fe9b8f8d --- /dev/null +++ b/config.h @@ -0,0 +1,338 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.in by autoheader. */ + +/* Enable optimizer debugging */ +/* #undef BDEBUG */ + +/* define if you have a cloning BPF device */ +/* #undef HAVE_CLONING_BPF */ + +/* define if you have the DAG API */ +/* #undef HAVE_DAG_API */ + +/* define if you have dag_get_erf_types() */ +/* #undef HAVE_DAG_GET_ERF_TYPES */ + +/* define if you have dag_get_stream_erf_types() */ +/* #undef HAVE_DAG_GET_STREAM_ERF_TYPES */ + +/* define if you have streams capable DAG API */ +/* #undef HAVE_DAG_STREAMS_API */ + +/* define if you have vdag_set_device_info() */ +/* #undef HAVE_DAG_VDAG */ + +/* Define to 1 if you have the declaration of `ether_hostton', and to 0 if you + don't. */ +/* #undef HAVE_DECL_ETHER_HOSTTON */ + +/* define if you have a /dev/dlpi */ +/* #undef HAVE_DEV_DLPI */ + +/* if passive_req_t primitive exists */ +/* #undef HAVE_DLPI_PASSIVE */ + +/* Define to 1 if you have the `ether_hostton' function. */ +/* #undef HAVE_ETHER_HOSTTON */ + +/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */ +#define HAVE_FSEEKO 1 + +/* on HP-UX 10.20 or later */ +/* #undef HAVE_HPUX10_20_OR_LATER */ + +/* on HP-UX 9.x */ +/* #undef HAVE_HPUX9 */ + +/* if ppa_info_t_dl_module_id exists */ +/* #undef HAVE_HP_PPA_INFO_T_DL_MODULE_ID_1 */ + +/* Define to 1 if you have the <inttypes.h> header file. */ +#define HAVE_INTTYPES_H 1 + +/* if libdlpi exists */ +/* #undef HAVE_LIBDLPI */ + +/* if libnl exists */ +/* #undef HAVE_LIBNL */ + +/* if libnl exists and is version 2.x */ +/* #undef HAVE_LIBNL_2_x */ + +/* if libnl exists and is version 3.x */ +/* #undef HAVE_LIBNL_3_x */ + +/* libnl has NLE_FAILURE */ +/* #undef HAVE_LIBNL_NLE */ + +/* libnl has new-style socket api */ +/* #undef HAVE_LIBNL_SOCKETS */ + +/* Define to 1 if you have the <limits.h> header file. */ +#define HAVE_LIMITS_H 1 + +/* Define to 1 if you have the <linux/compiler.h> header file. */ +/* #undef HAVE_LINUX_COMPILER_H */ + +/* Define to 1 if you have the <linux/ethtool.h> header file. */ +#define HAVE_LINUX_ETHTOOL_H 1 + +/* Define to 1 if you have the <linux/if_packet.h> header file. */ +#define HAVE_LINUX_IF_PACKET_H 1 + +/* Define to 1 if you have the <linux/net_tstamp.h> header file. */ +#define HAVE_LINUX_NET_TSTAMP_H 1 + +/* if tp_vlan_tci exists */ +#define HAVE_LINUX_TPACKET_AUXDATA_TP_VLAN_TCI 1 + +/* Define to 1 if you have the <linux/types.h> header file. */ +#define HAVE_LINUX_TYPES_H 1 + +/* Define to 1 if you have the <linux/usbdevice_fs.h> header file. */ +#define HAVE_LINUX_USBDEVICE_FS_H 1 + +/* Define to 1 if you have the <linux/wireless.h> header file. */ +#define HAVE_LINUX_WIRELESS_H 1 + +/* Define to 1 if you have the <memory.h> header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the <netinet/ether.h> header file. */ +#define HAVE_NETINET_ETHER_H 1 + +/* Define to 1 if you have the <netinet/if_ether.h> header file. */ +#define HAVE_NETINET_IF_ETHER_H 1 + +/* Define to 1 if you have the <netpacket/if_packet.h> header file. */ +/* #undef HAVE_NETPACKET_IF_PACKET_H */ + +/* Define to 1 if you have the <netpacket/packet.h> header file. */ +#define HAVE_NETPACKET_PACKET_H 1 + +/* Define to 1 if you have the <net/if_media.h> header file. */ +/* #undef HAVE_NET_IF_MEDIA_H */ + +/* Define to 1 if you have the <net/pfvar.h> header file. */ +/* #undef HAVE_NET_PFVAR_H */ + +/* if there's an os_proto.h for this platform, to use additional prototypes */ +/* #undef HAVE_OS_PROTO_H */ + +/* Define to 1 if you have the <paths.h> header file. */ +#define HAVE_PATHS_H 1 + +/* define if net/pfvar.h defines PF_NAT through PF_NORDR */ +/* #undef HAVE_PF_NAT_THROUGH_PF_NORDR */ + +/* define if you have a Septel API */ +/* #undef HAVE_SEPTEL_API */ + +/* define if you have Myricom SNF API */ +/* #undef HAVE_SNF_API */ + +/* Define to 1 if you have the `snprintf' function. */ +#define HAVE_SNPRINTF 1 + +/* if struct sockaddr has the sa_len member */ +/* #undef HAVE_SOCKADDR_SA_LEN */ + +/* if struct sockaddr_storage exists */ +#define HAVE_SOCKADDR_STORAGE 1 + +/* define if socklen_t is defined */ +#define HAVE_SOCKLEN_T 1 + +/* On solaris */ +/* #undef HAVE_SOLARIS */ + +/* Define to 1 if you have the <stdint.h> header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the `strerror' function. */ +#define HAVE_STRERROR 1 + +/* Define to 1 if you have the <strings.h> header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the `strlcpy' function. */ +/* #undef HAVE_STRLCPY */ + +/* Define to 1 if the system has the type `struct BPF_TIMEVAL'. */ +/* #undef HAVE_STRUCT_BPF_TIMEVAL */ + +/* Define to 1 if the system has the type `struct ether_addr'. */ +/* #undef HAVE_STRUCT_ETHER_ADDR */ + +/* Define to 1 if you have the <sys/bitypes.h> header file. */ +/* #undef HAVE_SYS_BITYPES_H */ + +/* Define to 1 if you have the <sys/bufmod.h> header file. */ +/* #undef HAVE_SYS_BUFMOD_H */ + +/* Define to 1 if you have the <sys/dlpi_ext.h> header file. */ +/* #undef HAVE_SYS_DLPI_EXT_H */ + +/* Define to 1 if you have the <sys/ioccom.h> header file. */ +/* #undef HAVE_SYS_IOCCOM_H */ + +/* Define to 1 if you have the <sys/sockio.h> header file. */ +/* #undef HAVE_SYS_SOCKIO_H */ + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* if if_packet.h has tpacket_stats defined */ +#define HAVE_TPACKET_STATS 1 + +/* Define to 1 if you have the <unistd.h> header file. */ +#define HAVE_UNISTD_H 1 + +/* if struct usbdevfs_ctrltransfer has bRequestType */ +#define HAVE_USBDEVFS_CTRLTRANSFER_BREQUESTTYPE 1 + +/* define if version.h is generated in the build procedure */ +#define HAVE_VERSION_H 1 + +/* Define to 1 if you have the `vsnprintf' function. */ +#define HAVE_VSNPRINTF 1 + +/* define if the system supports zerocopy BPF */ +/* #undef HAVE_ZEROCOPY_BPF */ + +/* define if your compiler has __attribute__ */ +#define HAVE___ATTRIBUTE__ 1 + +/* IPv6 */ +#define INET6 1 + +/* if unaligned access fails */ +/* #undef LBL_ALIGN */ + +/* path for device for USB sniffing */ +#define LINUX_USB_MON_DEV "/dev/usbmon" + +/* if we need a pcap_parse wrapper around yyparse */ +/* #undef NEED_YYPARSE_WRAPPER */ + +/* Define to 1 if netinet/ether.h declares `ether_hostton' */ +/* #undef NETINET_ETHER_H_DECLARES_ETHER_HOSTTON */ + +/* Define to 1 if netinet/if_ether.h declares `ether_hostton' */ +/* #undef NETINET_IF_ETHER_H_DECLARES_ETHER_HOSTTON */ + +/* do not use protochain */ +/* #undef NO_PROTOCHAIN */ + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "" + +/* /dev/dlpi directory */ +/* #undef PCAP_DEV_PREFIX */ + +/* target host supports Bluetooth sniffing */ +/* #undef PCAP_SUPPORT_BT */ + +/* target host supports CAN sniffing */ +#define PCAP_SUPPORT_CAN 1 + +/* target host supports canusb */ +/* #undef PCAP_SUPPORT_CANUSB */ + +/* support D-Bus sniffing */ +/* #undef PCAP_SUPPORT_DBUS */ + +/* target host supports netfilter sniffing */ +#define PCAP_SUPPORT_NETFILTER 1 + +/* target host supports USB sniffing */ +#define PCAP_SUPPORT_USB 1 + +/* include ACN support */ +/* #undef SITA */ + +/* if struct sockaddr_hci has hci_channel member */ +/* #undef SOCKADDR_HCI_HAS_HCI_CHANNEL */ + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Enable parser debugging */ +/* #undef YYDEBUG */ + +/* Enable large inode numbers on Mac OS X 10.5. */ +#ifndef _DARWIN_USE_64_BIT_INODE +# define _DARWIN_USE_64_BIT_INODE 1 +#endif + +/* Number of bits in a file offset, on hosts where this is settable. */ +/* #undef _FILE_OFFSET_BITS */ + +/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */ +/* #undef _LARGEFILE_SOURCE */ + +/* Define for large files, on AIX-style hosts. */ +/* #undef _LARGE_FILES */ + +/* define on AIX to get certain functions */ +/* #undef _SUN */ + +/* define if your compiler allows __attribute__((format)) without a warning */ +#define __ATTRIBUTE___FORMAT_OK 1 + +/* to handle Ultrix compilers that don't support const in prototypes */ +/* #undef const */ + +/* Define as token for inline if inlining supported */ +#define inline inline + +/* Define to `short' if int16_t not defined. */ +/* #undef int16_t */ + +/* Define to `int' if int32_t not defined. */ +/* #undef int32_t */ + +/* Define to `long long' if int64_t not defined. */ +/* #undef int64_t */ + +/* Define to `signed char' if int8_t not defined. */ +/* #undef int8_t */ + +/* on sinix */ +/* #undef sinix */ + +/* Define to `unsigned short' if u_int16_t not defined. */ +/* #undef u_int16_t */ + +/* Define to `unsigned int' if u_int32_t not defined. */ +/* #undef u_int32_t */ + +/* Define to `unsigned long long' if u_int64_t not defined. */ +/* #undef u_int64_t */ + +/* Define to `unsigned char' if u_int8_t not defined. */ +/* #undef u_int8_t */ diff --git a/grammar.c b/grammar.c new file mode 100644 index 00000000..ea3169c2 --- /dev/null +++ b/grammar.c @@ -0,0 +1,3976 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.5" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* Substitute the variable and function names. */ +#define yyparse pcap_parse +#define yylex pcap_lex +#define yyerror pcap_error +#define yylval pcap_lval +#define yychar pcap_char +#define yydebug pcap_debug +#define yynerrs pcap_nerrs + + +/* Copy the first part of user declarations. */ + +/* Line 268 of yacc.c */ +#line 1 "grammar.y" + +/* + * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that: (1) source code distributions + * retain the above copyright notice and this paragraph in its entirety, (2) + * distributions including binary code include the above copyright notice and + * this paragraph in its entirety in the documentation or other materials + * provided with the distribution, and (3) all advertising materials mentioning + * features or use of this software display the following acknowledgement: + * ``This product includes software developed by the University of California, + * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of + * the University 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 ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + */ +#ifndef lint +static const char rcsid[] _U_ = + "@(#) $Header: /tcpdump/master/libpcap/grammar.y,v 1.101 2007-11-18 02:03:52 guy Exp $ (LBL)"; +#endif + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef WIN32 +#include <pcap-stdinc.h> +#else /* WIN32 */ +#include <sys/types.h> +#include <sys/socket.h> +#endif /* WIN32 */ + +#include <stdlib.h> + +#ifndef WIN32 +#if __STDC__ +struct mbuf; +struct rtentry; +#endif + +#include <netinet/in.h> +#include <arpa/inet.h> +#endif /* WIN32 */ + +#include <stdio.h> + +#include "pcap-int.h" + +#include "gencode.h" +#ifdef HAVE_NET_PFVAR_H +#include <net/if.h> +#include <net/pfvar.h> +#include <net/if_pflog.h> +#endif +#include "ieee80211.h" +#include <pcap/namedb.h> + +#ifdef HAVE_OS_PROTO_H +#include "os-proto.h" +#endif + +#define QSET(q, p, d, a) (q).proto = (p),\ + (q).dir = (d),\ + (q).addr = (a) + +struct tok { + int v; /* value */ + const char *s; /* string */ +}; + +static const struct tok ieee80211_types[] = { + { IEEE80211_FC0_TYPE_DATA, "data" }, + { IEEE80211_FC0_TYPE_MGT, "mgt" }, + { IEEE80211_FC0_TYPE_MGT, "management" }, + { IEEE80211_FC0_TYPE_CTL, "ctl" }, + { IEEE80211_FC0_TYPE_CTL, "control" }, + { 0, NULL } +}; +static const struct tok ieee80211_mgt_subtypes[] = { + { IEEE80211_FC0_SUBTYPE_ASSOC_REQ, "assocreq" }, + { IEEE80211_FC0_SUBTYPE_ASSOC_REQ, "assoc-req" }, + { IEEE80211_FC0_SUBTYPE_ASSOC_RESP, "assocresp" }, + { IEEE80211_FC0_SUBTYPE_ASSOC_RESP, "assoc-resp" }, + { IEEE80211_FC0_SUBTYPE_REASSOC_REQ, "reassocreq" }, + { IEEE80211_FC0_SUBTYPE_REASSOC_REQ, "reassoc-req" }, + { IEEE80211_FC0_SUBTYPE_REASSOC_RESP, "reassocresp" }, + { IEEE80211_FC0_SUBTYPE_REASSOC_RESP, "reassoc-resp" }, + { IEEE80211_FC0_SUBTYPE_PROBE_REQ, "probereq" }, + { IEEE80211_FC0_SUBTYPE_PROBE_REQ, "probe-req" }, + { IEEE80211_FC0_SUBTYPE_PROBE_RESP, "proberesp" }, + { IEEE80211_FC0_SUBTYPE_PROBE_RESP, "probe-resp" }, + { IEEE80211_FC0_SUBTYPE_BEACON, "beacon" }, + { IEEE80211_FC0_SUBTYPE_ATIM, "atim" }, + { IEEE80211_FC0_SUBTYPE_DISASSOC, "disassoc" }, + { IEEE80211_FC0_SUBTYPE_DISASSOC, "disassociation" }, + { IEEE80211_FC0_SUBTYPE_AUTH, "auth" }, + { IEEE80211_FC0_SUBTYPE_AUTH, "authentication" }, + { IEEE80211_FC0_SUBTYPE_DEAUTH, "deauth" }, + { IEEE80211_FC0_SUBTYPE_DEAUTH, "deauthentication" }, + { 0, NULL } +}; +static const struct tok ieee80211_ctl_subtypes[] = { + { IEEE80211_FC0_SUBTYPE_PS_POLL, "ps-poll" }, + { IEEE80211_FC0_SUBTYPE_RTS, "rts" }, + { IEEE80211_FC0_SUBTYPE_CTS, "cts" }, + { IEEE80211_FC0_SUBTYPE_ACK, "ack" }, + { IEEE80211_FC0_SUBTYPE_CF_END, "cf-end" }, + { IEEE80211_FC0_SUBTYPE_CF_END_ACK, "cf-end-ack" }, + { 0, NULL } +}; +static const struct tok ieee80211_data_subtypes[] = { + { IEEE80211_FC0_SUBTYPE_DATA, "data" }, + { IEEE80211_FC0_SUBTYPE_CF_ACK, "data-cf-ack" }, + { IEEE80211_FC0_SUBTYPE_CF_POLL, "data-cf-poll" }, + { IEEE80211_FC0_SUBTYPE_CF_ACPL, "data-cf-ack-poll" }, + { IEEE80211_FC0_SUBTYPE_NODATA, "null" }, + { IEEE80211_FC0_SUBTYPE_NODATA_CF_ACK, "cf-ack" }, + { IEEE80211_FC0_SUBTYPE_NODATA_CF_POLL, "cf-poll" }, + { IEEE80211_FC0_SUBTYPE_NODATA_CF_ACPL, "cf-ack-poll" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_DATA, "qos-data" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_CF_ACK, "qos-data-cf-ack" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_CF_POLL, "qos-data-cf-poll" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_CF_ACPL, "qos-data-cf-ack-poll" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA, "qos" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA_CF_POLL, "qos-cf-poll" }, + { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA_CF_ACPL, "qos-cf-ack-poll" }, + { 0, NULL } +}; +struct type2tok { + int type; + const struct tok *tok; +}; +static const struct type2tok ieee80211_type_subtypes[] = { + { IEEE80211_FC0_TYPE_MGT, ieee80211_mgt_subtypes }, + { IEEE80211_FC0_TYPE_CTL, ieee80211_ctl_subtypes }, + { IEEE80211_FC0_TYPE_DATA, ieee80211_data_subtypes }, + { 0, NULL } +}; + +static int +str2tok(const char *str, const struct tok *toks) +{ + int i; + + for (i = 0; toks[i].s != NULL; i++) { + if (pcap_strcasecmp(toks[i].s, str) == 0) + return (toks[i].v); + } + return (-1); +} + +int n_errors = 0; + +static struct qual qerr = { Q_UNDEF, Q_UNDEF, Q_UNDEF, Q_UNDEF }; + +static void +yyerror(const char *msg) +{ + ++n_errors; + bpf_error("%s", msg); + /* NOTREACHED */ +} + +#ifdef NEED_YYPARSE_WRAPPER +int yyparse(void); + +int +pcap_parse() +{ + return (yyparse()); +} +#endif + +#ifdef HAVE_NET_PFVAR_H +static int +pfreason_to_num(const char *reason) +{ + const char *reasons[] = PFRES_NAMES; + int i; + + for (i = 0; reasons[i]; i++) { + if (pcap_strcasecmp(reason, reasons[i]) == 0) + return (i); + } + bpf_error("unknown PF reason"); + /*NOTREACHED*/ +} + +static int +pfaction_to_num(const char *action) +{ + if (pcap_strcasecmp(action, "pass") == 0 || + pcap_strcasecmp(action, "accept") == 0) + return (PF_PASS); + else if (pcap_strcasecmp(action, "drop") == 0 || + pcap_strcasecmp(action, "block") == 0) + return (PF_DROP); +#if HAVE_PF_NAT_THROUGH_PF_NORDR + else if (pcap_strcasecmp(action, "rdr") == 0) + return (PF_RDR); + else if (pcap_strcasecmp(action, "nat") == 0) + return (PF_NAT); + else if (pcap_strcasecmp(action, "binat") == 0) + return (PF_BINAT); + else if (pcap_strcasecmp(action, "nordr") == 0) + return (PF_NORDR); +#endif + else { + bpf_error("unknown PF action"); + /*NOTREACHED*/ + } +} +#else /* !HAVE_NET_PFVAR_H */ +static int +pfreason_to_num(const char *reason) +{ + bpf_error("libpcap was compiled on a machine without pf support"); + /*NOTREACHED*/ + + /* this is to make the VC compiler happy */ + return -1; +} + +static int +pfaction_to_num(const char *action) +{ + bpf_error("libpcap was compiled on a machine without pf support"); + /*NOTREACHED*/ + + /* this is to make the VC compiler happy */ + return -1; +} +#endif /* HAVE_NET_PFVAR_H */ + + +/* Line 268 of yacc.c */ +#line 321 "y.tab.c" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + DST = 258, + SRC = 259, + HOST = 260, + GATEWAY = 261, + NET = 262, + NETMASK = 263, + PORT = 264, + PORTRANGE = 265, + LESS = 266, + GREATER = 267, + PROTO = 268, + PROTOCHAIN = 269, + CBYTE = 270, + ARP = 271, + RARP = 272, + IP = 273, + SCTP = 274, + TCP = 275, + UDP = 276, + ICMP = 277, + IGMP = 278, + IGRP = 279, + PIM = 280, + VRRP = 281, + CARP = 282, + ATALK = 283, + AARP = 284, + DECNET = 285, + LAT = 286, + SCA = 287, + MOPRC = 288, + MOPDL = 289, + TK_BROADCAST = 290, + TK_MULTICAST = 291, + NUM = 292, + INBOUND = 293, + OUTBOUND = 294, + PF_IFNAME = 295, + PF_RSET = 296, + PF_RNR = 297, + PF_SRNR = 298, + PF_REASON = 299, + PF_ACTION = 300, + TYPE = 301, + SUBTYPE = 302, + DIR = 303, + ADDR1 = 304, + ADDR2 = 305, + ADDR3 = 306, + ADDR4 = 307, + RA = 308, + TA = 309, + LINK = 310, + GEQ = 311, + LEQ = 312, + NEQ = 313, + ID = 314, + EID = 315, + HID = 316, + HID6 = 317, + AID = 318, + LSH = 319, + RSH = 320, + LEN = 321, + IPV6 = 322, + ICMPV6 = 323, + AH = 324, + ESP = 325, + VLAN = 326, + MPLS = 327, + PPPOED = 328, + PPPOES = 329, + ISO = 330, + ESIS = 331, + CLNP = 332, + ISIS = 333, + L1 = 334, + L2 = 335, + IIH = 336, + LSP = 337, + SNP = 338, + CSNP = 339, + PSNP = 340, + STP = 341, + IPX = 342, + NETBEUI = 343, + LANE = 344, + LLC = 345, + METAC = 346, + BCC = 347, + SC = 348, + ILMIC = 349, + OAMF4EC = 350, + OAMF4SC = 351, + OAM = 352, + OAMF4 = 353, + CONNECTMSG = 354, + METACONNECT = 355, + VPI = 356, + VCI = 357, + RADIO = 358, + FISU = 359, + LSSU = 360, + MSU = 361, + HFISU = 362, + HLSSU = 363, + HMSU = 364, + SIO = 365, + OPC = 366, + DPC = 367, + SLS = 368, + HSIO = 369, + HOPC = 370, + HDPC = 371, + HSLS = 372, + AND = 373, + OR = 374, + UMINUS = 375 + }; +#endif +/* Tokens. */ +#define DST 258 +#define SRC 259 +#define HOST 260 +#define GATEWAY 261 +#define NET 262 +#define NETMASK 263 +#define PORT 264 +#define PORTRANGE 265 +#define LESS 266 +#define GREATER 267 +#define PROTO 268 +#define PROTOCHAIN 269 +#define CBYTE 270 +#define ARP 271 +#define RARP 272 +#define IP 273 +#define SCTP 274 +#define TCP 275 +#define UDP 276 +#define ICMP 277 +#define IGMP 278 +#define IGRP 279 +#define PIM 280 +#define VRRP 281 +#define CARP 282 +#define ATALK 283 +#define AARP 284 +#define DECNET 285 +#define LAT 286 +#define SCA 287 +#define MOPRC 288 +#define MOPDL 289 +#define TK_BROADCAST 290 +#define TK_MULTICAST 291 +#define NUM 292 +#define INBOUND 293 +#define OUTBOUND 294 +#define PF_IFNAME 295 +#define PF_RSET 296 +#define PF_RNR 297 +#define PF_SRNR 298 +#define PF_REASON 299 +#define PF_ACTION 300 +#define TYPE 301 +#define SUBTYPE 302 +#define DIR 303 +#define ADDR1 304 +#define ADDR2 305 +#define ADDR3 306 +#define ADDR4 307 +#define RA 308 +#define TA 309 +#define LINK 310 +#define GEQ 311 +#define LEQ 312 +#define NEQ 313 +#define ID 314 +#define EID 315 +#define HID 316 +#define HID6 317 +#define AID 318 +#define LSH 319 +#define RSH 320 +#define LEN 321 +#define IPV6 322 +#define ICMPV6 323 +#define AH 324 +#define ESP 325 +#define VLAN 326 +#define MPLS 327 +#define PPPOED 328 +#define PPPOES 329 +#define ISO 330 +#define ESIS 331 +#define CLNP 332 +#define ISIS 333 +#define L1 334 +#define L2 335 +#define IIH 336 +#define LSP 337 +#define SNP 338 +#define CSNP 339 +#define PSNP 340 +#define STP 341 +#define IPX 342 +#define NETBEUI 343 +#define LANE 344 +#define LLC 345 +#define METAC 346 +#define BCC 347 +#define SC 348 +#define ILMIC 349 +#define OAMF4EC 350 +#define OAMF4SC 351 +#define OAM 352 +#define OAMF4 353 +#define CONNECTMSG 354 +#define METACONNECT 355 +#define VPI 356 +#define VCI 357 +#define RADIO 358 +#define FISU 359 +#define LSSU 360 +#define MSU 361 +#define HFISU 362 +#define HLSSU 363 +#define HMSU 364 +#define SIO 365 +#define OPC 366 +#define DPC 367 +#define SLS 368 +#define HSIO 369 +#define HOPC 370 +#define HDPC 371 +#define HSLS 372 +#define AND 373 +#define OR 374 +#define UMINUS 375 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ + +/* Line 293 of yacc.c */ +#line 242 "grammar.y" + + int i; + bpf_u_int32 h; + u_char *e; + char *s; + struct stmt *stmt; + struct arth *a; + struct { + struct qual q; + int atmfieldtype; + int mtp3fieldtype; + struct block *b; + } blk; + struct block *rblk; + + + +/* Line 293 of yacc.c */ +#line 615 "y.tab.c" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + + +/* Copy the second part of user declarations. */ + + +/* Line 343 of yacc.c */ +#line 627 "y.tab.c" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 3 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 710 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 136 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 46 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 213 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 285 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 375 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 120, 2, 2, 2, 2, 122, 2, + 129, 128, 125, 123, 2, 124, 2, 126, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 135, 2, + 132, 131, 130, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 133, 2, 134, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 121, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 127 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 6, 8, 9, 11, 15, 19, 23, + 27, 29, 31, 33, 35, 39, 41, 45, 49, 51, + 55, 57, 59, 61, 64, 66, 68, 70, 74, 78, + 80, 82, 84, 87, 91, 94, 97, 100, 103, 106, + 109, 113, 115, 119, 123, 125, 127, 129, 132, 134, + 137, 139, 140, 142, 144, 148, 152, 156, 160, 162, + 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, + 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, + 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, + 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, + 244, 246, 248, 250, 252, 254, 256, 258, 260, 263, + 266, 269, 272, 277, 279, 281, 284, 286, 289, 291, + 293, 296, 298, 300, 303, 306, 309, 312, 315, 318, + 321, 326, 329, 332, 335, 337, 339, 341, 343, 345, + 347, 349, 351, 353, 355, 357, 359, 361, 363, 365, + 367, 369, 371, 376, 383, 387, 391, 395, 399, 403, + 407, 411, 415, 418, 422, 424, 426, 428, 430, 432, + 434, 436, 440, 442, 444, 446, 448, 450, 452, 454, + 456, 458, 460, 462, 464, 466, 468, 470, 473, 476, + 480, 482, 484, 488, 490, 492, 494, 496, 498, 500, + 502, 504, 506, 508, 510, 512, 514, 516, 518, 521, + 524, 528, 530, 532 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 137, 0, -1, 138, 139, -1, 138, -1, -1, 148, + -1, 139, 140, 148, -1, 139, 140, 142, -1, 139, + 141, 148, -1, 139, 141, 142, -1, 118, -1, 119, + -1, 143, -1, 170, -1, 145, 146, 128, -1, 59, + -1, 61, 126, 37, -1, 61, 8, 61, -1, 61, + -1, 62, 126, 37, -1, 62, -1, 60, -1, 63, + -1, 144, 142, -1, 120, -1, 129, -1, 143, -1, + 147, 140, 142, -1, 147, 141, 142, -1, 170, -1, + 146, -1, 150, -1, 144, 148, -1, 151, 152, 153, + -1, 151, 152, -1, 151, 153, -1, 151, 13, -1, + 151, 14, -1, 151, 154, -1, 149, 142, -1, 145, + 139, 128, -1, 155, -1, 167, 165, 167, -1, 167, + 166, 167, -1, 156, -1, 171, -1, 172, -1, 173, + 174, -1, 177, -1, 178, 179, -1, 155, -1, -1, + 4, -1, 3, -1, 4, 119, 3, -1, 3, 119, + 4, -1, 4, 118, 3, -1, 3, 118, 4, -1, + 49, -1, 50, -1, 51, -1, 52, -1, 53, -1, + 54, -1, 5, -1, 7, -1, 9, -1, 10, -1, + 6, -1, 55, -1, 18, -1, 16, -1, 17, -1, + 19, -1, 20, -1, 21, -1, 22, -1, 23, -1, + 24, -1, 25, -1, 26, -1, 27, -1, 28, -1, + 29, -1, 30, -1, 31, -1, 32, -1, 34, -1, + 33, -1, 67, -1, 68, -1, 69, -1, 70, -1, + 75, -1, 76, -1, 78, -1, 79, -1, 80, -1, + 81, -1, 82, -1, 83, -1, 85, -1, 84, -1, + 77, -1, 86, -1, 87, -1, 88, -1, 103, -1, + 151, 35, -1, 151, 36, -1, 11, 37, -1, 12, + 37, -1, 15, 37, 169, 37, -1, 38, -1, 39, + -1, 71, 170, -1, 71, -1, 72, 170, -1, 72, + -1, 73, -1, 74, 170, -1, 74, -1, 157, -1, + 151, 158, -1, 40, 59, -1, 41, 59, -1, 42, + 37, -1, 43, 37, -1, 44, 163, -1, 45, 164, + -1, 46, 159, 47, 160, -1, 46, 159, -1, 47, + 161, -1, 48, 162, -1, 37, -1, 59, -1, 37, + -1, 59, -1, 59, -1, 37, -1, 59, -1, 37, + -1, 59, -1, 59, -1, 130, -1, 56, -1, 131, + -1, 57, -1, 132, -1, 58, -1, 170, -1, 168, + -1, 155, 133, 167, 134, -1, 155, 133, 167, 135, + 37, 134, -1, 167, 123, 167, -1, 167, 124, 167, + -1, 167, 125, 167, -1, 167, 126, 167, -1, 167, + 122, 167, -1, 167, 121, 167, -1, 167, 64, 167, + -1, 167, 65, 167, -1, 124, 167, -1, 145, 168, + 128, -1, 66, -1, 122, -1, 121, -1, 132, -1, + 130, -1, 131, -1, 37, -1, 145, 170, 128, -1, + 89, -1, 90, -1, 91, -1, 92, -1, 95, -1, + 96, -1, 93, -1, 94, -1, 97, -1, 98, -1, + 99, -1, 100, -1, 101, -1, 102, -1, 175, -1, + 165, 37, -1, 166, 37, -1, 145, 176, 128, -1, + 37, -1, 175, -1, 176, 141, 175, -1, 104, -1, + 105, -1, 106, -1, 107, -1, 108, -1, 109, -1, + 110, -1, 111, -1, 112, -1, 113, -1, 114, -1, + 115, -1, 116, -1, 117, -1, 180, -1, 165, 37, + -1, 166, 37, -1, 145, 181, 128, -1, 37, -1, + 180, -1, 181, 141, 180, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 316, 316, 320, 322, 324, 325, 326, 327, 328, + 330, 332, 334, 335, 337, 339, 340, 342, 344, 357, + 366, 375, 384, 393, 395, 397, 399, 400, 401, 403, + 405, 407, 408, 410, 411, 412, 413, 414, 415, 417, + 418, 419, 420, 422, 424, 425, 426, 427, 428, 429, + 432, 433, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 450, 451, 452, 453, 456, 458, + 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, + 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 516, 517, 518, 519, 520, 521, + 524, 529, 532, 536, 539, 540, 546, 547, 567, 583, + 584, 597, 598, 601, 604, 605, 606, 608, 609, 610, + 612, 613, 615, 616, 617, 618, 619, 620, 621, 622, + 623, 624, 625, 626, 627, 629, 630, 631, 632, 633, + 635, 636, 638, 639, 640, 641, 642, 643, 644, 645, + 647, 648, 649, 650, 653, 654, 656, 657, 658, 659, + 661, 668, 669, 672, 673, 674, 675, 676, 677, 680, + 681, 682, 683, 684, 685, 686, 687, 689, 690, 691, + 692, 694, 707, 708 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "DST", "SRC", "HOST", "GATEWAY", "NET", + "NETMASK", "PORT", "PORTRANGE", "LESS", "GREATER", "PROTO", "PROTOCHAIN", + "CBYTE", "ARP", "RARP", "IP", "SCTP", "TCP", "UDP", "ICMP", "IGMP", + "IGRP", "PIM", "VRRP", "CARP", "ATALK", "AARP", "DECNET", "LAT", "SCA", + "MOPRC", "MOPDL", "TK_BROADCAST", "TK_MULTICAST", "NUM", "INBOUND", + "OUTBOUND", "PF_IFNAME", "PF_RSET", "PF_RNR", "PF_SRNR", "PF_REASON", + "PF_ACTION", "TYPE", "SUBTYPE", "DIR", "ADDR1", "ADDR2", "ADDR3", + "ADDR4", "RA", "TA", "LINK", "GEQ", "LEQ", "NEQ", "ID", "EID", "HID", + "HID6", "AID", "LSH", "RSH", "LEN", "IPV6", "ICMPV6", "AH", "ESP", + "VLAN", "MPLS", "PPPOED", "PPPOES", "ISO", "ESIS", "CLNP", "ISIS", "L1", + "L2", "IIH", "LSP", "SNP", "CSNP", "PSNP", "STP", "IPX", "NETBEUI", + "LANE", "LLC", "METAC", "BCC", "SC", "ILMIC", "OAMF4EC", "OAMF4SC", + "OAM", "OAMF4", "CONNECTMSG", "METACONNECT", "VPI", "VCI", "RADIO", + "FISU", "LSSU", "MSU", "HFISU", "HLSSU", "HMSU", "SIO", "OPC", "DPC", + "SLS", "HSIO", "HOPC", "HDPC", "HSLS", "AND", "OR", "'!'", "'|'", "'&'", + "'+'", "'-'", "'*'", "'/'", "UMINUS", "')'", "'('", "'>'", "'='", "'<'", + "'['", "']'", "':'", "$accept", "prog", "null", "expr", "and", "or", + "id", "nid", "not", "paren", "pid", "qid", "term", "head", "rterm", + "pqual", "dqual", "aqual", "ndaqual", "pname", "other", "pfvar", + "p80211", "type", "subtype", "type_subtype", "dir", "reason", "action", + "relop", "irelop", "arth", "narth", "byteop", "pnum", "atmtype", + "atmmultitype", "atmfield", "atmvalue", "atmfieldvalue", "atmlistvalue", + "mtp2type", "mtp3field", "mtp3value", "mtp3fieldvalue", "mtp3listvalue", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 33, 124, 38, 43, 45, 42, 47, 375, 41, 40, + 62, 61, 60, 91, 93, 58 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 136, 137, 137, 138, 139, 139, 139, 139, 139, + 140, 141, 142, 142, 142, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 144, 145, 146, 146, 146, 147, + 147, 148, 148, 149, 149, 149, 149, 149, 149, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 151, 151, 152, 152, 152, 152, 152, 152, 152, 152, + 152, 152, 152, 152, 153, 153, 153, 153, 154, 155, + 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 155, 155, 155, 155, 156, 156, + 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, + 156, 156, 156, 156, 157, 157, 157, 157, 157, 157, + 158, 158, 158, 158, 159, 159, 160, 160, 161, 162, + 162, 163, 163, 164, 165, 165, 165, 166, 166, 166, + 167, 167, 168, 168, 168, 168, 168, 168, 168, 168, + 168, 168, 168, 168, 168, 169, 169, 169, 169, 169, + 170, 170, 171, 171, 171, 171, 171, 171, 171, 171, + 172, 172, 172, 172, 173, 173, 174, 174, 174, 174, + 175, 176, 176, 177, 177, 177, 177, 177, 177, 178, + 178, 178, 178, 178, 178, 178, 178, 179, 179, 179, + 179, 180, 181, 181 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 2, 1, 0, 1, 3, 3, 3, 3, + 1, 1, 1, 1, 3, 1, 3, 3, 1, 3, + 1, 1, 1, 2, 1, 1, 1, 3, 3, 1, + 1, 1, 2, 3, 2, 2, 2, 2, 2, 2, + 3, 1, 3, 3, 1, 1, 1, 2, 1, 2, + 1, 0, 1, 1, 3, 3, 3, 3, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, + 2, 2, 4, 1, 1, 2, 1, 2, 1, 1, + 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, + 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 4, 6, 3, 3, 3, 3, 3, 3, + 3, 3, 2, 3, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, + 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, + 3, 1, 1, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = +{ + 4, 0, 51, 1, 0, 0, 0, 71, 72, 70, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 88, 87, 170, 113, 114, 0, + 0, 0, 0, 0, 0, 69, 164, 89, 90, 91, + 92, 116, 118, 119, 121, 93, 94, 103, 95, 96, + 97, 98, 99, 100, 102, 101, 104, 105, 106, 172, + 173, 174, 175, 178, 179, 176, 177, 180, 181, 182, + 183, 184, 185, 107, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 24, 0, + 25, 2, 51, 51, 5, 0, 31, 0, 50, 44, + 122, 0, 151, 150, 45, 46, 0, 48, 0, 110, + 111, 0, 124, 125, 126, 127, 141, 142, 128, 143, + 129, 0, 115, 117, 120, 0, 0, 162, 10, 11, + 51, 51, 32, 0, 151, 150, 15, 21, 18, 20, + 22, 39, 12, 0, 0, 13, 53, 52, 64, 68, + 65, 66, 67, 36, 37, 108, 109, 0, 0, 0, + 58, 59, 60, 61, 62, 63, 34, 35, 38, 123, + 0, 145, 147, 149, 0, 0, 0, 0, 0, 0, + 0, 0, 144, 146, 148, 0, 0, 190, 0, 0, + 0, 47, 186, 211, 0, 0, 0, 49, 207, 166, + 165, 168, 169, 167, 0, 0, 0, 7, 51, 51, + 6, 150, 9, 8, 40, 163, 171, 0, 0, 0, + 23, 26, 30, 0, 29, 0, 0, 0, 0, 134, + 135, 131, 138, 132, 139, 140, 133, 33, 0, 160, + 161, 159, 158, 154, 155, 156, 157, 42, 43, 191, + 0, 187, 188, 212, 0, 208, 209, 112, 150, 17, + 16, 19, 14, 0, 0, 57, 55, 56, 54, 0, + 152, 0, 189, 0, 210, 0, 27, 28, 136, 137, + 130, 0, 192, 213, 153 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 1, 2, 133, 130, 131, 220, 142, 143, 125, + 222, 223, 94, 95, 96, 97, 166, 167, 168, 126, + 99, 100, 169, 231, 280, 233, 236, 118, 120, 185, + 186, 101, 102, 204, 103, 104, 105, 106, 191, 192, + 250, 107, 108, 197, 198, 254 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -208 +static const yytype_int16 yypact[] = +{ + -208, 20, 226, -208, -10, -3, 1, -208, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -208, -208, -28, + -15, 49, 68, -18, 62, -208, -208, -208, -208, -208, + -208, -26, -26, -208, -26, -208, -208, -208, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -208, -208, 570, + -208, -42, 456, 456, -208, 19, -208, 656, 12, -208, + -208, 153, -208, -208, -208, -208, 55, -208, 59, -208, + -208, -69, -208, -208, -208, -208, -208, -208, -208, -208, + -208, -26, -208, -208, -208, 570, -19, -208, -208, -208, + 341, 341, -208, -93, -1, 21, -208, -208, -6, 34, + -208, -208, -208, 19, 19, -208, -9, 6, -208, -208, + -208, -208, -208, -208, -208, -208, -208, -14, 74, -13, + -208, -208, -208, -208, -208, -208, 23, -208, -208, -208, + 570, -208, -208, -208, 570, 570, 570, 570, 570, 570, + 570, 570, -208, -208, -208, 570, 570, -208, 81, 134, + 139, -208, -208, -208, 140, 141, 142, -208, -208, -208, + -208, -208, -208, -208, 143, 21, 79, -208, 341, 341, + -208, 4, -208, -208, -208, -208, -208, 86, 144, 145, + -208, -208, 64, -42, 21, 179, 189, 191, 192, -208, + -208, 149, -208, -208, -208, -208, -208, -208, -51, 42, + 42, 99, 110, 33, 33, -208, -208, 79, 79, -208, + -61, -208, -208, -208, -59, -208, -208, -208, -64, -208, + -208, -208, -208, 19, 19, -208, -208, -208, -208, -8, + -208, 160, -208, 81, -208, 140, -208, -208, -208, -208, + -208, 65, -208, -208, -208 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -208, -208, -208, 196, -11, -207, -94, -122, 5, -2, + -208, -208, -82, -208, -208, -208, -208, 53, -208, 7, + -208, -208, -208, -208, -208, -208, -208, -208, -208, -91, + -40, -24, -75, -208, -36, -208, -208, -208, -208, -185, + -208, -208, -208, -208, -173, -208 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -42 +static const yytype_int16 yytable[] = +{ + 93, 141, 217, 249, -13, 122, 123, 92, 124, 98, + 132, 26, -41, 174, 175, 189, 264, 195, 134, 116, + 3, 253, 221, 229, 234, 128, 129, 109, 148, 278, + 150, 112, 151, 152, 110, 214, 207, 212, 111, 121, + 121, 117, 121, 273, 113, 230, 235, 275, 210, 213, + 134, 279, 199, 200, -29, -29, 26, 135, 129, 145, + 129, 201, 202, 203, 216, 127, 190, 272, 196, 274, + 176, 177, 178, 179, 180, 181, 128, 129, 136, 137, + 138, 139, 140, 270, 271, 205, 114, 221, 282, 135, + 93, 93, 187, 144, 211, 211, 193, 92, 92, 98, + 98, 206, 283, 90, 188, 115, 194, 145, 224, 225, + 226, 171, 172, 173, 170, 171, 172, 173, 187, 121, + 218, 119, -13, -13, 227, 228, 132, 215, 209, 209, + -41, -41, -13, 232, 134, 208, 208, 98, 98, 88, + -41, 144, 121, 174, 175, 170, 238, 259, 90, 216, + 239, 240, 241, 242, 243, 244, 245, 246, 180, 181, + 219, 247, 248, 174, 175, 178, 179, 180, 181, 276, + 277, 251, 211, 258, 174, 175, 252, 193, 255, 256, + 257, 260, 261, 265, 90, 182, 183, 184, 90, 182, + 183, 184, 262, 266, 267, 268, 269, 281, 91, 284, + 176, 177, 178, 179, 180, 181, 209, 93, 0, 171, + 172, 173, 263, 208, 208, 98, 98, 174, 175, 237, + 0, 177, 178, 179, 180, 181, -3, 145, 145, 0, + 0, 0, 0, 178, 179, 180, 181, 4, 5, 0, + 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 144, 144, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 0, 0, 176, 177, 178, 179, 180, 181, + 0, 35, 0, 182, 183, 184, 0, 0, 0, 0, + 0, 0, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 0, 0, 88, 0, 0, 0, + 89, 0, 4, 5, 0, 90, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, + 136, 137, 138, 139, 140, 0, 0, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 0, + 0, 88, 0, 0, 0, 89, 0, 4, 5, 0, + 90, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 0, 0, 88, 0, 0, 0, + 89, 0, 0, 0, 0, 90, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 36, 37, 38, 39, + 40, 0, 0, 0, 0, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 146, + 147, 148, 149, 150, 0, 151, 152, 0, 0, 153, + 154, 0, 0, 73, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 155, 156, 0, 89, 0, 0, 0, 0, 90, + 0, 0, 157, 158, 159, 160, 161, 162, 163, 164, + 165 +}; + +#define yypact_value_is_default(yystate) \ + ((yystate) == (-208)) + +#define yytable_value_is_error(yytable_value) \ + YYID (0) + +static const yytype_int16 yycheck[] = +{ + 2, 95, 8, 188, 0, 41, 42, 2, 44, 2, + 92, 37, 0, 64, 65, 106, 223, 108, 93, 37, + 0, 194, 144, 37, 37, 118, 119, 37, 5, 37, + 7, 59, 9, 10, 37, 128, 130, 131, 37, 41, + 42, 59, 44, 250, 59, 59, 59, 254, 130, 131, + 125, 59, 121, 122, 118, 119, 37, 93, 119, 95, + 119, 130, 131, 132, 128, 89, 106, 128, 108, 128, + 121, 122, 123, 124, 125, 126, 118, 119, 59, 60, + 61, 62, 63, 134, 135, 121, 37, 209, 273, 125, + 92, 93, 37, 95, 130, 131, 37, 92, 93, 92, + 93, 125, 275, 129, 106, 37, 108, 143, 144, 118, + 119, 56, 57, 58, 133, 56, 57, 58, 37, 121, + 126, 59, 118, 119, 118, 119, 208, 128, 130, 131, + 118, 119, 128, 59, 209, 130, 131, 130, 131, 120, + 128, 143, 144, 64, 65, 133, 170, 61, 129, 128, + 174, 175, 176, 177, 178, 179, 180, 181, 125, 126, + 126, 185, 186, 64, 65, 123, 124, 125, 126, 263, + 264, 37, 208, 209, 64, 65, 37, 37, 37, 37, + 37, 37, 37, 4, 129, 130, 131, 132, 129, 130, + 131, 132, 128, 4, 3, 3, 47, 37, 2, 134, + 121, 122, 123, 124, 125, 126, 208, 209, -1, 56, + 57, 58, 223, 208, 209, 208, 209, 64, 65, 166, + -1, 122, 123, 124, 125, 126, 0, 263, 264, -1, + -1, -1, -1, 123, 124, 125, 126, 11, 12, -1, + -1, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 263, 264, 37, 38, 39, 40, 41, 42, 43, + 44, 45, -1, -1, 121, 122, 123, 124, 125, 126, + -1, 55, -1, 130, 131, 132, -1, -1, -1, -1, + -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, -1, -1, 120, -1, -1, -1, + 124, -1, 11, 12, -1, 129, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, -1, -1, 37, 38, + 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 55, -1, -1, -1, + 59, 60, 61, 62, 63, -1, -1, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + -1, 120, -1, -1, -1, 124, -1, 11, 12, -1, + 129, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, -1, -1, 37, 38, 39, 40, 41, 42, 43, + 44, 45, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 55, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, -1, -1, 120, -1, -1, -1, + 124, -1, -1, -1, -1, 129, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, -1, -1, 37, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 55, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 66, 67, 68, 69, + 70, -1, -1, -1, -1, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 3, + 4, 5, 6, 7, -1, 9, 10, -1, -1, 13, + 14, -1, -1, 103, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 35, 36, -1, 124, -1, -1, -1, -1, 129, + -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 137, 138, 0, 11, 12, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 55, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 120, 124, + 129, 139, 144, 145, 148, 149, 150, 151, 155, 156, + 157, 167, 168, 170, 171, 172, 173, 177, 178, 37, + 37, 37, 59, 59, 37, 37, 37, 59, 163, 59, + 164, 145, 170, 170, 170, 145, 155, 167, 118, 119, + 140, 141, 148, 139, 168, 170, 59, 60, 61, 62, + 63, 142, 143, 144, 145, 170, 3, 4, 5, 6, + 7, 9, 10, 13, 14, 35, 36, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 152, 153, 154, 158, + 133, 56, 57, 58, 64, 65, 121, 122, 123, 124, + 125, 126, 130, 131, 132, 165, 166, 37, 145, 165, + 166, 174, 175, 37, 145, 165, 166, 179, 180, 121, + 122, 130, 131, 132, 169, 170, 167, 142, 144, 145, + 148, 170, 142, 148, 128, 128, 128, 8, 126, 126, + 142, 143, 146, 147, 170, 118, 119, 118, 119, 37, + 59, 159, 59, 161, 37, 59, 162, 153, 167, 167, + 167, 167, 167, 167, 167, 167, 167, 167, 167, 175, + 176, 37, 37, 180, 181, 37, 37, 37, 170, 61, + 37, 37, 128, 140, 141, 4, 4, 3, 3, 47, + 134, 135, 128, 141, 128, 141, 142, 142, 37, 59, + 160, 37, 175, 180, 134 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* This macro is provided for backward compatibility. */ + +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: + +/* Line 1806 of yacc.c */ +#line 317 "grammar.y" + { + finish_parse((yyvsp[(2) - (2)].blk).b); +} + break; + + case 4: + +/* Line 1806 of yacc.c */ +#line 322 "grammar.y" + { (yyval.blk).q = qerr; } + break; + + case 6: + +/* Line 1806 of yacc.c */ +#line 325 "grammar.y" + { gen_and((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 7: + +/* Line 1806 of yacc.c */ +#line 326 "grammar.y" + { gen_and((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 8: + +/* Line 1806 of yacc.c */ +#line 327 "grammar.y" + { gen_or((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 9: + +/* Line 1806 of yacc.c */ +#line 328 "grammar.y" + { gen_or((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 10: + +/* Line 1806 of yacc.c */ +#line 330 "grammar.y" + { (yyval.blk) = (yyvsp[(0) - (1)].blk); } + break; + + case 11: + +/* Line 1806 of yacc.c */ +#line 332 "grammar.y" + { (yyval.blk) = (yyvsp[(0) - (1)].blk); } + break; + + case 13: + +/* Line 1806 of yacc.c */ +#line 335 "grammar.y" + { (yyval.blk).b = gen_ncode(NULL, (bpf_u_int32)(yyvsp[(1) - (1)].i), + (yyval.blk).q = (yyvsp[(0) - (1)].blk).q); } + break; + + case 14: + +/* Line 1806 of yacc.c */ +#line 337 "grammar.y" + { (yyval.blk) = (yyvsp[(2) - (3)].blk); } + break; + + case 15: + +/* Line 1806 of yacc.c */ +#line 339 "grammar.y" + { (yyval.blk).b = gen_scode((yyvsp[(1) - (1)].s), (yyval.blk).q = (yyvsp[(0) - (1)].blk).q); } + break; + + case 16: + +/* Line 1806 of yacc.c */ +#line 340 "grammar.y" + { (yyval.blk).b = gen_mcode((yyvsp[(1) - (3)].s), NULL, (yyvsp[(3) - (3)].i), + (yyval.blk).q = (yyvsp[(0) - (3)].blk).q); } + break; + + case 17: + +/* Line 1806 of yacc.c */ +#line 342 "grammar.y" + { (yyval.blk).b = gen_mcode((yyvsp[(1) - (3)].s), (yyvsp[(3) - (3)].s), 0, + (yyval.blk).q = (yyvsp[(0) - (3)].blk).q); } + break; + + case 18: + +/* Line 1806 of yacc.c */ +#line 344 "grammar.y" + { + /* Decide how to parse HID based on proto */ + (yyval.blk).q = (yyvsp[(0) - (1)].blk).q; + if ((yyval.blk).q.addr == Q_PORT) + bpf_error("'port' modifier applied to ip host"); + else if ((yyval.blk).q.addr == Q_PORTRANGE) + bpf_error("'portrange' modifier applied to ip host"); + else if ((yyval.blk).q.addr == Q_PROTO) + bpf_error("'proto' modifier applied to ip host"); + else if ((yyval.blk).q.addr == Q_PROTOCHAIN) + bpf_error("'protochain' modifier applied to ip host"); + (yyval.blk).b = gen_ncode((yyvsp[(1) - (1)].s), 0, (yyval.blk).q); + } + break; + + case 19: + +/* Line 1806 of yacc.c */ +#line 357 "grammar.y" + { +#ifdef INET6 + (yyval.blk).b = gen_mcode6((yyvsp[(1) - (3)].s), NULL, (yyvsp[(3) - (3)].i), + (yyval.blk).q = (yyvsp[(0) - (3)].blk).q); +#else + bpf_error("'ip6addr/prefixlen' not supported " + "in this configuration"); +#endif /*INET6*/ + } + break; + + case 20: + +/* Line 1806 of yacc.c */ +#line 366 "grammar.y" + { +#ifdef INET6 + (yyval.blk).b = gen_mcode6((yyvsp[(1) - (1)].s), 0, 128, + (yyval.blk).q = (yyvsp[(0) - (1)].blk).q); +#else + bpf_error("'ip6addr' not supported " + "in this configuration"); +#endif /*INET6*/ + } + break; + + case 21: + +/* Line 1806 of yacc.c */ +#line 375 "grammar.y" + { + (yyval.blk).b = gen_ecode((yyvsp[(1) - (1)].e), (yyval.blk).q = (yyvsp[(0) - (1)].blk).q); + /* + * $1 was allocated by "pcap_ether_aton()", + * so we must free it now that we're done + * with it. + */ + free((yyvsp[(1) - (1)].e)); + } + break; + + case 22: + +/* Line 1806 of yacc.c */ +#line 384 "grammar.y" + { + (yyval.blk).b = gen_acode((yyvsp[(1) - (1)].e), (yyval.blk).q = (yyvsp[(0) - (1)].blk).q); + /* + * $1 was allocated by "pcap_ether_aton()", + * so we must free it now that we're done + * with it. + */ + free((yyvsp[(1) - (1)].e)); + } + break; + + case 23: + +/* Line 1806 of yacc.c */ +#line 393 "grammar.y" + { gen_not((yyvsp[(2) - (2)].blk).b); (yyval.blk) = (yyvsp[(2) - (2)].blk); } + break; + + case 24: + +/* Line 1806 of yacc.c */ +#line 395 "grammar.y" + { (yyval.blk) = (yyvsp[(0) - (1)].blk); } + break; + + case 25: + +/* Line 1806 of yacc.c */ +#line 397 "grammar.y" + { (yyval.blk) = (yyvsp[(0) - (1)].blk); } + break; + + case 27: + +/* Line 1806 of yacc.c */ +#line 400 "grammar.y" + { gen_and((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 28: + +/* Line 1806 of yacc.c */ +#line 401 "grammar.y" + { gen_or((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 29: + +/* Line 1806 of yacc.c */ +#line 403 "grammar.y" + { (yyval.blk).b = gen_ncode(NULL, (bpf_u_int32)(yyvsp[(1) - (1)].i), + (yyval.blk).q = (yyvsp[(0) - (1)].blk).q); } + break; + + case 32: + +/* Line 1806 of yacc.c */ +#line 408 "grammar.y" + { gen_not((yyvsp[(2) - (2)].blk).b); (yyval.blk) = (yyvsp[(2) - (2)].blk); } + break; + + case 33: + +/* Line 1806 of yacc.c */ +#line 410 "grammar.y" + { QSET((yyval.blk).q, (yyvsp[(1) - (3)].i), (yyvsp[(2) - (3)].i), (yyvsp[(3) - (3)].i)); } + break; + + case 34: + +/* Line 1806 of yacc.c */ +#line 411 "grammar.y" + { QSET((yyval.blk).q, (yyvsp[(1) - (2)].i), (yyvsp[(2) - (2)].i), Q_DEFAULT); } + break; + + case 35: + +/* Line 1806 of yacc.c */ +#line 412 "grammar.y" + { QSET((yyval.blk).q, (yyvsp[(1) - (2)].i), Q_DEFAULT, (yyvsp[(2) - (2)].i)); } + break; + + case 36: + +/* Line 1806 of yacc.c */ +#line 413 "grammar.y" + { QSET((yyval.blk).q, (yyvsp[(1) - (2)].i), Q_DEFAULT, Q_PROTO); } + break; + + case 37: + +/* Line 1806 of yacc.c */ +#line 414 "grammar.y" + { QSET((yyval.blk).q, (yyvsp[(1) - (2)].i), Q_DEFAULT, Q_PROTOCHAIN); } + break; + + case 38: + +/* Line 1806 of yacc.c */ +#line 415 "grammar.y" + { QSET((yyval.blk).q, (yyvsp[(1) - (2)].i), Q_DEFAULT, (yyvsp[(2) - (2)].i)); } + break; + + case 39: + +/* Line 1806 of yacc.c */ +#line 417 "grammar.y" + { (yyval.blk) = (yyvsp[(2) - (2)].blk); } + break; + + case 40: + +/* Line 1806 of yacc.c */ +#line 418 "grammar.y" + { (yyval.blk).b = (yyvsp[(2) - (3)].blk).b; (yyval.blk).q = (yyvsp[(1) - (3)].blk).q; } + break; + + case 41: + +/* Line 1806 of yacc.c */ +#line 419 "grammar.y" + { (yyval.blk).b = gen_proto_abbrev((yyvsp[(1) - (1)].i)); (yyval.blk).q = qerr; } + break; + + case 42: + +/* Line 1806 of yacc.c */ +#line 420 "grammar.y" + { (yyval.blk).b = gen_relation((yyvsp[(2) - (3)].i), (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a), 0); + (yyval.blk).q = qerr; } + break; + + case 43: + +/* Line 1806 of yacc.c */ +#line 422 "grammar.y" + { (yyval.blk).b = gen_relation((yyvsp[(2) - (3)].i), (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a), 1); + (yyval.blk).q = qerr; } + break; + + case 44: + +/* Line 1806 of yacc.c */ +#line 424 "grammar.y" + { (yyval.blk).b = (yyvsp[(1) - (1)].rblk); (yyval.blk).q = qerr; } + break; + + case 45: + +/* Line 1806 of yacc.c */ +#line 425 "grammar.y" + { (yyval.blk).b = gen_atmtype_abbrev((yyvsp[(1) - (1)].i)); (yyval.blk).q = qerr; } + break; + + case 46: + +/* Line 1806 of yacc.c */ +#line 426 "grammar.y" + { (yyval.blk).b = gen_atmmulti_abbrev((yyvsp[(1) - (1)].i)); (yyval.blk).q = qerr; } + break; + + case 47: + +/* Line 1806 of yacc.c */ +#line 427 "grammar.y" + { (yyval.blk).b = (yyvsp[(2) - (2)].blk).b; (yyval.blk).q = qerr; } + break; + + case 48: + +/* Line 1806 of yacc.c */ +#line 428 "grammar.y" + { (yyval.blk).b = gen_mtp2type_abbrev((yyvsp[(1) - (1)].i)); (yyval.blk).q = qerr; } + break; + + case 49: + +/* Line 1806 of yacc.c */ +#line 429 "grammar.y" + { (yyval.blk).b = (yyvsp[(2) - (2)].blk).b; (yyval.blk).q = qerr; } + break; + + case 51: + +/* Line 1806 of yacc.c */ +#line 433 "grammar.y" + { (yyval.i) = Q_DEFAULT; } + break; + + case 52: + +/* Line 1806 of yacc.c */ +#line 436 "grammar.y" + { (yyval.i) = Q_SRC; } + break; + + case 53: + +/* Line 1806 of yacc.c */ +#line 437 "grammar.y" + { (yyval.i) = Q_DST; } + break; + + case 54: + +/* Line 1806 of yacc.c */ +#line 438 "grammar.y" + { (yyval.i) = Q_OR; } + break; + + case 55: + +/* Line 1806 of yacc.c */ +#line 439 "grammar.y" + { (yyval.i) = Q_OR; } + break; + + case 56: + +/* Line 1806 of yacc.c */ +#line 440 "grammar.y" + { (yyval.i) = Q_AND; } + break; + + case 57: + +/* Line 1806 of yacc.c */ +#line 441 "grammar.y" + { (yyval.i) = Q_AND; } + break; + + case 58: + +/* Line 1806 of yacc.c */ +#line 442 "grammar.y" + { (yyval.i) = Q_ADDR1; } + break; + + case 59: + +/* Line 1806 of yacc.c */ +#line 443 "grammar.y" + { (yyval.i) = Q_ADDR2; } + break; + + case 60: + +/* Line 1806 of yacc.c */ +#line 444 "grammar.y" + { (yyval.i) = Q_ADDR3; } + break; + + case 61: + +/* Line 1806 of yacc.c */ +#line 445 "grammar.y" + { (yyval.i) = Q_ADDR4; } + break; + + case 62: + +/* Line 1806 of yacc.c */ +#line 446 "grammar.y" + { (yyval.i) = Q_RA; } + break; + + case 63: + +/* Line 1806 of yacc.c */ +#line 447 "grammar.y" + { (yyval.i) = Q_TA; } + break; + + case 64: + +/* Line 1806 of yacc.c */ +#line 450 "grammar.y" + { (yyval.i) = Q_HOST; } + break; + + case 65: + +/* Line 1806 of yacc.c */ +#line 451 "grammar.y" + { (yyval.i) = Q_NET; } + break; + + case 66: + +/* Line 1806 of yacc.c */ +#line 452 "grammar.y" + { (yyval.i) = Q_PORT; } + break; + + case 67: + +/* Line 1806 of yacc.c */ +#line 453 "grammar.y" + { (yyval.i) = Q_PORTRANGE; } + break; + + case 68: + +/* Line 1806 of yacc.c */ +#line 456 "grammar.y" + { (yyval.i) = Q_GATEWAY; } + break; + + case 69: + +/* Line 1806 of yacc.c */ +#line 458 "grammar.y" + { (yyval.i) = Q_LINK; } + break; + + case 70: + +/* Line 1806 of yacc.c */ +#line 459 "grammar.y" + { (yyval.i) = Q_IP; } + break; + + case 71: + +/* Line 1806 of yacc.c */ +#line 460 "grammar.y" + { (yyval.i) = Q_ARP; } + break; + + case 72: + +/* Line 1806 of yacc.c */ +#line 461 "grammar.y" + { (yyval.i) = Q_RARP; } + break; + + case 73: + +/* Line 1806 of yacc.c */ +#line 462 "grammar.y" + { (yyval.i) = Q_SCTP; } + break; + + case 74: + +/* Line 1806 of yacc.c */ +#line 463 "grammar.y" + { (yyval.i) = Q_TCP; } + break; + + case 75: + +/* Line 1806 of yacc.c */ +#line 464 "grammar.y" + { (yyval.i) = Q_UDP; } + break; + + case 76: + +/* Line 1806 of yacc.c */ +#line 465 "grammar.y" + { (yyval.i) = Q_ICMP; } + break; + + case 77: + +/* Line 1806 of yacc.c */ +#line 466 "grammar.y" + { (yyval.i) = Q_IGMP; } + break; + + case 78: + +/* Line 1806 of yacc.c */ +#line 467 "grammar.y" + { (yyval.i) = Q_IGRP; } + break; + + case 79: + +/* Line 1806 of yacc.c */ +#line 468 "grammar.y" + { (yyval.i) = Q_PIM; } + break; + + case 80: + +/* Line 1806 of yacc.c */ +#line 469 "grammar.y" + { (yyval.i) = Q_VRRP; } + break; + + case 81: + +/* Line 1806 of yacc.c */ +#line 470 "grammar.y" + { (yyval.i) = Q_CARP; } + break; + + case 82: + +/* Line 1806 of yacc.c */ +#line 471 "grammar.y" + { (yyval.i) = Q_ATALK; } + break; + + case 83: + +/* Line 1806 of yacc.c */ +#line 472 "grammar.y" + { (yyval.i) = Q_AARP; } + break; + + case 84: + +/* Line 1806 of yacc.c */ +#line 473 "grammar.y" + { (yyval.i) = Q_DECNET; } + break; + + case 85: + +/* Line 1806 of yacc.c */ +#line 474 "grammar.y" + { (yyval.i) = Q_LAT; } + break; + + case 86: + +/* Line 1806 of yacc.c */ +#line 475 "grammar.y" + { (yyval.i) = Q_SCA; } + break; + + case 87: + +/* Line 1806 of yacc.c */ +#line 476 "grammar.y" + { (yyval.i) = Q_MOPDL; } + break; + + case 88: + +/* Line 1806 of yacc.c */ +#line 477 "grammar.y" + { (yyval.i) = Q_MOPRC; } + break; + + case 89: + +/* Line 1806 of yacc.c */ +#line 478 "grammar.y" + { (yyval.i) = Q_IPV6; } + break; + + case 90: + +/* Line 1806 of yacc.c */ +#line 479 "grammar.y" + { (yyval.i) = Q_ICMPV6; } + break; + + case 91: + +/* Line 1806 of yacc.c */ +#line 480 "grammar.y" + { (yyval.i) = Q_AH; } + break; + + case 92: + +/* Line 1806 of yacc.c */ +#line 481 "grammar.y" + { (yyval.i) = Q_ESP; } + break; + + case 93: + +/* Line 1806 of yacc.c */ +#line 482 "grammar.y" + { (yyval.i) = Q_ISO; } + break; + + case 94: + +/* Line 1806 of yacc.c */ +#line 483 "grammar.y" + { (yyval.i) = Q_ESIS; } + break; + + case 95: + +/* Line 1806 of yacc.c */ +#line 484 "grammar.y" + { (yyval.i) = Q_ISIS; } + break; + + case 96: + +/* Line 1806 of yacc.c */ +#line 485 "grammar.y" + { (yyval.i) = Q_ISIS_L1; } + break; + + case 97: + +/* Line 1806 of yacc.c */ +#line 486 "grammar.y" + { (yyval.i) = Q_ISIS_L2; } + break; + + case 98: + +/* Line 1806 of yacc.c */ +#line 487 "grammar.y" + { (yyval.i) = Q_ISIS_IIH; } + break; + + case 99: + +/* Line 1806 of yacc.c */ +#line 488 "grammar.y" + { (yyval.i) = Q_ISIS_LSP; } + break; + + case 100: + +/* Line 1806 of yacc.c */ +#line 489 "grammar.y" + { (yyval.i) = Q_ISIS_SNP; } + break; + + case 101: + +/* Line 1806 of yacc.c */ +#line 490 "grammar.y" + { (yyval.i) = Q_ISIS_PSNP; } + break; + + case 102: + +/* Line 1806 of yacc.c */ +#line 491 "grammar.y" + { (yyval.i) = Q_ISIS_CSNP; } + break; + + case 103: + +/* Line 1806 of yacc.c */ +#line 492 "grammar.y" + { (yyval.i) = Q_CLNP; } + break; + + case 104: + +/* Line 1806 of yacc.c */ +#line 493 "grammar.y" + { (yyval.i) = Q_STP; } + break; + + case 105: + +/* Line 1806 of yacc.c */ +#line 494 "grammar.y" + { (yyval.i) = Q_IPX; } + break; + + case 106: + +/* Line 1806 of yacc.c */ +#line 495 "grammar.y" + { (yyval.i) = Q_NETBEUI; } + break; + + case 107: + +/* Line 1806 of yacc.c */ +#line 496 "grammar.y" + { (yyval.i) = Q_RADIO; } + break; + + case 108: + +/* Line 1806 of yacc.c */ +#line 498 "grammar.y" + { (yyval.rblk) = gen_broadcast((yyvsp[(1) - (2)].i)); } + break; + + case 109: + +/* Line 1806 of yacc.c */ +#line 499 "grammar.y" + { (yyval.rblk) = gen_multicast((yyvsp[(1) - (2)].i)); } + break; + + case 110: + +/* Line 1806 of yacc.c */ +#line 500 "grammar.y" + { (yyval.rblk) = gen_less((yyvsp[(2) - (2)].i)); } + break; + + case 111: + +/* Line 1806 of yacc.c */ +#line 501 "grammar.y" + { (yyval.rblk) = gen_greater((yyvsp[(2) - (2)].i)); } + break; + + case 112: + +/* Line 1806 of yacc.c */ +#line 502 "grammar.y" + { (yyval.rblk) = gen_byteop((yyvsp[(3) - (4)].i), (yyvsp[(2) - (4)].i), (yyvsp[(4) - (4)].i)); } + break; + + case 113: + +/* Line 1806 of yacc.c */ +#line 503 "grammar.y" + { (yyval.rblk) = gen_inbound(0); } + break; + + case 114: + +/* Line 1806 of yacc.c */ +#line 504 "grammar.y" + { (yyval.rblk) = gen_inbound(1); } + break; + + case 115: + +/* Line 1806 of yacc.c */ +#line 505 "grammar.y" + { (yyval.rblk) = gen_vlan((yyvsp[(2) - (2)].i)); } + break; + + case 116: + +/* Line 1806 of yacc.c */ +#line 506 "grammar.y" + { (yyval.rblk) = gen_vlan(-1); } + break; + + case 117: + +/* Line 1806 of yacc.c */ +#line 507 "grammar.y" + { (yyval.rblk) = gen_mpls((yyvsp[(2) - (2)].i)); } + break; + + case 118: + +/* Line 1806 of yacc.c */ +#line 508 "grammar.y" + { (yyval.rblk) = gen_mpls(-1); } + break; + + case 119: + +/* Line 1806 of yacc.c */ +#line 509 "grammar.y" + { (yyval.rblk) = gen_pppoed(); } + break; + + case 120: + +/* Line 1806 of yacc.c */ +#line 510 "grammar.y" + { (yyval.rblk) = gen_pppoes((yyvsp[(2) - (2)].i)); } + break; + + case 121: + +/* Line 1806 of yacc.c */ +#line 511 "grammar.y" + { (yyval.rblk) = gen_pppoes(-1); } + break; + + case 122: + +/* Line 1806 of yacc.c */ +#line 512 "grammar.y" + { (yyval.rblk) = (yyvsp[(1) - (1)].rblk); } + break; + + case 123: + +/* Line 1806 of yacc.c */ +#line 513 "grammar.y" + { (yyval.rblk) = (yyvsp[(2) - (2)].rblk); } + break; + + case 124: + +/* Line 1806 of yacc.c */ +#line 516 "grammar.y" + { (yyval.rblk) = gen_pf_ifname((yyvsp[(2) - (2)].s)); } + break; + + case 125: + +/* Line 1806 of yacc.c */ +#line 517 "grammar.y" + { (yyval.rblk) = gen_pf_ruleset((yyvsp[(2) - (2)].s)); } + break; + + case 126: + +/* Line 1806 of yacc.c */ +#line 518 "grammar.y" + { (yyval.rblk) = gen_pf_rnr((yyvsp[(2) - (2)].i)); } + break; + + case 127: + +/* Line 1806 of yacc.c */ +#line 519 "grammar.y" + { (yyval.rblk) = gen_pf_srnr((yyvsp[(2) - (2)].i)); } + break; + + case 128: + +/* Line 1806 of yacc.c */ +#line 520 "grammar.y" + { (yyval.rblk) = gen_pf_reason((yyvsp[(2) - (2)].i)); } + break; + + case 129: + +/* Line 1806 of yacc.c */ +#line 521 "grammar.y" + { (yyval.rblk) = gen_pf_action((yyvsp[(2) - (2)].i)); } + break; + + case 130: + +/* Line 1806 of yacc.c */ +#line 525 "grammar.y" + { (yyval.rblk) = gen_p80211_type((yyvsp[(2) - (4)].i) | (yyvsp[(4) - (4)].i), + IEEE80211_FC0_TYPE_MASK | + IEEE80211_FC0_SUBTYPE_MASK); + } + break; + + case 131: + +/* Line 1806 of yacc.c */ +#line 529 "grammar.y" + { (yyval.rblk) = gen_p80211_type((yyvsp[(2) - (2)].i), + IEEE80211_FC0_TYPE_MASK); + } + break; + + case 132: + +/* Line 1806 of yacc.c */ +#line 532 "grammar.y" + { (yyval.rblk) = gen_p80211_type((yyvsp[(2) - (2)].i), + IEEE80211_FC0_TYPE_MASK | + IEEE80211_FC0_SUBTYPE_MASK); + } + break; + + case 133: + +/* Line 1806 of yacc.c */ +#line 536 "grammar.y" + { (yyval.rblk) = gen_p80211_fcdir((yyvsp[(2) - (2)].i)); } + break; + + case 135: + +/* Line 1806 of yacc.c */ +#line 540 "grammar.y" + { (yyval.i) = str2tok((yyvsp[(1) - (1)].s), ieee80211_types); + if ((yyval.i) == -1) + bpf_error("unknown 802.11 type name"); + } + break; + + case 137: + +/* Line 1806 of yacc.c */ +#line 547 "grammar.y" + { const struct tok *types = NULL; + int i; + for (i = 0;; i++) { + if (ieee80211_type_subtypes[i].tok == NULL) { + /* Ran out of types */ + bpf_error("unknown 802.11 type"); + break; + } + if ((yyvsp[(-1) - (1)].i) == ieee80211_type_subtypes[i].type) { + types = ieee80211_type_subtypes[i].tok; + break; + } + } + + (yyval.i) = str2tok((yyvsp[(1) - (1)].s), types); + if ((yyval.i) == -1) + bpf_error("unknown 802.11 subtype name"); + } + break; + + case 138: + +/* Line 1806 of yacc.c */ +#line 567 "grammar.y" + { int i; + for (i = 0;; i++) { + if (ieee80211_type_subtypes[i].tok == NULL) { + /* Ran out of types */ + bpf_error("unknown 802.11 type name"); + break; + } + (yyval.i) = str2tok((yyvsp[(1) - (1)].s), ieee80211_type_subtypes[i].tok); + if ((yyval.i) != -1) { + (yyval.i) |= ieee80211_type_subtypes[i].type; + break; + } + } + } + break; + + case 140: + +/* Line 1806 of yacc.c */ +#line 584 "grammar.y" + { if (pcap_strcasecmp((yyvsp[(1) - (1)].s), "nods") == 0) + (yyval.i) = IEEE80211_FC1_DIR_NODS; + else if (pcap_strcasecmp((yyvsp[(1) - (1)].s), "tods") == 0) + (yyval.i) = IEEE80211_FC1_DIR_TODS; + else if (pcap_strcasecmp((yyvsp[(1) - (1)].s), "fromds") == 0) + (yyval.i) = IEEE80211_FC1_DIR_FROMDS; + else if (pcap_strcasecmp((yyvsp[(1) - (1)].s), "dstods") == 0) + (yyval.i) = IEEE80211_FC1_DIR_DSTODS; + else + bpf_error("unknown 802.11 direction"); + } + break; + + case 141: + +/* Line 1806 of yacc.c */ +#line 597 "grammar.y" + { (yyval.i) = (yyvsp[(1) - (1)].i); } + break; + + case 142: + +/* Line 1806 of yacc.c */ +#line 598 "grammar.y" + { (yyval.i) = pfreason_to_num((yyvsp[(1) - (1)].s)); } + break; + + case 143: + +/* Line 1806 of yacc.c */ +#line 601 "grammar.y" + { (yyval.i) = pfaction_to_num((yyvsp[(1) - (1)].s)); } + break; + + case 144: + +/* Line 1806 of yacc.c */ +#line 604 "grammar.y" + { (yyval.i) = BPF_JGT; } + break; + + case 145: + +/* Line 1806 of yacc.c */ +#line 605 "grammar.y" + { (yyval.i) = BPF_JGE; } + break; + + case 146: + +/* Line 1806 of yacc.c */ +#line 606 "grammar.y" + { (yyval.i) = BPF_JEQ; } + break; + + case 147: + +/* Line 1806 of yacc.c */ +#line 608 "grammar.y" + { (yyval.i) = BPF_JGT; } + break; + + case 148: + +/* Line 1806 of yacc.c */ +#line 609 "grammar.y" + { (yyval.i) = BPF_JGE; } + break; + + case 149: + +/* Line 1806 of yacc.c */ +#line 610 "grammar.y" + { (yyval.i) = BPF_JEQ; } + break; + + case 150: + +/* Line 1806 of yacc.c */ +#line 612 "grammar.y" + { (yyval.a) = gen_loadi((yyvsp[(1) - (1)].i)); } + break; + + case 152: + +/* Line 1806 of yacc.c */ +#line 615 "grammar.y" + { (yyval.a) = gen_load((yyvsp[(1) - (4)].i), (yyvsp[(3) - (4)].a), 1); } + break; + + case 153: + +/* Line 1806 of yacc.c */ +#line 616 "grammar.y" + { (yyval.a) = gen_load((yyvsp[(1) - (6)].i), (yyvsp[(3) - (6)].a), (yyvsp[(5) - (6)].i)); } + break; + + case 154: + +/* Line 1806 of yacc.c */ +#line 617 "grammar.y" + { (yyval.a) = gen_arth(BPF_ADD, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 155: + +/* Line 1806 of yacc.c */ +#line 618 "grammar.y" + { (yyval.a) = gen_arth(BPF_SUB, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 156: + +/* Line 1806 of yacc.c */ +#line 619 "grammar.y" + { (yyval.a) = gen_arth(BPF_MUL, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 157: + +/* Line 1806 of yacc.c */ +#line 620 "grammar.y" + { (yyval.a) = gen_arth(BPF_DIV, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 158: + +/* Line 1806 of yacc.c */ +#line 621 "grammar.y" + { (yyval.a) = gen_arth(BPF_AND, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 159: + +/* Line 1806 of yacc.c */ +#line 622 "grammar.y" + { (yyval.a) = gen_arth(BPF_OR, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 160: + +/* Line 1806 of yacc.c */ +#line 623 "grammar.y" + { (yyval.a) = gen_arth(BPF_LSH, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 161: + +/* Line 1806 of yacc.c */ +#line 624 "grammar.y" + { (yyval.a) = gen_arth(BPF_RSH, (yyvsp[(1) - (3)].a), (yyvsp[(3) - (3)].a)); } + break; + + case 162: + +/* Line 1806 of yacc.c */ +#line 625 "grammar.y" + { (yyval.a) = gen_neg((yyvsp[(2) - (2)].a)); } + break; + + case 163: + +/* Line 1806 of yacc.c */ +#line 626 "grammar.y" + { (yyval.a) = (yyvsp[(2) - (3)].a); } + break; + + case 164: + +/* Line 1806 of yacc.c */ +#line 627 "grammar.y" + { (yyval.a) = gen_loadlen(); } + break; + + case 165: + +/* Line 1806 of yacc.c */ +#line 629 "grammar.y" + { (yyval.i) = '&'; } + break; + + case 166: + +/* Line 1806 of yacc.c */ +#line 630 "grammar.y" + { (yyval.i) = '|'; } + break; + + case 167: + +/* Line 1806 of yacc.c */ +#line 631 "grammar.y" + { (yyval.i) = '<'; } + break; + + case 168: + +/* Line 1806 of yacc.c */ +#line 632 "grammar.y" + { (yyval.i) = '>'; } + break; + + case 169: + +/* Line 1806 of yacc.c */ +#line 633 "grammar.y" + { (yyval.i) = '='; } + break; + + case 171: + +/* Line 1806 of yacc.c */ +#line 636 "grammar.y" + { (yyval.i) = (yyvsp[(2) - (3)].i); } + break; + + case 172: + +/* Line 1806 of yacc.c */ +#line 638 "grammar.y" + { (yyval.i) = A_LANE; } + break; + + case 173: + +/* Line 1806 of yacc.c */ +#line 639 "grammar.y" + { (yyval.i) = A_LLC; } + break; + + case 174: + +/* Line 1806 of yacc.c */ +#line 640 "grammar.y" + { (yyval.i) = A_METAC; } + break; + + case 175: + +/* Line 1806 of yacc.c */ +#line 641 "grammar.y" + { (yyval.i) = A_BCC; } + break; + + case 176: + +/* Line 1806 of yacc.c */ +#line 642 "grammar.y" + { (yyval.i) = A_OAMF4EC; } + break; + + case 177: + +/* Line 1806 of yacc.c */ +#line 643 "grammar.y" + { (yyval.i) = A_OAMF4SC; } + break; + + case 178: + +/* Line 1806 of yacc.c */ +#line 644 "grammar.y" + { (yyval.i) = A_SC; } + break; + + case 179: + +/* Line 1806 of yacc.c */ +#line 645 "grammar.y" + { (yyval.i) = A_ILMIC; } + break; + + case 180: + +/* Line 1806 of yacc.c */ +#line 647 "grammar.y" + { (yyval.i) = A_OAM; } + break; + + case 181: + +/* Line 1806 of yacc.c */ +#line 648 "grammar.y" + { (yyval.i) = A_OAMF4; } + break; + + case 182: + +/* Line 1806 of yacc.c */ +#line 649 "grammar.y" + { (yyval.i) = A_CONNECTMSG; } + break; + + case 183: + +/* Line 1806 of yacc.c */ +#line 650 "grammar.y" + { (yyval.i) = A_METACONNECT; } + break; + + case 184: + +/* Line 1806 of yacc.c */ +#line 653 "grammar.y" + { (yyval.blk).atmfieldtype = A_VPI; } + break; + + case 185: + +/* Line 1806 of yacc.c */ +#line 654 "grammar.y" + { (yyval.blk).atmfieldtype = A_VCI; } + break; + + case 187: + +/* Line 1806 of yacc.c */ +#line 657 "grammar.y" + { (yyval.blk).b = gen_atmfield_code((yyvsp[(0) - (2)].blk).atmfieldtype, (bpf_int32)(yyvsp[(2) - (2)].i), (bpf_u_int32)(yyvsp[(1) - (2)].i), 0); } + break; + + case 188: + +/* Line 1806 of yacc.c */ +#line 658 "grammar.y" + { (yyval.blk).b = gen_atmfield_code((yyvsp[(0) - (2)].blk).atmfieldtype, (bpf_int32)(yyvsp[(2) - (2)].i), (bpf_u_int32)(yyvsp[(1) - (2)].i), 1); } + break; + + case 189: + +/* Line 1806 of yacc.c */ +#line 659 "grammar.y" + { (yyval.blk).b = (yyvsp[(2) - (3)].blk).b; (yyval.blk).q = qerr; } + break; + + case 190: + +/* Line 1806 of yacc.c */ +#line 661 "grammar.y" + { + (yyval.blk).atmfieldtype = (yyvsp[(0) - (1)].blk).atmfieldtype; + if ((yyval.blk).atmfieldtype == A_VPI || + (yyval.blk).atmfieldtype == A_VCI) + (yyval.blk).b = gen_atmfield_code((yyval.blk).atmfieldtype, (bpf_int32) (yyvsp[(1) - (1)].i), BPF_JEQ, 0); + } + break; + + case 192: + +/* Line 1806 of yacc.c */ +#line 669 "grammar.y" + { gen_or((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + case 193: + +/* Line 1806 of yacc.c */ +#line 672 "grammar.y" + { (yyval.i) = M_FISU; } + break; + + case 194: + +/* Line 1806 of yacc.c */ +#line 673 "grammar.y" + { (yyval.i) = M_LSSU; } + break; + + case 195: + +/* Line 1806 of yacc.c */ +#line 674 "grammar.y" + { (yyval.i) = M_MSU; } + break; + + case 196: + +/* Line 1806 of yacc.c */ +#line 675 "grammar.y" + { (yyval.i) = MH_FISU; } + break; + + case 197: + +/* Line 1806 of yacc.c */ +#line 676 "grammar.y" + { (yyval.i) = MH_LSSU; } + break; + + case 198: + +/* Line 1806 of yacc.c */ +#line 677 "grammar.y" + { (yyval.i) = MH_MSU; } + break; + + case 199: + +/* Line 1806 of yacc.c */ +#line 680 "grammar.y" + { (yyval.blk).mtp3fieldtype = M_SIO; } + break; + + case 200: + +/* Line 1806 of yacc.c */ +#line 681 "grammar.y" + { (yyval.blk).mtp3fieldtype = M_OPC; } + break; + + case 201: + +/* Line 1806 of yacc.c */ +#line 682 "grammar.y" + { (yyval.blk).mtp3fieldtype = M_DPC; } + break; + + case 202: + +/* Line 1806 of yacc.c */ +#line 683 "grammar.y" + { (yyval.blk).mtp3fieldtype = M_SLS; } + break; + + case 203: + +/* Line 1806 of yacc.c */ +#line 684 "grammar.y" + { (yyval.blk).mtp3fieldtype = MH_SIO; } + break; + + case 204: + +/* Line 1806 of yacc.c */ +#line 685 "grammar.y" + { (yyval.blk).mtp3fieldtype = MH_OPC; } + break; + + case 205: + +/* Line 1806 of yacc.c */ +#line 686 "grammar.y" + { (yyval.blk).mtp3fieldtype = MH_DPC; } + break; + + case 206: + +/* Line 1806 of yacc.c */ +#line 687 "grammar.y" + { (yyval.blk).mtp3fieldtype = MH_SLS; } + break; + + case 208: + +/* Line 1806 of yacc.c */ +#line 690 "grammar.y" + { (yyval.blk).b = gen_mtp3field_code((yyvsp[(0) - (2)].blk).mtp3fieldtype, (u_int)(yyvsp[(2) - (2)].i), (u_int)(yyvsp[(1) - (2)].i), 0); } + break; + + case 209: + +/* Line 1806 of yacc.c */ +#line 691 "grammar.y" + { (yyval.blk).b = gen_mtp3field_code((yyvsp[(0) - (2)].blk).mtp3fieldtype, (u_int)(yyvsp[(2) - (2)].i), (u_int)(yyvsp[(1) - (2)].i), 1); } + break; + + case 210: + +/* Line 1806 of yacc.c */ +#line 692 "grammar.y" + { (yyval.blk).b = (yyvsp[(2) - (3)].blk).b; (yyval.blk).q = qerr; } + break; + + case 211: + +/* Line 1806 of yacc.c */ +#line 694 "grammar.y" + { + (yyval.blk).mtp3fieldtype = (yyvsp[(0) - (1)].blk).mtp3fieldtype; + if ((yyval.blk).mtp3fieldtype == M_SIO || + (yyval.blk).mtp3fieldtype == M_OPC || + (yyval.blk).mtp3fieldtype == M_DPC || + (yyval.blk).mtp3fieldtype == M_SLS || + (yyval.blk).mtp3fieldtype == MH_SIO || + (yyval.blk).mtp3fieldtype == MH_OPC || + (yyval.blk).mtp3fieldtype == MH_DPC || + (yyval.blk).mtp3fieldtype == MH_SLS) + (yyval.blk).b = gen_mtp3field_code((yyval.blk).mtp3fieldtype, (u_int) (yyvsp[(1) - (1)].i), BPF_JEQ, 0); + } + break; + + case 213: + +/* Line 1806 of yacc.c */ +#line 708 "grammar.y" + { gen_or((yyvsp[(1) - (3)].blk).b, (yyvsp[(3) - (3)].blk).b); (yyval.blk) = (yyvsp[(3) - (3)].blk); } + break; + + + +/* Line 1806 of yacc.c */ +#line 3744 "y.tab.c" + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined(yyoverflow) || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + + +/* Line 2067 of yacc.c */ +#line 710 "grammar.y" + + diff --git a/pcap-linux.c b/pcap-linux.c index 17bd0f56..dc427353 100644 --- a/pcap-linux.c +++ b/pcap-linux.c @@ -5135,7 +5135,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device) ireq.ifr_ifrn.ifrn_name[sizeof ireq.ifr_ifrn.ifrn_name - 1] = 0; ireq.u.data.length = 1; /* 1 argument */ args[0] = 3; /* request Prism header */ - memcpy(ireq.u.name, args, IFNAMSIZ); + memcpy(ireq.u.name, args, sizeof (int)); if (ioctl(sock_fd, cmd, &ireq) != -1) { /* * Success. diff --git a/scanner.c b/scanner.c new file mode 100644 index 00000000..e9fc736d --- /dev/null +++ b/scanner.c @@ -0,0 +1,4819 @@ +#line 2 "scanner.c" + +#line 4 "scanner.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define yy_create_buffer pcap__create_buffer +#define yy_delete_buffer pcap__delete_buffer +#define yy_flex_debug pcap__flex_debug +#define yy_init_buffer pcap__init_buffer +#define yy_flush_buffer pcap__flush_buffer +#define yy_load_buffer_state pcap__load_buffer_state +#define yy_switch_to_buffer pcap__switch_to_buffer +#define yyin pcap_in +#define yyleng pcap_leng +#define yylex pcap_lex +#define yylineno pcap_lineno +#define yyout pcap_out +#define yyrestart pcap_restart +#define yytext pcap_text +#define yywrap pcap_wrap +#define yyalloc pcap_alloc +#define yyrealloc pcap_realloc +#define yyfree pcap_free + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 35 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <stdlib.h> + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include <inttypes.h> +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +#ifdef __cplusplus + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +/* C99 requires __STDC__ to be defined as 1. */ +#if defined (__STDC__) + +#define YY_USE_CONST + +#endif /* defined (__STDC__) */ +#endif /* ! __cplusplus */ + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE pcap_restart(pcap_in ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +extern int pcap_leng; + +extern FILE *pcap_in, *pcap_out; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up pcap_text. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up pcap_text again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via pcap_restart()), so that the user can continue scanning by + * just pointing pcap_in at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) + +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when pcap_text is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int pcap_leng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow pcap_wrap()'s to do buffer switches + * instead of setting up a fresh pcap_in. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void pcap_restart (FILE *input_file ); +void pcap__switch_to_buffer (YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE pcap__create_buffer (FILE *file,int size ); +void pcap__delete_buffer (YY_BUFFER_STATE b ); +void pcap__flush_buffer (YY_BUFFER_STATE b ); +void pcap_push_buffer_state (YY_BUFFER_STATE new_buffer ); +void pcap_pop_buffer_state (void ); + +static void pcap_ensure_buffer_stack (void ); +static void pcap__load_buffer_state (void ); +static void pcap__init_buffer (YY_BUFFER_STATE b,FILE *file ); + +#define YY_FLUSH_BUFFER pcap__flush_buffer(YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE pcap__scan_buffer (char *base,yy_size_t size ); +YY_BUFFER_STATE pcap__scan_string (yyconst char *yy_str ); +YY_BUFFER_STATE pcap__scan_bytes (yyconst char *bytes,int len ); + +void *pcap_alloc (yy_size_t ); +void *pcap_realloc (void *,yy_size_t ); +void pcap_free (void * ); + +#define yy_new_buffer pcap__create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + pcap_ensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + pcap__create_buffer(pcap_in,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + pcap_ensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + pcap__create_buffer(pcap_in,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +typedef unsigned char YY_CHAR; + +FILE *pcap_in = (FILE *) 0, *pcap_out = (FILE *) 0; + +typedef int yy_state_type; + +extern int pcap_lineno; + +int pcap_lineno = 1; + +extern char *pcap_text; +#define yytext_ptr pcap_text + +static yy_state_type yy_get_previous_state (void ); +static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); +static int yy_get_next_buffer (void ); +static void yy_fatal_error (yyconst char msg[] ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up pcap_text. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + pcap_leng = (size_t) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; + +#define YY_NUM_RULES 154 +#define YY_END_OF_BUFFER 155 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static yyconst flex_int16_t yy_accept[1459] = + { 0, + 0, 0, 155, 152, 112, 112, 112, 113, 152, 113, + 113, 113, 153, 122, 122, 113, 113, 113, 113, 150, + 150, 152, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 113, 152, 116, 120, 67, 0, 150, 122, + 0, 150, 150, 150, 0, 124, 118, 115, 117, 114, + 119, 150, 151, 151, 150, 150, 150, 20, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + + 7, 150, 34, 35, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 91, 150, + 68, 150, 150, 150, 150, 150, 150, 60, 150, 150, + 150, 150, 85, 150, 150, 150, 150, 150, 150, 61, + 150, 4, 150, 150, 150, 150, 150, 150, 150, 68, + 120, 150, 123, 123, 150, 122, 150, 0, 124, 122, + 124, 124, 124, 150, 150, 150, 67, 5, 150, 80, + 150, 150, 150, 150, 150, 150, 150, 55, 106, 1, + 0, 150, 21, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + + 36, 150, 150, 18, 43, 0, 150, 29, 150, 25, + 70, 150, 150, 78, 37, 150, 99, 150, 150, 150, + 150, 100, 150, 46, 69, 81, 105, 150, 14, 150, + 3, 150, 150, 150, 150, 150, 93, 150, 150, 26, + 150, 104, 150, 107, 38, 2, 150, 42, 150, 9, + 150, 10, 88, 150, 87, 150, 150, 0, 150, 150, + 123, 150, 150, 150, 150, 122, 0, 150, 0, 125, + 124, 124, 0, 124, 0, 124, 0, 124, 0, 23, + 150, 150, 150, 150, 64, 16, 41, 150, 39, 150, + 150, 150, 30, 150, 97, 150, 150, 110, 150, 150, + + 103, 109, 45, 108, 111, 11, 150, 12, 13, 150, + 150, 150, 32, 77, 150, 62, 3, 98, 47, 150, + 150, 150, 74, 150, 150, 150, 150, 48, 150, 150, + 40, 150, 6, 150, 92, 150, 8, 94, 150, 150, + 0, 150, 53, 73, 15, 150, 123, 123, 150, 123, + 123, 123, 150, 122, 150, 0, 124, 150, 0, 0, + 124, 0, 124, 125, 124, 0, 0, 0, 0, 124, + 124, 124, 124, 124, 0, 150, 56, 57, 58, 59, + 150, 22, 150, 150, 150, 150, 31, 150, 150, 101, + 102, 0, 19, 150, 150, 150, 86, 150, 33, 150, + + 79, 28, 27, 150, 150, 82, 150, 150, 150, 50, + 17, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 0, 150, 150, 123, 150, 150, 150, + 150, 123, 123, 150, 122, 150, 0, 0, 124, 124, + 124, 0, 0, 125, 124, 124, 125, 124, 0, 0, + 124, 124, 124, 124, 124, 0, 0, 0, 0, 124, + 124, 0, 124, 0, 124, 0, 96, 150, 150, 150, + 24, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 70, 150, 150, 150, 150, + 150, 150, 150, 75, 76, 150, 95, 150, 150, 150, + + 150, 150, 150, 150, 150, 150, 150, 150, 150, 123, + 123, 150, 123, 123, 123, 123, 150, 122, 150, 0, + 124, 124, 0, 124, 0, 0, 124, 0, 124, 125, + 124, 0, 0, 0, 124, 124, 0, 124, 125, 124, + 0, 0, 0, 0, 0, 0, 0, 124, 124, 124, + 124, 124, 0, 150, 150, 150, 150, 52, 63, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 71, 150, 150, 44, 83, 84, 150, 150, 150, + 150, 54, 148, 144, 150, 146, 145, 149, 150, 0, + 150, 150, 123, 150, 150, 150, 123, 150, 122, 150, + + 0, 0, 124, 124, 124, 124, 124, 124, 0, 0, + 125, 124, 124, 124, 0, 0, 124, 124, 124, 124, + 124, 0, 0, 0, 0, 0, 0, 0, 124, 124, + 124, 124, 124, 0, 0, 0, 0, 0, 124, 124, + 0, 124, 0, 124, 0, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 127, 126, + 150, 150, 72, 150, 150, 150, 147, 143, 150, 150, + 123, 123, 123, 123, 150, 122, 150, 0, 124, 124, + 0, 124, 124, 0, 124, 0, 0, 124, 0, 124, + 125, 124, 0, 0, 0, 124, 124, 0, 124, 125, + + 124, 0, 0, 0, 0, 0, 124, 124, 0, 124, + 125, 124, 0, 124, 124, 0, 0, 0, 0, 0, + 0, 0, 124, 124, 124, 124, 124, 0, 65, 150, + 55, 132, 139, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 66, 49, 150, 150, 0, 150, 150, 150, + 150, 150, 122, 150, 0, 0, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 0, 0, 125, 124, 124, + 124, 0, 0, 124, 124, 124, 124, 124, 0, 0, + 0, 0, 0, 0, 0, 124, 124, 124, 124, 124, + 0, 124, 124, 0, 0, 0, 0, 0, 0, 0, + + 124, 124, 124, 124, 124, 0, 0, 0, 0, 0, + 0, 124, 124, 0, 124, 0, 124, 0, 89, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 51, 121, 121, 123, 123, 150, 122, 150, 0, 124, + 124, 0, 124, 124, 0, 124, 124, 0, 124, 0, + 121, 124, 0, 124, 125, 124, 0, 0, 0, 124, + 124, 0, 124, 125, 124, 0, 0, 0, 0, 0, + 124, 124, 0, 124, 125, 124, 0, 0, 0, 0, + 0, 0, 124, 124, 0, 124, 125, 124, 0, 124, + 124, 124, 0, 0, 0, 0, 0, 0, 0, 124, + + 124, 124, 124, 124, 0, 150, 150, 150, 150, 150, + 150, 150, 150, 137, 150, 90, 121, 121, 123, 150, + 121, 121, 0, 0, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 0, 121, 125, 124, + 124, 124, 0, 0, 124, 124, 124, 124, 124, 0, + 0, 0, 0, 0, 0, 0, 124, 124, 124, 124, + 124, 0, 124, 124, 0, 0, 0, 0, 0, 0, + 0, 124, 124, 124, 124, 124, 0, 124, 124, 124, + 0, 0, 0, 0, 0, 0, 0, 124, 124, 124, + 124, 124, 0, 0, 0, 0, 0, 0, 124, 124, + + 0, 124, 0, 124, 0, 150, 150, 150, 141, 150, + 150, 150, 150, 150, 150, 150, 129, 123, 150, 122, + 0, 124, 124, 0, 124, 124, 0, 124, 124, 0, + 124, 124, 0, 124, 0, 0, 0, 124, 0, 0, + 124, 125, 124, 0, 0, 0, 124, 124, 0, 124, + 125, 124, 0, 0, 0, 0, 0, 124, 124, 0, + 124, 125, 124, 0, 0, 0, 0, 0, 0, 124, + 124, 0, 124, 125, 124, 0, 0, 0, 0, 0, + 0, 124, 124, 0, 124, 125, 124, 0, 124, 124, + 124, 0, 0, 0, 0, 0, 0, 0, 124, 124, + + 124, 124, 124, 0, 150, 150, 150, 150, 131, 150, + 150, 150, 135, 150, 121, 0, 0, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 0, 0, 0, 125, 0, 0, 124, 0, + 0, 124, 124, 124, 0, 0, 0, 0, 0, 0, + 0, 124, 124, 124, 0, 124, 124, 0, 0, 0, + 0, 0, 0, 0, 124, 124, 124, 0, 124, 124, + 124, 0, 0, 0, 0, 0, 0, 0, 124, 124, + 124, 0, 124, 124, 124, 0, 0, 0, 0, 0, + 0, 0, 124, 124, 124, 0, 0, 0, 0, 0, + + 0, 124, 124, 0, 124, 0, 124, 0, 128, 140, + 142, 136, 150, 150, 150, 150, 0, 0, 124, 0, + 124, 0, 124, 124, 0, 124, 124, 0, 124, 124, + 0, 124, 124, 0, 124, 0, 0, 0, 0, 124, + 124, 0, 124, 0, 0, 124, 124, 124, 0, 0, + 0, 0, 124, 124, 124, 0, 0, 0, 0, 0, + 124, 124, 124, 0, 0, 0, 0, 0, 124, 124, + 124, 0, 0, 0, 0, 0, 124, 124, 124, 124, + 124, 124, 0, 0, 0, 0, 0, 0, 0, 124, + 124, 124, 0, 150, 150, 150, 150, 0, 0, 0, + + 124, 124, 124, 124, 124, 124, 0, 0, 0, 0, + 124, 124, 0, 0, 0, 0, 124, 124, 124, 0, + 0, 0, 0, 0, 124, 124, 124, 124, 0, 0, + 0, 0, 0, 124, 124, 124, 124, 0, 0, 0, + 0, 0, 124, 124, 124, 124, 0, 0, 0, 0, + 0, 124, 0, 0, 0, 0, 0, 124, 124, 124, + 150, 150, 150, 138, 124, 124, 124, 124, 124, 124, + 124, 124, 0, 0, 0, 0, 124, 124, 0, 0, + 124, 0, 0, 0, 124, 0, 0, 0, 124, 0, + 0, 0, 124, 0, 0, 0, 124, 124, 124, 124, + + 0, 0, 0, 0, 0, 124, 133, 150, 130, 124, + 0, 0, 124, 124, 0, 124, 124, 124, 0, 124, + 124, 124, 0, 124, 124, 124, 0, 124, 124, 124, + 0, 0, 0, 0, 124, 134, 124, 124, 0, 0, + 0, 0, 0, 0, 124, 124, 124, 0, 0, 124, + 124, 124, 124, 124, 0, 124, 124, 0 + } ; + +static yyconst flex_int32_t yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 5, 1, 1, 6, 1, 7, 1, 8, + 8, 9, 9, 1, 10, 11, 9, 12, 13, 14, + 15, 16, 17, 18, 17, 17, 17, 19, 1, 20, + 21, 22, 1, 1, 23, 23, 23, 23, 23, 23, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 25, 24, 24, + 26, 27, 26, 1, 28, 1, 29, 30, 31, 32, + + 33, 34, 35, 36, 37, 24, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 24, 1, 53, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst flex_int32_t yy_meta[54] = + { 0, + 1, 2, 2, 1, 2, 1, 3, 2, 1, 4, + 5, 6, 6, 6, 6, 6, 6, 6, 7, 3, + 3, 3, 8, 4, 9, 3, 1, 4, 8, 8, + 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 9, 4, 3 + } ; + +static yyconst flex_int16_t yy_base[1919] = + { 0, + 0, 0, 3907, 53, 7401, 7401, 54, 3884, 60, 3897, + 7401, 82, 7401, 100, 31, 152, 47, 3882, 49, 169, + 211, 169, 61, 44, 126, 61, 30, 63, 76, 158, + 215, 218, 160, 32, 166, 117, 230, 236, 208, 3855, + 174, 3847, 3832, 281, 7401, 0, 7401, 297, 320, 344, + 3865, 368, 0, 375, 0, 409, 7401, 7401, 7401, 7401, + 7401, 279, 297, 0, 3838, 3834, 3848, 0, 3847, 3821, + 3834, 3831, 3819, 3813, 3813, 3816, 3815, 3799, 3808, 3793, + 3806, 3789, 225, 3798, 3801, 3786, 3770, 3783, 3772, 3777, + 3767, 3765, 121, 83, 3770, 3768, 129, 3757, 3752, 3761, + + 148, 228, 0, 0, 37, 169, 3749, 3758, 226, 3741, + 3739, 3742, 3731, 3721, 3729, 3720, 3719, 3724, 0, 3732, + 0, 3715, 3706, 3700, 3701, 3701, 3701, 234, 3710, 3693, + 3690, 3683, 56, 3679, 243, 3677, 160, 3676, 3687, 0, + 3673, 0, 3672, 3656, 3661, 3668, 3659, 3649, 3663, 7401, + 7401, 434, 458, 274, 499, 523, 547, 3657, 554, 3664, + 578, 293, 3655, 3630, 3635, 3625, 0, 0, 3630, 0, + 3639, 3619, 3608, 3607, 3608, 3604, 3604, 3596, 0, 0, + 3591, 3581, 0, 3593, 3588, 3575, 3589, 3592, 3574, 3558, + 3557, 3554, 3569, 3552, 3556, 3536, 3538, 3551, 3536, 3535, + + 0, 3539, 3533, 0, 0, 3537, 3527, 0, 3518, 0, + 3515, 3502, 3509, 0, 0, 3497, 0, 3506, 3514, 272, + 3496, 0, 3480, 3496, 0, 3491, 0, 3494, 0, 3474, + 3478, 3472, 3475, 3471, 3444, 3440, 0, 3438, 3450, 0, + 3438, 0, 3437, 0, 0, 0, 3434, 0, 171, 202, + 3445, 0, 0, 3421, 0, 3418, 3419, 618, 3449, 641, + 665, 3446, 672, 481, 115, 696, 3437, 720, 3436, 3435, + 728, 294, 3420, 3419, 488, 769, 792, 3417, 0, 0, + 3392, 381, 3395, 3399, 0, 0, 0, 3382, 0, 3381, + 3382, 3366, 0, 3364, 0, 3358, 3360, 0, 3343, 3342, + + 0, 0, 0, 0, 0, 595, 3349, 0, 0, 3355, + 3325, 3324, 0, 0, 3313, 0, 0, 0, 0, 3328, + 3311, 3318, 0, 3310, 3294, 3310, 3283, 3279, 3290, 3279, + 0, 3278, 0, 3264, 0, 261, 0, 0, 3247, 3241, + 720, 3247, 0, 0, 0, 817, 841, 296, 882, 3274, + 3273, 405, 905, 929, 953, 3242, 960, 602, 3241, 3240, + 983, 757, 1007, 1030, 3239, 0, 3236, 408, 409, 1054, + 3235, 1078, 297, 3224, 3210, 3179, 0, 0, 0, 0, + 3173, 0, 3183, 3182, 3150, 3148, 0, 3165, 3160, 0, + 0, 1097, 0, 3148, 3126, 3140, 0, 3131, 0, 3135, + + 3112, 0, 0, 3121, 3101, 366, 3089, 3104, 371, 3101, + 0, 3090, 3060, 3063, 3053, 3048, 3059, 3052, 3038, 3039, + 3032, 3038, 3053, 1134, 3062, 1157, 1181, 3059, 1188, 864, + 165, 1212, 314, 1252, 1275, 1299, 3047, 3036, 1307, 315, + 3014, 3013, 3012, 3010, 1348, 317, 3008, 3007, 496, 612, + 1389, 3006, 1413, 321, 2981, 2988, 2979, 871, 0, 352, + 2978, 1101, 1454, 1477, 2976, 0, 0, 2948, 2964, 2930, + 0, 2939, 2923, 2928, 2940, 2925, 2940, 2939, 369, 2911, + 408, 2911, 2916, 2904, 2914, 0, 2904, 2901, 2892, 2896, + 2892, 2881, 2848, 0, 0, 2852, 0, 2847, 2838, 2850, + + 2849, 2843, 2824, 2818, 2816, 2821, 2826, 2824, 1502, 1526, + 404, 1567, 2847, 2846, 614, 1591, 1615, 1622, 1646, 2822, + 1653, 1677, 1700, 2821, 2820, 2819, 1723, 1108, 1747, 1770, + 2818, 0, 1235, 0, 442, 2816, 1242, 1794, 1817, 2815, + 0, 739, 766, 2822, 466, 786, 817, 1841, 2799, 1865, + 433, 2798, 2805, 510, 2769, 2774, 2770, 0, 0, 2775, + 2777, 2748, 2748, 2760, 2743, 2742, 2748, 2740, 2741, 2738, + 2737, 0, 2728, 2722, 0, 0, 0, 2735, 2730, 2735, + 2722, 0, 0, 0, 2711, 0, 0, 0, 2700, 1905, + 2735, 1928, 1952, 2733, 1959, 358, 1983, 2007, 2014, 2038, + + 2724, 2722, 2046, 457, 2721, 2087, 493, 2720, 2705, 2704, + 2703, 2128, 494, 2702, 879, 899, 2169, 2701, 2193, 523, + 2699, 2706, 1128, 1130, 2705, 2689, 1251, 1317, 2234, 2680, + 2258, 524, 2679, 2686, 1331, 0, 1338, 0, 467, 2677, + 1371, 2299, 2322, 2674, 0, 2345, 354, 390, 534, 535, + 622, 276, 591, 2645, 241, 551, 433, 1129, 2630, 2629, + 1247, 2628, 2627, 1343, 854, 503, 2626, 2624, 2383, 2420, + 2456, 2492, 553, 2516, 650, 2524, 2548, 2651, 2555, 2579, + 2602, 2650, 2626, 2649, 2634, 2633, 2632, 2672, 1379, 2696, + 2719, 2631, 0, 1436, 0, 680, 2629, 1443, 2743, 2766, + + 2627, 0, 1549, 0, 1556, 0, 681, 2611, 1888, 2790, + 2813, 2610, 0, 555, 1895, 2617, 1451, 1471, 2616, 2615, + 1502, 1564, 2837, 2605, 2861, 615, 2604, 2611, 617, 688, + 634, 768, 1251, 1388, 2056, 1453, 808, 834, 898, 2083, + 766, 923, 810, 833, 2081, 2085, 2903, 835, 2926, 921, + 2949, 2114, 2973, 2997, 2587, 2586, 3005, 642, 2585, 3046, + 643, 2584, 3087, 671, 2582, 2581, 2580, 2564, 3128, 742, + 2563, 1694, 1904, 3169, 2562, 3193, 902, 2561, 2568, 2056, + 2057, 2566, 2565, 2063, 2123, 3234, 2556, 3258, 930, 2555, + 2541, 931, 2151, 2540, 2124, 2125, 2539, 2538, 2145, 2166, + + 3299, 2529, 3323, 954, 2527, 2534, 0, 2216, 0, 2223, + 0, 737, 2525, 2281, 3364, 3387, 2524, 0, 897, 975, + 976, 1000, 1904, 1001, 1566, 1022, 1046, 2276, 1047, 2105, + 1048, 3412, 3435, 3459, 1029, 3499, 3523, 3547, 2501, 3554, + 3578, 3601, 2500, 3625, 3648, 2499, 3672, 3695, 2498, 2497, + 2495, 3718, 2368, 3742, 3765, 2494, 0, 2406, 0, 969, + 2493, 2443, 3789, 3812, 2492, 0, 2463, 0, 2470, 0, + 1016, 2445, 2477, 3836, 3859, 2443, 0, 0, 2484, 0, + 2884, 0, 1087, 2429, 2891, 3883, 3906, 2428, 0, 0, + 1077, 3028, 2434, 2231, 2295, 2431, 2397, 2296, 2316, 3930, + + 2375, 3954, 1080, 2347, 2354, 2359, 2360, 2361, 2127, 1128, + 2233, 2298, 1071, 2362, 1203, 1072, 1126, 1150, 3996, 4020, + 4029, 1204, 2345, 2331, 4047, 1107, 2330, 4088, 1110, 2329, + 4129, 1157, 2325, 4170, 1158, 2324, 2306, 2305, 4210, 4234, + 1159, 2286, 2414, 2415, 4275, 2283, 4299, 1182, 2282, 2289, + 2596, 2643, 2273, 2269, 2899, 2900, 4340, 2259, 4364, 1187, + 2241, 2248, 1246, 3035, 2247, 2903, 3043, 2244, 2243, 3056, + 3062, 4405, 2202, 4429, 1248, 2201, 2208, 0, 1249, 3110, + 2204, 3063, 3084, 2203, 2183, 3104, 3123, 4470, 2174, 4494, + 1252, 2171, 2167, 0, 3151, 0, 3216, 0, 1166, 2154, + + 3223, 4535, 4558, 2135, 0, 3268, 3269, 3333, 1206, 2399, + 2363, 1407, 3252, 2275, 1469, 1493, 1347, 4583, 4607, 4616, + 2105, 4633, 4657, 4680, 2075, 4704, 4727, 2073, 4751, 4774, + 2070, 4798, 4821, 2068, 2067, 4845, 1276, 2066, 2064, 3286, + 4886, 2054, 2051, 0, 3350, 0, 1535, 2023, 3482, 4910, + 2021, 2020, 0, 3489, 0, 3977, 0, 1576, 2019, 3984, + 4934, 2017, 2016, 0, 0, 4036, 0, 4070, 0, 1599, + 2015, 4077, 4958, 1991, 1989, 0, 0, 4111, 0, 4118, + 0, 1630, 1986, 4152, 4982, 1985, 1911, 0, 0, 1386, + 4159, 1876, 3125, 3145, 1857, 1832, 3164, 3166, 5006, 1819, + + 5030, 1389, 1803, 1807, 1495, 1669, 1670, 1520, 1671, 1741, + 4168, 1692, 1716, 2401, 5072, 1776, 5089, 5113, 1390, 1775, + 5154, 1453, 1753, 5195, 1561, 1752, 5236, 1566, 1730, 5277, + 1568, 1729, 1728, 4196, 5318, 1724, 1709, 0, 1708, 3231, + 3294, 5342, 1705, 1631, 1633, 3333, 3360, 1632, 1602, 3381, + 3412, 5366, 1573, 1569, 1541, 1591, 4257, 1534, 3498, 3595, + 1518, 1517, 3642, 3689, 5390, 1505, 1480, 1469, 0, 1621, + 4264, 1464, 4180, 4181, 1463, 1423, 4205, 4209, 5414, 1394, + 1391, 1398, 0, 1622, 4322, 1363, 4272, 4316, 1361, 1359, + 4335, 4337, 5438, 1350, 1316, 1323, 0, 4387, 0, 4394, + + 0, 1756, 1314, 4452, 5462, 0, 1312, 0, 1740, 1763, + 1764, 1786, 1787, 1974, 4488, 4504, 5486, 1623, 0, 1310, + 5527, 0, 1276, 5551, 0, 1259, 5575, 0, 1253, 5599, + 0, 1221, 5623, 0, 1217, 4402, 4446, 5647, 1196, 1114, + 1108, 88, 138, 4460, 0, 1826, 214, 229, 4521, 0, + 4623, 0, 1850, 322, 345, 0, 4868, 0, 4875, 0, + 1874, 416, 460, 0, 5053, 0, 5060, 0, 1914, 501, + 508, 0, 5079, 0, 5136, 0, 1937, 524, 580, 0, + 1650, 5143, 589, 4531, 4552, 610, 611, 4632, 4674, 5671, + 605, 0, 632, 2418, 1788, 1811, 1834, 5695, 627, 696, + + 0, 0, 0, 0, 0, 0, 5177, 0, 1967, 698, + 699, 0, 4721, 4768, 709, 710, 0, 1652, 5184, 713, + 4815, 4883, 741, 744, 0, 0, 1653, 5218, 778, 5088, + 5192, 801, 803, 0, 0, 1816, 5259, 805, 5212, 5231, + 808, 828, 0, 0, 1838, 5300, 849, 5233, 5253, 856, + 858, 0, 0, 5307, 0, 5509, 0, 1968, 883, 0, + 3083, 2964, 2161, 1921, 0, 7401, 0, 0, 0, 0, + 0, 0, 5315, 5503, 892, 895, 0, 7401, 5517, 0, + 7401, 0, 5718, 0, 7401, 0, 5725, 0, 7401, 0, + 5732, 0, 7401, 0, 5739, 0, 7401, 0, 1840, 5746, + + 898, 5754, 5755, 937, 2022, 0, 1975, 3341, 2062, 0, + 5755, 0, 1841, 5769, 946, 0, 1899, 5776, 973, 0, + 1901, 5783, 976, 0, 1902, 5795, 996, 0, 1929, 5802, + 1020, 0, 5809, 0, 7401, 2185, 1956, 5816, 1040, 0, + 0, 0, 0, 0, 0, 1958, 5823, 1041, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7401, 5841, 5849, + 5853, 5856, 5859, 5862, 5865, 5868, 5871, 5874, 5877, 5880, + 5883, 5886, 5889, 5892, 5895, 5898, 5901, 5905, 5909, 5912, + 5915, 5918, 5921, 5924, 5927, 5930, 5933, 5937, 5941, 5944, + 5947, 5951, 5953, 5956, 5959, 5962, 5965, 5968, 5971, 5974, + + 5977, 5981, 5983, 5986, 5990, 5995, 5999, 6002, 6006, 6009, + 6012, 6015, 6018, 6021, 6024, 6027, 6031, 6035, 6038, 6042, + 6046, 6051, 6055, 6057, 6061, 6064, 6068, 6071, 6074, 6078, + 6080, 6083, 6086, 6089, 6092, 6095, 6098, 6101, 6104, 6107, + 6111, 6113, 6116, 6119, 6122, 6126, 6128, 6131, 6134, 6139, + 6143, 6148, 6152, 6154, 6158, 6161, 6165, 6170, 6174, 6177, + 6180, 6183, 6186, 6189, 6192, 6195, 6199, 6203, 6206, 6210, + 6214, 6219, 6223, 6225, 6229, 6232, 6236, 6239, 6244, 6248, + 6253, 6257, 6259, 6263, 6266, 6270, 6273, 6276, 6279, 6283, + 6285, 6288, 6293, 6297, 6300, 6303, 6306, 6309, 6312, 6315, + + 6318, 6321, 6325, 6327, 6330, 6333, 6336, 6340, 6342, 6345, + 6348, 6351, 6354, 6358, 6360, 6363, 6366, 6369, 6374, 6378, + 6383, 6387, 6389, 6393, 6396, 6400, 6405, 6409, 6412, 6415, + 6418, 6421, 6424, 6427, 6430, 6434, 6438, 6441, 6445, 6449, + 6454, 6458, 6460, 6464, 6467, 6471, 6474, 6479, 6483, 6488, + 6492, 6494, 6498, 6501, 6505, 6508, 6511, 6516, 6520, 6525, + 6529, 6531, 6535, 6538, 6542, 6545, 6548, 6551, 6555, 6557, + 6560, 6565, 6569, 6572, 6575, 6578, 6581, 6584, 6587, 6590, + 6593, 6596, 6599, 6602, 6606, 6608, 6611, 6614, 6617, 6620, + 6624, 6626, 6629, 6632, 6635, 6638, 6641, 6645, 6647, 6650, + + 6653, 6656, 6659, 6662, 6666, 6668, 6671, 6674, 6677, 6680, + 6685, 6689, 6694, 6698, 6700, 6704, 6707, 6711, 6716, 6720, + 6723, 6726, 6729, 6732, 6735, 6738, 6741, 6744, 6747, 6751, + 6755, 6758, 6762, 6766, 6771, 6775, 6777, 6781, 6784, 6788, + 6791, 6796, 6800, 6805, 6809, 6811, 6815, 6818, 6822, 6825, + 6828, 6833, 6837, 6842, 6846, 6848, 6852, 6855, 6859, 6862, + 6865, 6870, 6874, 6879, 6883, 6885, 6889, 6892, 6896, 6899, + 6902, 6905, 6909, 6911, 6914, 6917, 6922, 6926, 6929, 6932, + 6935, 6938, 6941, 6944, 6947, 6950, 6953, 6956, 6959, 6963, + 6967, 6970, 6973, 6977, 6980, 6983, 6987, 6989, 6992, 6995, + + 6999, 7001, 7004, 7007, 7010, 7014, 7016, 7019, 7022, 7025, + 7029, 7031, 7034, 7037, 7040, 7044, 7046, 7049, 7052, 7057, + 7061, 7066, 7070, 7072, 7076, 7079, 7083, 7088, 7092, 7095, + 7098, 7101, 7104, 7107, 7110, 7113, 7116, 7120, 7122, 7125, + 7129, 7134, 7138, 7139, 7142, 7147, 7151, 7156, 7160, 7161, + 7164, 7167, 7172, 7176, 7181, 7185, 7186, 7189, 7192, 7197, + 7201, 7206, 7210, 7211, 7214, 7217, 7222, 7226, 7231, 7235, + 7236, 7239, 7242, 7245, 7249, 7251, 7256, 7260, 7263, 7266, + 7269, 7272, 7275, 7278, 7282, 7287, 7291, 7292, 7295, 7298, + 7301, 7304, 7307, 7310, 7313, 7316, 7319, 7322, 7327, 7331, + + 7334, 7337, 7340, 7344, 7348, 7352, 7356, 7360, 7363, 7366, + 7370, 7373, 7376, 7379, 7382, 7385, 7389, 7392 + } ; + +static yyconst flex_int16_t yy_def[1919] = + { 0, + 1458, 1, 1458, 1458, 1458, 1458, 1458, 1458, 1459, 1458, + 1458, 1458, 1458, 1458, 14, 1458, 1458, 1458, 1458, 14, + 20, 1460, 20, 20, 20, 20, 20, 20, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 1458, 1458, 1458, 1461, 1458, 21, 21, 20, + 1462, 50, 21, 21, 21, 1458, 1458, 1458, 1458, 1458, + 1458, 49, 1460, 1460, 52, 52, 52, 21, 21, 21, + 21, 52, 21, 21, 52, 21, 21, 21, 52, 21, + 21, 21, 21, 21, 52, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 1458, + 1458, 21, 21, 153, 21, 21, 156, 1463, 1458, 54, + 1458, 161, 1464, 21, 21, 157, 21, 21, 21, 157, + 21, 21, 21, 21, 21, 21, 157, 21, 21, 21, + 21, 21, 21, 21, 157, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 260, 261, 157, 1465, 266, 1466, 1467, + 1458, 271, 1468, 1469, 1458, 1458, 1458, 1470, 1471, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 347, 21, 261, + 263, 261, 263, 263, 354, 1472, 1458, 353, 1473, 1474, + 1458, 1458, 1458, 1458, 1475, 1476, 1477, 1478, 1478, 1458, + 1479, 1458, 372, 1480, 1471, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 426, + 427, 427, 432, 426, 354, 435, 1481, 1482, 1458, 439, + 1483, 1458, 1484, 1485, 1458, 445, 1486, 1487, 1488, 1488, + 1458, 1489, 1458, 453, 1490, 1476, 1458, 1458, 1491, 1492, + 1458, 1458, 1458, 1458, 1493, 1494, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 510, 21, 427, 429, 427, 427, 516, 435, 518, 1495, + 1458, 1458, 1458, 1496, 1497, 1498, 1458, 1458, 1458, 1458, + 1499, 1500, 1458, 1501, 1502, 1458, 1458, 1458, 1458, 1503, + 1504, 1505, 1505, 1491, 1492, 1506, 1506, 1458, 1507, 1458, + 550, 1508, 1509, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 593, 593, 597, 518, 599, + + 1510, 1511, 1458, 603, 1512, 1458, 606, 1513, 1458, 1514, + 1515, 1458, 612, 1516, 1517, 1517, 1458, 1518, 1458, 619, + 1519, 1520, 1521, 1521, 1522, 1523, 1524, 1524, 1458, 1525, + 1458, 631, 1526, 1527, 1458, 1528, 1458, 1529, 1530, 1458, + 1458, 1458, 1458, 1531, 1532, 600, 646, 646, 646, 646, + 646, 646, 646, 646, 646, 646, 646, 646, 646, 646, + 646, 646, 646, 646, 646, 646, 646, 646, 646, 646, + 646, 671, 671, 671, 646, 671, 676, 1533, 1458, 1458, + 1458, 1534, 1458, 1458, 1535, 1536, 1537, 1458, 1458, 1458, + 1458, 1538, 1539, 1458, 1540, 1541, 1458, 1458, 1458, 1458, + + 1542, 1543, 1458, 1544, 1458, 1545, 1546, 1458, 1458, 1458, + 1458, 1547, 1548, 1549, 1458, 1550, 1551, 1551, 1552, 1553, + 1554, 1554, 1458, 1555, 1458, 725, 1556, 1557, 1558, 1558, + 1558, 1558, 1558, 1558, 1558, 1558, 1558, 1558, 1558, 1558, + 1558, 1558, 1558, 1558, 1558, 1558, 1558, 1558, 747, 1558, + 747, 751, 751, 753, 1559, 1560, 1458, 757, 1561, 1458, + 760, 1562, 1458, 763, 1563, 1458, 1564, 1565, 1458, 769, + 1566, 1567, 1567, 1458, 1568, 1458, 776, 1569, 1570, 1571, + 1571, 1572, 1573, 1574, 1574, 1458, 1575, 1458, 788, 1576, + 1577, 1578, 1458, 1579, 1580, 1580, 1581, 1582, 1583, 1583, + + 1458, 1584, 1458, 803, 1585, 1586, 1587, 1458, 1588, 1458, + 1589, 1590, 1458, 1458, 1458, 1458, 1591, 1592, 1593, 1593, + 1593, 1593, 1593, 1593, 1593, 1593, 1593, 1593, 1593, 1593, + 1593, 1593, 832, 832, 834, 832, 832, 837, 1594, 1458, + 1458, 1458, 1595, 1458, 1458, 1596, 1458, 1458, 1597, 1598, + 1599, 1458, 1458, 1458, 1458, 1600, 1601, 1458, 1602, 1603, + 1458, 1458, 1458, 1458, 1604, 1605, 1458, 1606, 1458, 1607, + 1608, 1458, 1458, 1458, 1458, 1609, 1610, 1611, 1458, 1612, + 1458, 1613, 1614, 1458, 1458, 1458, 1458, 1615, 1616, 1617, + 1618, 1458, 1619, 1620, 1620, 1621, 1622, 1623, 1623, 1458, + + 1624, 1458, 902, 1625, 1626, 1627, 1627, 1627, 1627, 1627, + 1627, 1627, 1627, 1627, 1627, 1627, 1627, 1627, 1627, 919, + 1627, 1627, 1628, 1629, 1458, 925, 1630, 1458, 928, 1631, + 1458, 931, 1632, 1458, 934, 1633, 1458, 1634, 1458, 1458, + 940, 1635, 1636, 1636, 1458, 1637, 1458, 947, 1638, 1639, + 1640, 1640, 1641, 1642, 1643, 1643, 1458, 1644, 1458, 959, + 1645, 1646, 1647, 1458, 1648, 1649, 1649, 1650, 1651, 1652, + 1652, 1458, 1653, 1458, 974, 1654, 1655, 1656, 1657, 1458, + 1658, 1659, 1659, 1660, 1661, 1662, 1662, 1458, 1663, 1458, + 990, 1664, 1665, 1666, 1458, 1667, 1458, 1668, 1669, 1458, + + 1458, 1458, 1458, 1670, 1671, 1672, 1672, 1672, 1672, 1672, + 1672, 1672, 1672, 1672, 1672, 1672, 1672, 1672, 1018, 1672, + 1673, 1458, 1458, 1458, 1674, 1458, 1458, 1675, 1458, 1458, + 1676, 1458, 1458, 1677, 1678, 1458, 1036, 1679, 1680, 1458, + 1458, 1681, 1682, 1683, 1458, 1684, 1685, 1458, 1458, 1458, + 1686, 1687, 1688, 1458, 1689, 1458, 1690, 1691, 1458, 1458, + 1458, 1692, 1693, 1694, 1695, 1458, 1696, 1458, 1697, 1698, + 1458, 1458, 1458, 1699, 1700, 1701, 1702, 1458, 1703, 1458, + 1704, 1705, 1458, 1458, 1458, 1706, 1707, 1708, 1709, 1710, + 1458, 1711, 1712, 1712, 1713, 1714, 1715, 1715, 1458, 1716, + + 1458, 1101, 1717, 1718, 1719, 1719, 1719, 1719, 1719, 1719, + 1719, 1719, 1719, 1719, 1719, 1720, 1458, 1458, 1118, 1721, + 1458, 1121, 1722, 1458, 1124, 1723, 1458, 1127, 1724, 1458, + 1130, 1725, 1458, 1458, 1458, 1726, 1727, 1728, 1729, 1730, + 1730, 1458, 1731, 1732, 1733, 1734, 1734, 1735, 1736, 1737, + 1737, 1458, 1738, 1739, 1740, 1741, 1458, 1742, 1743, 1743, + 1744, 1745, 1746, 1746, 1458, 1747, 1748, 1749, 1750, 1751, + 1458, 1752, 1753, 1753, 1754, 1755, 1756, 1756, 1458, 1757, + 1758, 1759, 1760, 1761, 1458, 1762, 1763, 1763, 1764, 1765, + 1766, 1766, 1458, 1767, 1768, 1769, 1770, 1458, 1771, 1458, + + 1772, 1773, 1458, 1458, 1458, 1774, 1775, 1776, 1777, 1777, + 1777, 1777, 1777, 1777, 1777, 1777, 1458, 1217, 1778, 1779, + 1458, 1780, 1781, 1458, 1782, 1783, 1458, 1784, 1785, 1458, + 1786, 1787, 1458, 1788, 1789, 1790, 1790, 1458, 1791, 1792, + 1793, 1794, 1795, 1458, 1796, 1797, 1458, 1798, 1458, 1799, + 1458, 1800, 1801, 1458, 1802, 1803, 1458, 1804, 1458, 1805, + 1806, 1458, 1807, 1808, 1458, 1809, 1458, 1810, 1811, 1458, + 1812, 1813, 1458, 1814, 1458, 1815, 1816, 1458, 1817, 1818, + 1819, 1458, 1820, 1821, 1821, 1822, 1823, 1824, 1824, 1458, + 1825, 1826, 1827, 1828, 1828, 1828, 1828, 1458, 1829, 1830, + + 1831, 1832, 1833, 1834, 1835, 1836, 1458, 1837, 1838, 1458, + 1839, 1840, 1841, 1841, 1842, 1843, 1844, 1845, 1458, 1846, + 1847, 1847, 1848, 1849, 1850, 1851, 1852, 1458, 1853, 1854, + 1854, 1855, 1856, 1857, 1858, 1859, 1458, 1860, 1861, 1861, + 1862, 1863, 1864, 1865, 1866, 1458, 1867, 1868, 1868, 1869, + 1870, 1871, 1872, 1458, 1873, 1458, 1874, 1875, 1458, 1876, + 1877, 1877, 1877, 1877, 1878, 1458, 1879, 1880, 1881, 1882, + 1883, 1884, 1885, 1885, 1886, 1887, 1888, 1458, 1458, 1889, + 1458, 1890, 1458, 1891, 1458, 1892, 1458, 1893, 1458, 1894, + 1458, 1895, 1458, 1896, 1458, 1897, 1458, 1872, 1898, 1458, + + 1873, 1899, 1899, 1874, 1875, 1900, 1877, 1877, 1877, 1901, + 1458, 1902, 1903, 1458, 1889, 1890, 1904, 1458, 1891, 1892, + 1905, 1458, 1893, 1894, 1906, 1458, 1895, 1896, 1907, 1458, + 1897, 1908, 1458, 1909, 1458, 1877, 1910, 1458, 1902, 1911, + 1912, 1913, 1914, 1915, 1908, 1916, 1458, 1909, 1917, 1911, + 1912, 1913, 1914, 1915, 1918, 1917, 1918, 0, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458 + } ; + +static yyconst flex_int16_t yy_nxt[7455] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 11, + 13, 14, 15, 15, 15, 15, 15, 15, 16, 17, + 18, 19, 20, 21, 21, 11, 22, 13, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 21, 32, 33, + 34, 35, 36, 21, 37, 38, 39, 40, 41, 42, + 21, 21, 43, 44, 44, 53, 44, 44, 44, 44, + 44, 44, 44, 44, 116, 44, 57, 58, 44, 60, + 61, 44, 44, 117, 72, 83, 84, 209, 44, 44, + 44, 53, 44, 210, 240, 44, 44, 44, 73, 65, + 44, 66, 67, 79, 85, 74, 68, 80, 1134, 86, + + 44, 69, 241, 81, 87, 70, 82, 71, 44, 48, + 49, 50, 50, 50, 50, 50, 50, 50, 51, 195, + 88, 196, 52, 53, 54, 53, 352, 55, 52, 52, + 52, 52, 52, 52, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 54, 53, 44, 123, 75, 44, 447, 44, 124, 125, + 44, 126, 127, 193, 76, 204, 194, 77, 199, 63, + 56, 78, 63, 200, 63, 53, 515, 63, 44, 62, + 52, 52, 52, 52, 52, 52, 52, 63, 110, 89, + 246, 90, 111, 53, 118, 63, 91, 92, 205, 93, + + 247, 112, 113, 94, 145, 114, 119, 115, 120, 211, + 121, 341, 146, 122, 212, 339, 147, 340, 148, 53, + 55, 53, 53, 53, 53, 53, 53, 53, 53, 1458, + 103, 104, 1222, 53, 181, 342, 140, 206, 141, 53, + 53, 53, 53, 53, 53, 95, 105, 447, 96, 97, + 106, 98, 142, 99, 107, 100, 108, 101, 128, 143, + 102, 182, 129, 109, 207, 234, 133, 183, 215, 208, + 130, 216, 134, 217, 135, 131, 136, 132, 235, 243, + 137, 44, 138, 139, 44, 738, 44, 53, 244, 44, + 155, 155, 155, 155, 155, 155, 155, 63, 53, 44, + + 63, 413, 63, 321, 735, 63, 414, 44, 152, 152, + 152, 152, 152, 152, 152, 63, 322, 1458, 1458, 152, + 53, 1458, 53, 63, 53, 152, 152, 152, 152, 152, + 152, 153, 154, 154, 154, 154, 154, 154, 53, 1458, + 1225, 1458, 155, 1458, 1458, 1458, 53, 1458, 155, 155, + 155, 155, 155, 155, 49, 156, 156, 156, 156, 156, + 156, 156, 275, 447, 53, 1458, 157, 1458, 53, 673, + 277, 1458, 157, 157, 157, 157, 157, 157, 62, 157, + 157, 157, 157, 157, 157, 157, 160, 160, 160, 160, + 160, 160, 160, 377, 378, 379, 380, 160, 490, 730, + + 53, 564, 494, 160, 160, 160, 160, 160, 160, 44, + 565, 491, 44, 381, 44, 431, 495, 44, 458, 458, + 161, 162, 162, 162, 162, 162, 162, 44, 53, 263, + 731, 163, 459, 1458, 1228, 44, 53, 163, 163, 163, + 163, 163, 163, 258, 567, 259, 259, 259, 259, 259, + 259, 259, 362, 568, 53, 263, 259, 1458, 459, 1458, + 523, 740, 259, 259, 259, 259, 259, 259, 260, 261, + 261, 261, 261, 261, 261, 261, 275, 462, 447, 53, + 262, 1458, 263, 1458, 1458, 464, 262, 262, 262, 262, + 262, 262, 349, 349, 349, 349, 349, 349, 349, 368, + + 369, 369, 369, 369, 369, 369, 533, 1458, 263, 264, + 262, 262, 262, 262, 262, 262, 262, 1458, 1458, 1231, + 534, 262, 377, 378, 379, 380, 447, 262, 262, 262, + 262, 262, 262, 265, 266, 266, 266, 266, 266, 266, + 266, 267, 1234, 1458, 1458, 268, 534, 1458, 1458, 53, + 746, 268, 268, 268, 268, 268, 268, 53, 268, 268, + 268, 268, 268, 268, 268, 271, 272, 272, 272, 272, + 272, 272, 273, 1458, 1458, 732, 274, 595, 733, 807, + 53, 53, 274, 274, 274, 274, 274, 274, 275, 276, + 276, 276, 276, 276, 276, 276, 277, 53, 447, 1198, + + 278, 739, 279, 595, 392, 807, 278, 278, 278, 278, + 278, 278, 393, 434, 434, 434, 434, 434, 434, 434, + 1200, 1001, 533, 1206, 596, 394, 55, 736, 279, 346, + 346, 346, 346, 346, 346, 346, 1458, 53, 429, 1458, + 346, 395, 1204, 55, 55, 1366, 346, 346, 346, 346, + 346, 346, 347, 348, 348, 348, 348, 348, 348, 734, + 752, 55, 1458, 349, 429, 1458, 1458, 1458, 53, 349, + 349, 349, 349, 349, 349, 260, 350, 350, 350, 350, + 350, 350, 350, 351, 351, 351, 351, 351, 351, 351, + 528, 537, 1458, 1458, 351, 1458, 53, 55, 681, 684, + + 351, 351, 351, 351, 351, 351, 353, 354, 354, 354, + 354, 354, 354, 354, 1299, 55, 1299, 447, 355, 1244, + 1040, 1458, 819, 1249, 355, 355, 355, 355, 355, 355, + 358, 355, 355, 355, 355, 355, 355, 355, 362, 363, + 363, 363, 363, 363, 363, 363, 364, 641, 417, 635, + 365, 1251, 366, 418, 1049, 643, 365, 365, 365, 365, + 365, 365, 419, 636, 420, 421, 1458, 422, 449, 450, + 450, 450, 450, 450, 450, 55, 635, 55, 366, 275, + 370, 370, 370, 370, 370, 370, 370, 277, 1257, 636, + 1458, 371, 1458, 55, 829, 55, 637, 371, 371, 371, + + 371, 371, 371, 372, 373, 373, 373, 373, 373, 373, + 638, 1259, 820, 1060, 374, 1265, 1458, 55, 1267, 55, + 374, 374, 374, 374, 374, 374, 424, 637, 425, 425, + 425, 425, 425, 425, 425, 55, 638, 55, 1072, 425, + 825, 1458, 55, 55, 747, 425, 425, 425, 425, 425, + 425, 426, 427, 427, 427, 427, 427, 427, 427, 1273, + 55, 55, 55, 428, 826, 429, 1275, 1458, 1084, 428, + 428, 428, 428, 428, 428, 512, 512, 512, 512, 512, + 512, 512, 542, 543, 543, 543, 543, 543, 543, 694, + 745, 429, 430, 428, 428, 428, 428, 428, 428, 428, + + 53, 1206, 1307, 695, 428, 1134, 55, 55, 1354, 694, + 428, 428, 428, 428, 428, 428, 432, 433, 433, 433, + 433, 433, 433, 1458, 55, 55, 1458, 434, 827, 695, + 55, 749, 55, 434, 434, 434, 434, 434, 434, 265, + 435, 435, 435, 435, 435, 435, 435, 1356, 55, 1458, + 55, 436, 1458, 830, 1458, 878, 1379, 436, 436, 436, + 436, 436, 436, 53, 436, 436, 436, 436, 436, 436, + 436, 439, 440, 440, 440, 440, 440, 440, 1458, 689, + 1458, 878, 441, 1383, 55, 55, 1387, 842, 441, 441, + 441, 441, 441, 441, 445, 446, 446, 446, 446, 446, + + 446, 447, 55, 55, 1458, 448, 1391, 906, 907, 55, + 55, 448, 448, 448, 448, 448, 448, 362, 451, 451, + 451, 451, 451, 451, 451, 364, 698, 55, 55, 452, + 1395, 55, 908, 910, 845, 452, 452, 452, 452, 452, + 452, 453, 454, 454, 454, 454, 454, 454, 447, 55, + 1411, 1433, 455, 53, 912, 55, 55, 55, 455, 455, + 455, 455, 455, 455, 275, 460, 460, 460, 460, 460, + 460, 460, 277, 55, 55, 55, 461, 915, 913, 53, + 55, 55, 461, 461, 461, 461, 461, 461, 462, 463, + 463, 463, 463, 463, 463, 463, 464, 709, 55, 55, + + 465, 994, 466, 1015, 1458, 848, 465, 465, 465, 465, + 465, 465, 546, 547, 547, 547, 547, 547, 547, 615, + 616, 616, 616, 616, 616, 616, 447, 994, 466, 475, + 1458, 1458, 447, 476, 1458, 55, 477, 55, 703, 478, + 703, 479, 480, 481, 482, 509, 509, 509, 509, 509, + 509, 509, 704, 55, 1458, 55, 509, 1458, 1011, 55, + 1458, 741, 509, 509, 509, 509, 509, 509, 510, 511, + 511, 511, 511, 511, 511, 53, 814, 55, 704, 512, + 1458, 1458, 1458, 1458, 816, 512, 512, 512, 512, 512, + 512, 426, 513, 513, 513, 513, 513, 513, 513, 514, + + 514, 514, 514, 514, 514, 514, 1458, 1458, 1458, 1458, + 514, 1458, 55, 55, 1299, 55, 514, 514, 514, 514, + 514, 514, 431, 516, 516, 516, 516, 516, 516, 516, + 55, 55, 1458, 55, 517, 1234, 263, 1458, 1017, 1231, + 517, 517, 517, 517, 517, 517, 623, 624, 624, 624, + 624, 624, 624, 627, 628, 628, 628, 628, 628, 628, + 55, 705, 263, 517, 517, 517, 517, 517, 517, 517, + 1065, 1228, 1458, 1077, 517, 706, 1458, 1225, 55, 742, + 517, 517, 517, 517, 517, 517, 518, 518, 518, 518, + 518, 518, 518, 53, 1222, 821, 1065, 519, 1458, 1077, + + 1458, 706, 1458, 519, 519, 519, 519, 519, 519, 53, + 519, 519, 519, 519, 519, 519, 519, 362, 522, 522, + 522, 522, 522, 522, 522, 523, 1458, 705, 1299, 524, + 1206, 366, 1003, 1084, 447, 524, 524, 524, 524, 524, + 524, 1458, 714, 715, 715, 715, 715, 715, 715, 717, + 718, 718, 718, 718, 718, 718, 55, 366, 528, 529, + 529, 529, 529, 529, 529, 529, 530, 1458, 1234, 885, + 531, 1080, 532, 1078, 55, 744, 531, 531, 531, 531, + 531, 531, 721, 722, 722, 722, 722, 722, 722, 53, + 772, 773, 773, 773, 773, 773, 773, 55, 532, 362, + + 535, 535, 535, 535, 535, 535, 535, 523, 1072, 447, + 1197, 536, 1231, 1458, 1458, 55, 55, 536, 536, 536, + 536, 536, 536, 537, 538, 538, 538, 538, 538, 538, + 538, 539, 822, 873, 55, 540, 1197, 541, 1110, 1458, + 1458, 540, 540, 540, 540, 540, 540, 780, 781, 781, + 781, 781, 781, 781, 784, 785, 785, 785, 785, 785, + 785, 808, 55, 541, 462, 548, 548, 548, 548, 548, + 548, 548, 464, 1068, 1066, 809, 549, 1458, 55, 1060, + 55, 808, 549, 549, 549, 549, 549, 549, 550, 551, + 551, 551, 551, 551, 551, 1458, 55, 824, 447, 552, + + 1113, 809, 55, 1458, 55, 552, 552, 552, 552, 552, + 552, 590, 810, 591, 591, 591, 591, 591, 591, 591, + 55, 1458, 55, 1228, 591, 1114, 811, 862, 1056, 55, + 591, 591, 591, 591, 591, 591, 592, 593, 593, 593, + 593, 593, 593, 593, 1054, 853, 1209, 55, 594, 1212, + 595, 1049, 811, 1024, 594, 594, 594, 594, 594, 594, + 792, 793, 793, 793, 793, 793, 793, 795, 796, 796, + 796, 796, 796, 796, 810, 55, 595, 592, 594, 594, + 594, 594, 594, 594, 594, 1458, 862, 447, 1458, 594, + 1458, 1225, 1458, 55, 1027, 594, 594, 594, 594, 594, + + 594, 431, 597, 597, 597, 597, 597, 597, 597, 873, + 911, 1458, 853, 598, 1458, 1256, 1458, 1030, 1458, 598, + 598, 598, 598, 598, 598, 53, 598, 598, 598, 598, + 598, 598, 598, 599, 599, 599, 599, 599, 599, 599, + 885, 1256, 1045, 1040, 600, 1264, 1272, 1458, 1033, 447, + 600, 600, 600, 600, 600, 600, 53, 600, 600, 600, + 600, 600, 600, 600, 603, 604, 604, 604, 604, 604, + 604, 1264, 1272, 1458, 1353, 605, 1382, 1386, 55, 55, + 55, 605, 605, 605, 605, 605, 605, 362, 451, 451, + 451, 451, 451, 451, 451, 523, 55, 55, 55, 452, + + 1353, 55, 1382, 1386, 858, 452, 452, 452, 452, 452, + 452, 606, 607, 607, 607, 607, 607, 607, 859, 55, + 1210, 1211, 608, 1222, 1215, 55, 447, 1136, 608, 608, + 608, 608, 608, 608, 612, 613, 613, 613, 613, 613, + 613, 447, 1241, 55, 859, 614, 1117, 1234, 1231, 55, + 55, 614, 614, 614, 614, 614, 614, 528, 617, 617, + 617, 617, 617, 617, 617, 530, 1001, 55, 55, 618, + 1228, 1225, 55, 55, 1003, 618, 618, 618, 618, 618, + 618, 619, 620, 620, 620, 620, 620, 620, 447, 1213, + 55, 55, 621, 1222, 1117, 55, 55, 55, 621, 621, + + 621, 621, 621, 621, 537, 629, 629, 629, 629, 629, + 629, 629, 539, 55, 55, 55, 630, 1001, 1362, 1294, + 55, 1206, 630, 630, 630, 630, 630, 630, 631, 632, + 632, 632, 632, 632, 632, 447, 1040, 1003, 55, 633, + 1390, 1363, 814, 55, 1222, 633, 633, 633, 633, 633, + 633, 462, 639, 639, 639, 639, 639, 639, 639, 464, + 1049, 55, 1394, 640, 1432, 1440, 1390, 997, 1225, 640, + 640, 640, 640, 640, 640, 641, 642, 642, 642, 642, + 642, 642, 642, 643, 1060, 1364, 995, 644, 1394, 645, + 1432, 1440, 1228, 644, 644, 644, 644, 644, 644, 799, + + 800, 800, 800, 800, 800, 800, 715, 715, 715, 715, + 715, 715, 715, 55, 858, 645, 669, 669, 669, 669, + 669, 669, 669, 1441, 1072, 1442, 1443, 669, 1458, 1086, + 55, 55, 1231, 669, 669, 669, 669, 669, 669, 670, + 670, 670, 670, 670, 670, 670, 909, 1084, 55, 1441, + 670, 1442, 1443, 1444, 1458, 1234, 670, 670, 670, 670, + 670, 670, 592, 671, 671, 671, 671, 671, 671, 671, + 672, 672, 672, 672, 672, 672, 672, 1134, 1204, 1444, + 1449, 672, 1455, 55, 55, 1299, 1206, 672, 672, 672, + 672, 672, 672, 431, 674, 674, 674, 674, 674, 674, + + 674, 55, 55, 447, 1033, 675, 1449, 1074, 1455, 447, + 1295, 675, 675, 675, 675, 675, 675, 53, 675, 675, + 675, 675, 675, 675, 675, 676, 676, 676, 676, 676, + 676, 676, 1204, 1030, 1062, 447, 677, 1027, 1051, 447, + 1458, 1024, 677, 677, 677, 677, 677, 677, 53, 677, + 677, 677, 677, 677, 677, 677, 528, 680, 680, 680, + 680, 680, 680, 680, 681, 55, 867, 867, 682, 1042, + 532, 55, 447, 869, 682, 682, 682, 682, 682, 682, + 868, 1458, 1136, 55, 447, 1117, 1033, 870, 1030, 55, + 55, 1027, 55, 1024, 55, 823, 532, 537, 683, 683, + + 683, 683, 683, 683, 683, 684, 868, 1458, 55, 685, + 55, 541, 55, 870, 55, 685, 685, 685, 685, 685, + 685, 831, 828, 1117, 338, 836, 836, 836, 836, 836, + 836, 836, 55, 869, 879, 879, 55, 541, 689, 690, + 690, 690, 690, 690, 690, 690, 691, 1458, 880, 1458, + 692, 916, 693, 1003, 55, 881, 692, 692, 692, 692, + 692, 692, 793, 793, 793, 793, 793, 793, 793, 882, + 55, 1010, 816, 1458, 880, 1458, 881, 885, 693, 528, + 696, 696, 696, 696, 696, 696, 696, 681, 55, 1086, + 1458, 697, 1033, 709, 55, 882, 1409, 697, 697, 697, + + 697, 697, 697, 698, 699, 699, 699, 699, 699, 699, + 699, 700, 55, 881, 879, 701, 1458, 702, 873, 1074, + 1030, 701, 701, 701, 701, 701, 701, 891, 892, 892, + 892, 892, 892, 892, 894, 895, 895, 895, 895, 895, + 895, 995, 55, 702, 537, 707, 707, 707, 707, 707, + 707, 707, 684, 698, 869, 996, 708, 867, 862, 1062, + 55, 1012, 708, 708, 708, 708, 708, 708, 709, 710, + 710, 710, 710, 710, 710, 710, 711, 1027, 1013, 689, + 712, 996, 713, 858, 55, 55, 712, 712, 712, 712, + 712, 712, 898, 899, 899, 899, 899, 899, 899, 853, + + 1051, 1024, 55, 55, 1042, 995, 997, 55, 713, 641, + 723, 723, 723, 723, 723, 723, 723, 643, 914, 1458, + 998, 724, 1112, 939, 924, 55, 997, 724, 724, 724, + 724, 724, 724, 725, 726, 726, 726, 726, 726, 726, + 1458, 1014, 1033, 1030, 727, 1458, 998, 1027, 1024, 1022, + 727, 727, 727, 727, 727, 727, 53, 53, 53, 53, + 53, 53, 53, 924, 814, 1003, 1458, 53, 55, 55, + 55, 55, 55, 53, 53, 53, 53, 53, 53, 943, + 944, 944, 944, 944, 944, 944, 55, 55, 55, 55, + 55, 729, 747, 816, 748, 748, 748, 748, 748, 748, + + 748, 1006, 1007, 1008, 1009, 748, 1016, 641, 55, 1109, + 55, 748, 748, 748, 748, 748, 748, 951, 952, 952, + 952, 952, 952, 952, 1045, 1045, 55, 55, 55, 53, + 749, 750, 750, 750, 750, 750, 750, 750, 1046, 1458, + 1108, 810, 750, 1216, 808, 55, 887, 848, 750, 750, + 750, 750, 750, 750, 955, 956, 956, 956, 956, 956, + 956, 875, 1361, 845, 1046, 1458, 53, 671, 671, 671, + 671, 671, 671, 671, 963, 964, 964, 964, 964, 964, + 964, 966, 967, 967, 967, 967, 967, 967, 970, 971, + 971, 971, 971, 971, 971, 979, 980, 980, 980, 980, + + 980, 980, 53, 672, 672, 672, 672, 672, 672, 672, + 864, 842, 855, 939, 672, 924, 848, 845, 842, 924, + 672, 672, 672, 672, 672, 672, 751, 350, 350, 350, + 350, 350, 350, 350, 265, 753, 753, 753, 753, 753, + 753, 753, 816, 643, 709, 887, 754, 848, 537, 705, + 703, 698, 754, 754, 754, 754, 754, 754, 53, 754, + 754, 754, 754, 754, 754, 754, 757, 758, 758, 758, + 758, 758, 758, 875, 845, 528, 694, 759, 689, 864, + 842, 855, 852, 759, 759, 759, 759, 759, 759, 528, + 617, 617, 617, 617, 617, 617, 617, 681, 768, 756, + + 848, 618, 845, 842, 840, 756, 1054, 618, 618, 618, + 618, 618, 618, 760, 761, 761, 761, 761, 761, 761, + 1055, 641, 816, 643, 762, 462, 637, 635, 711, 684, + 762, 762, 762, 762, 762, 762, 537, 629, 629, 629, + 629, 629, 629, 629, 684, 700, 1055, 681, 630, 691, + 768, 756, 684, 1054, 630, 630, 630, 630, 630, 630, + 763, 764, 764, 764, 764, 764, 764, 1458, 681, 756, + 53, 765, 53, 53, 743, 53, 53, 765, 765, 765, + 765, 765, 765, 769, 770, 770, 770, 770, 770, 770, + 447, 737, 643, 1458, 771, 464, 537, 711, 684, 362, + + 771, 771, 771, 771, 771, 771, 689, 774, 774, 774, + 774, 774, 774, 774, 691, 533, 528, 700, 775, 681, + 691, 688, 611, 602, 775, 775, 775, 775, 775, 775, + 776, 777, 777, 777, 777, 777, 777, 447, 684, 681, + 679, 778, 602, 592, 590, 668, 667, 778, 778, 778, + 778, 778, 778, 698, 786, 786, 786, 786, 786, 786, + 786, 700, 666, 665, 664, 787, 663, 662, 661, 660, + 659, 787, 787, 787, 787, 787, 787, 788, 789, 789, + 789, 789, 789, 789, 447, 658, 657, 656, 790, 655, + 654, 653, 652, 651, 790, 790, 790, 790, 790, 790, + + 709, 801, 801, 801, 801, 801, 801, 801, 711, 650, + 649, 648, 802, 647, 646, 462, 643, 464, 802, 802, + 802, 802, 802, 802, 803, 804, 804, 804, 804, 804, + 804, 447, 458, 539, 523, 805, 530, 611, 602, 523, + 602, 805, 805, 805, 805, 805, 805, 641, 812, 812, + 812, 812, 812, 812, 812, 643, 596, 596, 589, 813, + 588, 587, 586, 585, 584, 813, 813, 813, 813, 813, + 813, 814, 815, 815, 815, 815, 815, 815, 815, 816, + 583, 582, 581, 817, 335, 818, 237, 580, 579, 817, + 817, 817, 817, 817, 817, 982, 983, 983, 983, 983, + + 983, 983, 986, 987, 987, 987, 987, 987, 987, 1056, + 1056, 818, 55, 1066, 832, 832, 832, 832, 832, 832, + 832, 578, 577, 1057, 1458, 832, 576, 1067, 575, 574, + 55, 832, 832, 832, 832, 832, 832, 833, 833, 833, + 833, 833, 833, 833, 573, 572, 571, 570, 833, 1057, + 1458, 569, 566, 1067, 833, 833, 833, 833, 833, 833, + 834, 835, 835, 835, 835, 835, 835, 563, 562, 561, + 560, 836, 559, 55, 558, 557, 556, 836, 836, 836, + 836, 836, 836, 265, 837, 837, 837, 837, 837, 837, + 837, 55, 555, 554, 464, 838, 277, 447, 362, 539, + + 1408, 838, 838, 838, 838, 838, 838, 53, 838, 838, + 838, 838, 838, 838, 838, 689, 841, 841, 841, 841, + 841, 841, 841, 842, 523, 530, 447, 843, 527, 693, + 444, 438, 523, 843, 843, 843, 843, 843, 843, 892, + 892, 892, 892, 892, 892, 892, 964, 964, 964, 964, + 964, 964, 964, 1066, 521, 693, 698, 844, 844, 844, + 844, 844, 844, 844, 845, 438, 1068, 1458, 846, 430, + 702, 424, 1068, 1078, 846, 846, 846, 846, 846, 846, + 1069, 508, 507, 506, 505, 504, 1458, 1079, 503, 502, + 501, 500, 55, 1458, 1078, 499, 702, 709, 847, 847, + + 847, 847, 847, 847, 847, 848, 1069, 498, 1458, 849, + 55, 713, 1458, 1079, 1080, 849, 849, 849, 849, 849, + 849, 980, 980, 980, 980, 980, 980, 980, 1081, 1407, + 497, 496, 493, 1080, 1458, 1198, 492, 713, 853, 854, + 854, 854, 854, 854, 854, 854, 855, 1458, 489, 1199, + 856, 488, 857, 487, 1081, 1198, 856, 856, 856, 856, + 856, 856, 1090, 1091, 1091, 1091, 1091, 1091, 1091, 1458, + 486, 485, 119, 1458, 1200, 1199, 1200, 484, 857, 689, + 860, 860, 860, 860, 860, 860, 860, 842, 1201, 483, + 1458, 861, 474, 473, 472, 1458, 471, 861, 861, 861, + + 861, 861, 861, 862, 863, 863, 863, 863, 863, 863, + 863, 864, 470, 469, 1201, 865, 1458, 866, 468, 467, + 275, 865, 865, 865, 865, 865, 865, 1093, 1094, 1094, + 1094, 1094, 1094, 1094, 1097, 1098, 1098, 1098, 1098, 1098, + 1098, 1244, 464, 866, 698, 871, 871, 871, 871, 871, + 871, 871, 845, 277, 447, 1245, 872, 364, 444, 438, + 438, 55, 872, 872, 872, 872, 872, 872, 873, 874, + 874, 874, 874, 874, 874, 874, 875, 55, 55, 55, + 876, 1245, 877, 431, 431, 423, 876, 876, 876, 876, + 876, 876, 416, 1111, 415, 55, 55, 1140, 1141, 1141, + + 1141, 1141, 1141, 1141, 1244, 412, 1105, 1106, 877, 709, + 883, 883, 883, 883, 883, 883, 883, 848, 1458, 411, + 410, 884, 409, 408, 407, 406, 405, 884, 884, 884, + 884, 884, 884, 885, 886, 886, 886, 886, 886, 886, + 886, 887, 55, 1249, 1458, 888, 404, 889, 403, 402, + 55, 888, 888, 888, 888, 888, 888, 1250, 401, 400, + 55, 1146, 1147, 1147, 1147, 1147, 1147, 1147, 55, 399, + 1249, 1107, 398, 889, 814, 900, 900, 900, 900, 900, + 900, 900, 816, 1250, 1458, 397, 901, 1436, 396, 391, + 390, 1251, 901, 901, 901, 901, 901, 901, 902, 903, + + 903, 903, 903, 903, 903, 1252, 389, 388, 317, 904, + 1458, 387, 386, 385, 384, 904, 904, 904, 904, 904, + 904, 55, 1251, 917, 917, 917, 917, 917, 917, 917, + 383, 1252, 382, 376, 917, 277, 1458, 364, 273, 55, + 917, 917, 917, 917, 917, 917, 918, 918, 918, 918, + 918, 918, 918, 361, 270, 357, 264, 918, 258, 142, + 345, 344, 1458, 918, 918, 918, 918, 918, 918, 596, + 919, 919, 919, 919, 919, 919, 919, 343, 338, 317, + 337, 920, 336, 429, 335, 334, 333, 920, 920, 920, + 920, 920, 920, 1150, 1151, 1151, 1151, 1151, 1151, 1151, + + 1156, 1157, 1157, 1157, 1157, 1157, 1157, 332, 1257, 429, + 920, 920, 920, 920, 920, 920, 920, 331, 330, 329, + 328, 920, 1258, 327, 326, 325, 324, 920, 920, 920, + 920, 920, 920, 265, 921, 921, 921, 921, 921, 921, + 921, 323, 320, 319, 318, 922, 317, 316, 1258, 315, + 314, 922, 922, 922, 922, 922, 922, 53, 922, 922, + 922, 922, 922, 922, 922, 925, 926, 926, 926, 926, + 926, 926, 313, 312, 311, 310, 927, 309, 308, 307, + 306, 305, 927, 927, 927, 927, 927, 927, 689, 774, + 774, 774, 774, 774, 774, 774, 842, 304, 303, 302, + + 775, 301, 300, 299, 298, 1257, 775, 775, 775, 775, + 775, 775, 928, 929, 929, 929, 929, 929, 929, 1458, + 297, 296, 295, 930, 142, 294, 293, 292, 291, 930, + 930, 930, 930, 930, 930, 698, 786, 786, 786, 786, + 786, 786, 786, 845, 290, 1458, 289, 787, 288, 287, + 286, 285, 1259, 787, 787, 787, 787, 787, 787, 931, + 932, 932, 932, 932, 932, 932, 1260, 284, 283, 282, + 933, 281, 280, 277, 265, 270, 933, 933, 933, 933, + 933, 933, 709, 801, 801, 801, 801, 801, 801, 801, + 848, 257, 1260, 256, 802, 255, 254, 253, 252, 1259, + + 802, 802, 802, 802, 802, 802, 934, 935, 935, 935, + 935, 935, 935, 1458, 251, 250, 249, 936, 248, 245, + 242, 239, 238, 936, 936, 936, 936, 936, 936, 940, + 941, 941, 941, 941, 941, 941, 447, 237, 236, 1458, + 942, 233, 232, 231, 230, 229, 942, 942, 942, 942, + 942, 942, 853, 945, 945, 945, 945, 945, 945, 945, + 855, 228, 227, 226, 946, 225, 224, 223, 222, 221, + 946, 946, 946, 946, 946, 946, 947, 948, 948, 948, + 948, 948, 948, 447, 220, 219, 218, 949, 214, 213, + 203, 202, 201, 949, 949, 949, 949, 949, 949, 862, + + 957, 957, 957, 957, 957, 957, 957, 864, 198, 197, + 192, 958, 191, 190, 189, 188, 187, 958, 958, 958, + 958, 958, 958, 959, 960, 960, 960, 960, 960, 960, + 447, 186, 185, 184, 961, 180, 179, 178, 177, 176, + 961, 961, 961, 961, 961, 961, 873, 972, 972, 972, + 972, 972, 972, 972, 875, 175, 174, 173, 973, 172, + 171, 170, 169, 168, 973, 973, 973, 973, 973, 973, + 974, 975, 975, 975, 975, 975, 975, 447, 167, 166, + 165, 976, 164, 159, 150, 149, 144, 976, 976, 976, + 976, 976, 976, 885, 988, 988, 988, 988, 988, 988, + + 988, 887, 59, 47, 45, 989, 1458, 1458, 1458, 1458, + 1458, 989, 989, 989, 989, 989, 989, 990, 991, 991, + 991, 991, 991, 991, 447, 1458, 1458, 1458, 992, 1458, + 1458, 1458, 1458, 1458, 992, 992, 992, 992, 992, 992, + 814, 999, 999, 999, 999, 999, 999, 999, 816, 1458, + 1458, 1458, 1000, 1458, 1458, 1458, 1458, 1458, 1000, 1000, + 1000, 1000, 1000, 1000, 1001, 1002, 1002, 1002, 1002, 1002, + 1002, 1002, 1003, 1458, 1458, 1458, 1004, 1458, 1005, 1458, + 1458, 1458, 1004, 1004, 1004, 1004, 1004, 1004, 1159, 1160, + 1160, 1160, 1160, 1160, 1160, 1163, 1164, 1164, 1164, 1164, + + 1164, 1164, 1458, 1458, 1005, 55, 596, 1018, 1018, 1018, + 1018, 1018, 1018, 1018, 1458, 1458, 1458, 1458, 1019, 1458, + 1458, 1458, 1458, 55, 1019, 1019, 1019, 1019, 1019, 1019, + 53, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 55, 265, + 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1170, 1171, 1171, + 1171, 1171, 1171, 1171, 1458, 1458, 55, 853, 1023, 1023, + 1023, 1023, 1023, 1023, 1023, 1024, 1458, 1458, 1458, 1025, + 1458, 857, 1458, 1458, 1458, 1025, 1025, 1025, 1025, 1025, + 1025, 1173, 1174, 1174, 1174, 1174, 1174, 1174, 1177, 1178, + 1178, 1178, 1178, 1178, 1178, 1458, 1458, 857, 862, 1026, + + 1026, 1026, 1026, 1026, 1026, 1026, 1027, 1458, 1458, 1458, + 1028, 1458, 866, 1458, 1458, 1458, 1028, 1028, 1028, 1028, + 1028, 1028, 1184, 1185, 1185, 1185, 1185, 1185, 1185, 1187, + 1188, 1188, 1188, 1188, 1188, 1188, 1458, 1458, 866, 873, + 1029, 1029, 1029, 1029, 1029, 1029, 1029, 1030, 1458, 1458, + 1458, 1031, 1458, 877, 1458, 1458, 1458, 1031, 1031, 1031, + 1031, 1031, 1031, 1191, 1192, 1192, 1192, 1192, 1192, 1192, + 1091, 1091, 1091, 1091, 1091, 1091, 1091, 55, 1458, 877, + 885, 1032, 1032, 1032, 1032, 1032, 1032, 1032, 1033, 1458, + 1265, 1265, 1034, 1458, 889, 55, 1458, 1458, 1034, 1034, + + 1034, 1034, 1034, 1034, 1266, 1458, 1214, 1236, 1237, 1237, + 1237, 1237, 1237, 1237, 1458, 1267, 1458, 1458, 1458, 1267, + 889, 1036, 1037, 1037, 1037, 1037, 1037, 1037, 1038, 1268, + 1266, 1458, 1039, 1458, 1458, 1458, 1458, 1458, 1039, 1039, + 1039, 1039, 1039, 1039, 1040, 1041, 1041, 1041, 1041, 1041, + 1041, 1041, 1042, 1458, 1458, 1268, 1043, 1458, 1044, 1458, + 1458, 1458, 1043, 1043, 1043, 1043, 1043, 1043, 1157, 1157, + 1157, 1157, 1157, 1157, 1157, 1171, 1171, 1171, 1171, 1171, + 1171, 1171, 1273, 1458, 1044, 853, 1047, 1047, 1047, 1047, + 1047, 1047, 1047, 1024, 1458, 1458, 1274, 1048, 1458, 1458, + + 1458, 1458, 1458, 1048, 1048, 1048, 1048, 1048, 1048, 1049, + 1050, 1050, 1050, 1050, 1050, 1050, 1050, 1051, 1458, 1458, + 1458, 1052, 1274, 1053, 1458, 1458, 1273, 1052, 1052, 1052, + 1052, 1052, 1052, 1185, 1185, 1185, 1185, 1185, 1185, 1185, + 1458, 1458, 1458, 1458, 1458, 1275, 1458, 1275, 1458, 1053, + 862, 1058, 1058, 1058, 1058, 1058, 1058, 1058, 1027, 1276, + 1458, 1458, 1059, 1458, 1458, 1458, 1458, 1458, 1059, 1059, + 1059, 1059, 1059, 1059, 1060, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1062, 1458, 1458, 1276, 1063, 1458, 1064, 1458, + 1458, 1458, 1063, 1063, 1063, 1063, 1063, 1063, 1281, 1282, + + 1282, 1282, 1282, 1282, 1282, 1284, 1285, 1285, 1285, 1285, + 1285, 1285, 1307, 1458, 1064, 873, 1070, 1070, 1070, 1070, + 1070, 1070, 1070, 1030, 1458, 1458, 1308, 1071, 1458, 1458, + 1458, 1458, 1458, 1071, 1071, 1071, 1071, 1071, 1071, 1072, + 1073, 1073, 1073, 1073, 1073, 1073, 1073, 1074, 1458, 1458, + 1458, 1075, 1308, 1076, 1458, 1458, 1307, 1075, 1075, 1075, + 1075, 1075, 1075, 1288, 1289, 1289, 1289, 1289, 1289, 1289, + 1458, 1313, 1314, 1314, 1314, 1314, 1314, 1314, 1458, 1076, + 885, 1082, 1082, 1082, 1082, 1082, 1082, 1082, 1033, 1458, + 1458, 1458, 1083, 1458, 1458, 1458, 1458, 55, 1083, 1083, + + 1083, 1083, 1083, 1083, 1084, 1085, 1085, 1085, 1085, 1085, + 1085, 1085, 1086, 55, 1458, 55, 1087, 1458, 1088, 1458, + 1458, 1458, 1087, 1087, 1087, 1087, 1087, 1087, 1296, 1458, + 1458, 55, 1318, 1319, 1319, 1319, 1319, 1319, 1319, 1458, + 1458, 1354, 1297, 1458, 1088, 1001, 1099, 1099, 1099, 1099, + 1099, 1099, 1099, 1003, 1458, 1355, 1458, 1100, 1458, 1458, + 1458, 1458, 1354, 1100, 1100, 1100, 1100, 1100, 1100, 1101, + 1102, 1102, 1102, 1102, 1102, 1102, 1458, 1458, 1458, 1458, + 1103, 1355, 1458, 1458, 1458, 1458, 1103, 1103, 1103, 1103, + 1103, 1103, 55, 596, 1115, 1115, 1115, 1115, 1115, 1115, + + 1115, 1458, 1458, 1458, 1458, 922, 1458, 1458, 1458, 1458, + 55, 922, 922, 922, 922, 922, 922, 53, 922, 922, + 922, 922, 922, 922, 922, 55, 265, 1020, 1020, 1020, + 1020, 1020, 1020, 1020, 1321, 1322, 1322, 1322, 1322, 1322, + 1322, 1458, 1356, 55, 1118, 1119, 1119, 1119, 1119, 1119, + 1119, 1458, 1458, 1458, 1458, 1120, 1357, 1458, 1458, 1458, + 1458, 1120, 1120, 1120, 1120, 1120, 1120, 853, 945, 945, + 945, 945, 945, 945, 945, 1024, 1458, 1458, 1458, 946, + 1458, 1458, 1357, 1458, 1356, 946, 946, 946, 946, 946, + 946, 1121, 1122, 1122, 1122, 1122, 1122, 1122, 1458, 1458, + + 1458, 1458, 1123, 1458, 1458, 1458, 1458, 1458, 1123, 1123, + 1123, 1123, 1123, 1123, 862, 957, 957, 957, 957, 957, + 957, 957, 1027, 1458, 1458, 1458, 958, 1458, 1458, 1458, + 1458, 1379, 958, 958, 958, 958, 958, 958, 1124, 1125, + 1125, 1125, 1125, 1125, 1125, 1380, 1458, 1458, 1458, 1126, + 1458, 1458, 1458, 1458, 1458, 1126, 1126, 1126, 1126, 1126, + 1126, 873, 972, 972, 972, 972, 972, 972, 972, 1030, + 1458, 1380, 1458, 973, 1458, 1458, 1458, 1458, 1379, 973, + 973, 973, 973, 973, 973, 1127, 1128, 1128, 1128, 1128, + 1128, 1128, 1458, 1458, 1458, 1458, 1129, 1458, 1458, 1458, + + 1458, 1458, 1129, 1129, 1129, 1129, 1129, 1129, 885, 988, + 988, 988, 988, 988, 988, 988, 1033, 1458, 1458, 1458, + 989, 1458, 1458, 1458, 1458, 1383, 989, 989, 989, 989, + 989, 989, 1130, 1131, 1131, 1131, 1131, 1131, 1131, 1384, + 1458, 1458, 1458, 1132, 1458, 1458, 1458, 1458, 1458, 1132, + 1132, 1132, 1132, 1132, 1132, 1134, 1135, 1135, 1135, 1135, + 1135, 1135, 1135, 1136, 1458, 1384, 1458, 1137, 1458, 1138, + 1458, 1458, 1458, 1137, 1137, 1137, 1137, 1137, 1137, 1327, + 1328, 1328, 1328, 1328, 1328, 1328, 1330, 1331, 1331, 1331, + 1331, 1331, 1331, 1383, 1458, 1138, 1040, 1142, 1142, 1142, + + 1142, 1142, 1142, 1142, 1042, 1458, 1458, 1458, 1143, 1458, + 1458, 1458, 1458, 1458, 1143, 1143, 1143, 1143, 1143, 1143, + 1049, 1152, 1152, 1152, 1152, 1152, 1152, 1152, 1051, 1458, + 1458, 1458, 1153, 1458, 1458, 1458, 1458, 1458, 1153, 1153, + 1153, 1153, 1153, 1153, 1060, 1165, 1165, 1165, 1165, 1165, + 1165, 1165, 1062, 1458, 1458, 1458, 1166, 1458, 1458, 1458, + 1458, 1458, 1166, 1166, 1166, 1166, 1166, 1166, 1072, 1179, + 1179, 1179, 1179, 1179, 1179, 1179, 1074, 1458, 1458, 1458, + 1180, 1458, 1458, 1458, 1458, 1458, 1180, 1180, 1180, 1180, + 1180, 1180, 1084, 1193, 1193, 1193, 1193, 1193, 1193, 1193, + + 1086, 1458, 1458, 1458, 1194, 1458, 1458, 1458, 1458, 1458, + 1194, 1194, 1194, 1194, 1194, 1194, 1001, 1202, 1202, 1202, + 1202, 1202, 1202, 1202, 1003, 1458, 1458, 1458, 1203, 1458, + 1458, 1458, 1458, 1458, 1203, 1203, 1203, 1203, 1203, 1203, + 1204, 1205, 1205, 1205, 1205, 1205, 1205, 1205, 1206, 1458, + 1458, 1458, 1207, 1458, 1208, 1458, 1458, 1458, 1207, 1207, + 1207, 1207, 1207, 1207, 1336, 1337, 1337, 1337, 1337, 1337, + 1337, 1339, 1340, 1340, 1340, 1340, 1340, 1340, 1458, 1458, + 1208, 55, 596, 513, 513, 513, 513, 513, 513, 513, + 1345, 1346, 1346, 1346, 1346, 1346, 1346, 1458, 1387, 55, + + 1217, 1218, 1218, 1218, 1218, 1218, 1218, 1219, 1458, 1458, + 1458, 1220, 1388, 1458, 1458, 1458, 1458, 1220, 1220, 1220, + 1220, 1220, 1220, 1040, 1221, 1221, 1221, 1221, 1221, 1221, + 1221, 1222, 1458, 1458, 1458, 1223, 1458, 1044, 1388, 1458, + 1458, 1223, 1223, 1223, 1223, 1223, 1223, 1348, 1349, 1349, + 1349, 1349, 1349, 1349, 1282, 1282, 1282, 1282, 1282, 1282, + 1282, 1458, 1458, 1044, 1049, 1224, 1224, 1224, 1224, 1224, + 1224, 1224, 1225, 1458, 1458, 1458, 1226, 1458, 1053, 1458, + 1458, 1458, 1226, 1226, 1226, 1226, 1226, 1226, 1373, 1374, + 1374, 1374, 1374, 1374, 1374, 1319, 1319, 1319, 1319, 1319, + + 1319, 1319, 1387, 1458, 1053, 1060, 1227, 1227, 1227, 1227, + 1227, 1227, 1227, 1228, 1458, 1458, 1458, 1229, 1458, 1064, + 1458, 1458, 1391, 1229, 1229, 1229, 1229, 1229, 1229, 1328, + 1328, 1328, 1328, 1328, 1328, 1328, 1392, 1458, 1458, 1458, + 1458, 1391, 1458, 1395, 1458, 1064, 1072, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1231, 1458, 1458, 1396, 1232, 1458, + 1076, 1458, 1392, 1395, 1232, 1232, 1232, 1232, 1232, 1232, + 1337, 1337, 1337, 1337, 1337, 1337, 1337, 1458, 1458, 1458, + 1458, 1458, 1458, 1396, 1458, 1458, 1076, 1084, 1233, 1233, + 1233, 1233, 1233, 1233, 1233, 1234, 1458, 1458, 1458, 1235, + + 1458, 1088, 1458, 1458, 1458, 1235, 1235, 1235, 1235, 1235, + 1235, 1346, 1346, 1346, 1346, 1346, 1346, 1346, 1399, 1400, + 1400, 1400, 1400, 1400, 1400, 1411, 1458, 1088, 1134, 1238, + 1238, 1238, 1238, 1238, 1238, 1238, 1136, 1458, 1458, 1412, + 1239, 1458, 1458, 1458, 1458, 1458, 1239, 1239, 1239, 1239, + 1239, 1239, 1040, 1246, 1246, 1246, 1246, 1246, 1246, 1246, + 1222, 1458, 1458, 1458, 1247, 1412, 1458, 1458, 1458, 1458, + 1247, 1247, 1247, 1247, 1247, 1247, 1049, 1253, 1253, 1253, + 1253, 1253, 1253, 1253, 1225, 1458, 1458, 1458, 1254, 1458, + 1458, 1458, 1458, 1458, 1254, 1254, 1254, 1254, 1254, 1254, + + 1060, 1261, 1261, 1261, 1261, 1261, 1261, 1261, 1228, 1458, + 1458, 1458, 1262, 1458, 1458, 1458, 1458, 1458, 1262, 1262, + 1262, 1262, 1262, 1262, 1072, 1269, 1269, 1269, 1269, 1269, + 1269, 1269, 1231, 1458, 1458, 1458, 1270, 1458, 1458, 1458, + 1458, 1458, 1270, 1270, 1270, 1270, 1270, 1270, 1084, 1277, + 1277, 1277, 1277, 1277, 1277, 1277, 1234, 1458, 1458, 1458, + 1278, 1458, 1458, 1458, 1458, 1458, 1278, 1278, 1278, 1278, + 1278, 1278, 1204, 1290, 1290, 1290, 1290, 1290, 1290, 1290, + 1206, 1458, 1458, 1458, 1291, 1458, 1458, 1458, 1458, 1458, + 1291, 1291, 1291, 1291, 1291, 1291, 1134, 1298, 1298, 1298, + + 1298, 1298, 1298, 1298, 1299, 1458, 1458, 1458, 1300, 1458, + 1138, 1458, 1458, 1411, 1300, 1300, 1300, 1300, 1300, 1300, + 1402, 1403, 1403, 1403, 1403, 1403, 1403, 1458, 1413, 1414, + 1414, 1414, 1414, 1414, 1414, 1458, 1138, 1040, 1142, 1142, + 1142, 1142, 1142, 1142, 1142, 1222, 1458, 1458, 1458, 1143, + 1458, 1458, 1458, 1458, 1458, 1143, 1143, 1143, 1143, 1143, + 1143, 1049, 1152, 1152, 1152, 1152, 1152, 1152, 1152, 1225, + 1458, 1458, 1458, 1153, 1458, 1458, 1458, 1458, 1458, 1153, + 1153, 1153, 1153, 1153, 1153, 1060, 1165, 1165, 1165, 1165, + 1165, 1165, 1165, 1228, 1458, 1458, 1458, 1166, 1458, 1458, + + 1458, 1458, 1458, 1166, 1166, 1166, 1166, 1166, 1166, 1072, + 1179, 1179, 1179, 1179, 1179, 1179, 1179, 1231, 1458, 1458, + 1458, 1180, 1458, 1458, 1458, 1458, 1458, 1180, 1180, 1180, + 1180, 1180, 1180, 1084, 1193, 1193, 1193, 1193, 1193, 1193, + 1193, 1234, 1458, 1458, 1458, 1194, 1458, 1458, 1458, 1458, + 1458, 1194, 1194, 1194, 1194, 1194, 1194, 1134, 1309, 1309, + 1309, 1309, 1309, 1309, 1309, 1299, 1458, 1458, 1458, 1310, + 1458, 1458, 1458, 1458, 1458, 1310, 1310, 1310, 1310, 1310, + 1310, 1204, 1358, 1358, 1358, 1358, 1358, 1358, 1358, 1206, + 1458, 1458, 1458, 1359, 1458, 1458, 1458, 1458, 1458, 1359, + + 1359, 1359, 1359, 1359, 1359, 1134, 1238, 1238, 1238, 1238, + 1238, 1238, 1238, 1299, 1458, 1458, 1458, 1239, 1458, 1458, + 1458, 1458, 1458, 1239, 1239, 1239, 1239, 1239, 1239, 1417, + 1418, 1418, 1418, 1418, 1418, 1418, 1421, 1422, 1422, 1422, + 1422, 1422, 1422, 1425, 1426, 1426, 1426, 1426, 1426, 1426, + 1429, 1430, 1430, 1430, 1430, 1430, 1430, 1400, 1400, 1400, + 1400, 1400, 1400, 1400, 1433, 1433, 1437, 1438, 1438, 1438, + 1438, 1438, 1438, 1458, 1458, 1458, 1458, 1458, 1434, 1458, + 1414, 1414, 1414, 1414, 1414, 1414, 1414, 1418, 1418, 1418, + 1418, 1418, 1418, 1418, 1422, 1422, 1422, 1422, 1422, 1422, + + 1422, 1458, 1458, 1458, 1434, 1458, 1426, 1426, 1426, 1426, + 1426, 1426, 1426, 1430, 1430, 1430, 1430, 1430, 1430, 1430, + 1446, 1447, 1447, 1447, 1447, 1447, 1447, 1438, 1438, 1438, + 1438, 1438, 1438, 1438, 1447, 1447, 1447, 1447, 1447, 1447, + 1447, 46, 1458, 1458, 1458, 1458, 46, 46, 46, 64, + 1458, 64, 64, 64, 64, 64, 64, 64, 151, 1458, + 151, 158, 158, 158, 269, 269, 269, 278, 278, 278, + 356, 356, 356, 359, 359, 359, 360, 360, 360, 367, + 367, 367, 365, 365, 365, 371, 371, 371, 375, 1458, + 375, 437, 437, 437, 442, 442, 442, 443, 443, 443, + + 452, 452, 452, 456, 1458, 456, 457, 457, 457, 369, + 369, 1458, 1458, 369, 461, 461, 461, 465, 465, 465, + 359, 359, 359, 520, 520, 520, 524, 524, 524, 525, + 525, 525, 526, 526, 526, 367, 367, 367, 531, 531, + 531, 450, 450, 1458, 1458, 450, 536, 536, 536, 540, + 540, 540, 544, 1458, 544, 545, 545, 545, 549, 549, + 549, 553, 1458, 553, 601, 601, 601, 452, 452, 452, + 609, 609, 609, 610, 610, 610, 618, 618, 618, 622, + 1458, 622, 625, 1458, 625, 626, 626, 626, 630, 630, + 630, 634, 1458, 634, 543, 543, 1458, 1458, 543, 547, + + 547, 1458, 1458, 547, 640, 640, 640, 644, 644, 644, + 553, 553, 1458, 553, 525, 525, 525, 678, 678, 678, + 682, 682, 682, 685, 685, 685, 686, 686, 686, 687, + 687, 687, 692, 692, 692, 616, 616, 1458, 1458, 616, + 697, 697, 697, 701, 701, 701, 622, 622, 1458, 622, + 624, 624, 1458, 1458, 624, 625, 625, 1458, 625, 626, + 626, 628, 628, 1458, 1458, 628, 708, 708, 708, 712, + 712, 712, 634, 634, 1458, 634, 716, 1458, 716, 719, + 1458, 719, 720, 720, 720, 724, 724, 724, 728, 1458, + 728, 755, 755, 755, 618, 618, 618, 630, 630, 630, + + 766, 766, 766, 767, 767, 767, 775, 775, 775, 779, + 1458, 779, 782, 1458, 782, 783, 783, 783, 787, 787, + 787, 791, 1458, 791, 794, 1458, 794, 797, 1458, 797, + 798, 798, 798, 802, 802, 802, 806, 1458, 806, 715, + 1458, 1458, 715, 716, 716, 1458, 716, 718, 718, 1458, + 1458, 718, 719, 719, 1458, 719, 720, 720, 722, 722, + 1458, 1458, 722, 813, 813, 813, 817, 817, 817, 728, + 728, 1458, 728, 53, 53, 53, 1458, 53, 53, 686, + 686, 686, 839, 839, 839, 843, 843, 843, 846, 846, + 846, 849, 849, 849, 850, 850, 850, 851, 851, 851, + + 856, 856, 856, 773, 773, 1458, 1458, 773, 861, 861, + 861, 865, 865, 865, 779, 779, 1458, 779, 781, 781, + 1458, 1458, 781, 782, 782, 1458, 782, 783, 783, 785, + 785, 1458, 1458, 785, 872, 872, 872, 876, 876, 876, + 791, 791, 1458, 791, 793, 1458, 1458, 793, 794, 794, + 1458, 794, 796, 796, 1458, 1458, 796, 797, 797, 1458, + 797, 798, 798, 800, 800, 1458, 1458, 800, 884, 884, + 884, 888, 888, 888, 806, 806, 1458, 806, 890, 1458, + 890, 893, 1458, 893, 896, 1458, 896, 897, 897, 897, + 901, 901, 901, 905, 1458, 905, 53, 53, 53, 1458, + + 53, 53, 923, 923, 923, 775, 775, 775, 787, 787, + 787, 802, 802, 802, 937, 937, 937, 938, 938, 938, + 946, 946, 946, 950, 1458, 950, 953, 1458, 953, 954, + 954, 954, 958, 958, 958, 962, 1458, 962, 965, 1458, + 965, 968, 1458, 968, 969, 969, 969, 973, 973, 973, + 977, 1458, 977, 978, 1458, 978, 981, 1458, 981, 984, + 1458, 984, 985, 985, 985, 989, 989, 989, 993, 1458, + 993, 890, 1458, 890, 892, 1458, 1458, 892, 893, 893, + 1458, 893, 895, 895, 1458, 1458, 895, 896, 896, 1458, + 896, 897, 897, 899, 899, 1458, 1458, 899, 1000, 1000, + + 1000, 1004, 1004, 1004, 905, 905, 1458, 905, 53, 53, + 53, 1458, 53, 53, 850, 850, 850, 1021, 1021, 1021, + 1025, 1025, 1025, 1028, 1028, 1028, 1031, 1031, 1031, 1034, + 1034, 1034, 1035, 1035, 1035, 1043, 1043, 1043, 944, 944, + 1458, 1458, 944, 1048, 1048, 1048, 1052, 1052, 1052, 950, + 950, 1458, 950, 952, 952, 1458, 1458, 952, 953, 953, + 1458, 953, 954, 954, 956, 956, 1458, 1458, 956, 1059, + 1059, 1059, 1063, 1063, 1063, 962, 962, 1458, 962, 964, + 1458, 1458, 964, 965, 965, 1458, 965, 967, 967, 1458, + 1458, 967, 968, 968, 1458, 968, 969, 969, 971, 971, + + 1458, 1458, 971, 1071, 1071, 1071, 1075, 1075, 1075, 977, + 977, 1458, 977, 978, 1458, 978, 980, 1458, 1458, 980, + 981, 981, 1458, 981, 983, 983, 1458, 1458, 983, 984, + 984, 1458, 984, 985, 985, 987, 987, 1458, 1458, 987, + 1083, 1083, 1083, 1087, 1087, 1087, 993, 993, 1458, 993, + 1089, 1458, 1089, 1092, 1458, 1092, 1095, 1458, 1095, 1096, + 1096, 1096, 1100, 1100, 1100, 1104, 1458, 1104, 53, 53, + 53, 1458, 53, 53, 1116, 1116, 1116, 946, 946, 946, + 958, 958, 958, 973, 973, 973, 989, 989, 989, 1133, + 1133, 1133, 1139, 1139, 1139, 1137, 1137, 1137, 1144, 1144, + + 1144, 1143, 1143, 1143, 1145, 1458, 1145, 1148, 1458, 1148, + 1149, 1149, 1149, 1154, 1154, 1154, 1153, 1153, 1153, 1155, + 1458, 1155, 1158, 1458, 1158, 1161, 1458, 1161, 1162, 1162, + 1162, 1167, 1167, 1167, 1166, 1166, 1166, 1168, 1458, 1168, + 1169, 1458, 1169, 1172, 1458, 1172, 1175, 1458, 1175, 1176, + 1176, 1176, 1181, 1181, 1181, 1180, 1180, 1180, 1182, 1458, + 1182, 1183, 1458, 1183, 1186, 1458, 1186, 1189, 1458, 1189, + 1190, 1190, 1190, 1195, 1195, 1195, 1194, 1194, 1194, 1196, + 1458, 1196, 1089, 1458, 1089, 1091, 1458, 1458, 1091, 1092, + 1092, 1458, 1092, 1094, 1094, 1458, 1458, 1094, 1095, 1095, + + 1458, 1095, 1096, 1096, 1098, 1098, 1458, 1458, 1098, 1203, + 1203, 1203, 1207, 1207, 1207, 1104, 1104, 1458, 1104, 53, + 53, 53, 1458, 53, 53, 1035, 1035, 1035, 1223, 1223, + 1223, 1226, 1226, 1226, 1229, 1229, 1229, 1232, 1232, 1232, + 1235, 1235, 1235, 1240, 1240, 1240, 1239, 1239, 1239, 1242, + 1458, 1242, 1243, 1243, 1243, 1141, 1141, 1458, 1458, 1141, + 1247, 1247, 1247, 1248, 1248, 1248, 1145, 1145, 1458, 1145, + 1147, 1147, 1458, 1458, 1147, 1148, 1148, 1458, 1148, 1149, + 1149, 1151, 1151, 1458, 1458, 1151, 1254, 1254, 1254, 1255, + 1255, 1255, 1155, 1155, 1458, 1155, 1157, 1458, 1458, 1157, + + 1158, 1158, 1458, 1158, 1160, 1160, 1458, 1458, 1160, 1161, + 1161, 1458, 1161, 1162, 1162, 1164, 1164, 1458, 1458, 1164, + 1262, 1262, 1262, 1263, 1263, 1263, 1168, 1168, 1458, 1168, + 1169, 1458, 1169, 1171, 1458, 1458, 1171, 1172, 1172, 1458, + 1172, 1174, 1174, 1458, 1458, 1174, 1175, 1175, 1458, 1175, + 1176, 1176, 1178, 1178, 1458, 1458, 1178, 1270, 1270, 1270, + 1271, 1271, 1271, 1182, 1182, 1458, 1182, 1183, 1458, 1183, + 1185, 1458, 1458, 1185, 1186, 1186, 1458, 1186, 1188, 1188, + 1458, 1458, 1188, 1189, 1189, 1458, 1189, 1190, 1190, 1192, + 1192, 1458, 1458, 1192, 1278, 1278, 1278, 1279, 1279, 1279, + + 1196, 1196, 1458, 1196, 1280, 1458, 1280, 1283, 1458, 1283, + 1286, 1458, 1286, 1287, 1287, 1287, 1292, 1458, 1292, 1291, + 1291, 1291, 1293, 1458, 1293, 53, 53, 53, 1458, 53, + 53, 1301, 1458, 1301, 1300, 1300, 1300, 1302, 1458, 1302, + 1143, 1143, 1143, 1303, 1458, 1303, 1153, 1153, 1153, 1304, + 1458, 1304, 1166, 1166, 1166, 1305, 1458, 1305, 1180, 1180, + 1180, 1306, 1458, 1306, 1194, 1194, 1194, 1237, 1237, 1458, + 1458, 1237, 1310, 1310, 1310, 1311, 1311, 1311, 367, 367, + 367, 1242, 1242, 1458, 1242, 1312, 1312, 1312, 1315, 1458, + 1315, 1316, 1316, 1316, 1317, 1317, 1317, 1320, 1458, 1320, + + 1323, 1458, 1323, 1324, 1324, 1324, 1325, 1325, 1325, 1326, + 1458, 1326, 1329, 1458, 1329, 1332, 1458, 1332, 1333, 1333, + 1333, 1334, 1334, 1334, 1335, 1458, 1335, 1338, 1458, 1338, + 1341, 1458, 1341, 1342, 1342, 1342, 1343, 1343, 1343, 1344, + 1458, 1344, 1347, 1458, 1347, 1350, 1458, 1350, 1351, 1351, + 1351, 1352, 1352, 1352, 1280, 1458, 1280, 1282, 1458, 1458, + 1282, 1283, 1283, 1458, 1283, 1285, 1285, 1458, 1458, 1285, + 1286, 1286, 1458, 1286, 1287, 1287, 1289, 1289, 1458, 1458, + 1289, 1359, 1359, 1359, 1360, 1458, 1360, 1293, 1293, 1458, + 1293, 53, 53, 53, 1458, 53, 53, 1365, 1365, 1365, + + 1239, 1239, 1239, 1367, 1458, 1367, 1368, 1458, 1368, 1369, + 1458, 1369, 1370, 1458, 1370, 1371, 1458, 1371, 1372, 1458, + 1372, 1375, 1458, 1375, 1376, 1376, 1376, 1377, 1377, 1377, + 1378, 1458, 1378, 1314, 1314, 1458, 1458, 1314, 1315, 1315, + 1458, 1315, 1316, 1316, 1381, 1458, 1381, 1319, 1458, 1458, + 1319, 1320, 1320, 1458, 1320, 1322, 1322, 1458, 1458, 1322, + 1323, 1323, 1458, 1323, 1324, 1324, 1385, 1458, 1385, 1326, + 1458, 1326, 1328, 1458, 1458, 1328, 1329, 1329, 1458, 1329, + 1331, 1331, 1458, 1458, 1331, 1332, 1332, 1458, 1332, 1333, + 1333, 1389, 1458, 1389, 1335, 1458, 1335, 1337, 1458, 1458, + + 1337, 1338, 1338, 1458, 1338, 1340, 1340, 1458, 1458, 1340, + 1341, 1341, 1458, 1341, 1342, 1342, 1393, 1458, 1393, 1344, + 1458, 1344, 1346, 1458, 1458, 1346, 1347, 1347, 1458, 1347, + 1349, 1349, 1458, 1458, 1349, 1350, 1350, 1458, 1350, 1351, + 1351, 1397, 1458, 1397, 1398, 1458, 1398, 1401, 1458, 1401, + 1404, 1458, 1404, 1405, 1405, 1405, 1406, 1458, 1406, 53, + 53, 53, 1458, 53, 53, 1410, 1458, 1410, 1312, 1458, + 1312, 1317, 1458, 1317, 1325, 1458, 1325, 1334, 1458, 1334, + 1343, 1458, 1343, 1352, 1458, 1352, 1374, 1374, 1458, 1458, + 1374, 1375, 1375, 1458, 1375, 1376, 1376, 1366, 1458, 1366, + + 1415, 1458, 1415, 1416, 1458, 1416, 1419, 1458, 1419, 1420, + 1458, 1420, 1423, 1458, 1423, 1424, 1458, 1424, 1427, 1458, + 1427, 1428, 1458, 1428, 1431, 1458, 1431, 1400, 1458, 1458, + 1400, 1403, 1403, 1458, 1458, 1403, 1435, 1458, 1435, 1377, + 1458, 1377, 1439, 1458, 1439, 1414, 1458, 1458, 1414, 1418, + 1458, 1458, 1418, 1422, 1458, 1458, 1422, 1426, 1458, 1458, + 1426, 1430, 1458, 1458, 1430, 1445, 1458, 1445, 1448, 1458, + 1448, 1438, 1458, 1458, 1438, 1450, 1458, 1450, 1451, 1458, + 1451, 1452, 1458, 1452, 1453, 1458, 1453, 1454, 1458, 1454, + 1447, 1458, 1458, 1447, 1456, 1458, 1456, 1457, 1458, 1457, + + 3, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458 + } ; + +static yyconst flex_int16_t yy_chk[7455] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 4, 7, 15, 4, 7, 4, 7, + 9, 4, 7, 9, 34, 9, 17, 17, 9, 19, + 19, 4, 7, 34, 24, 27, 27, 105, 9, 4, + 7, 15, 12, 105, 133, 12, 9, 12, 24, 23, + 12, 23, 23, 26, 28, 24, 23, 26, 1242, 28, + + 12, 23, 133, 26, 29, 23, 26, 23, 12, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 94, + 29, 94, 14, 14, 14, 265, 265, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 16, 36, 25, 16, 1243, 16, 36, 36, + 16, 36, 36, 93, 25, 101, 93, 25, 97, 22, + 16, 25, 22, 97, 22, 431, 431, 22, 16, 20, + 20, 20, 20, 20, 20, 20, 20, 22, 33, 30, + 137, 30, 33, 20, 35, 22, 30, 30, 101, 30, + + 137, 33, 33, 30, 41, 33, 35, 33, 35, 106, + 35, 250, 41, 35, 106, 249, 41, 249, 41, 20, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 32, 32, 1247, 21, 83, 250, 39, 102, 39, 21, + 21, 21, 21, 21, 21, 31, 32, 1248, 31, 31, + 32, 31, 39, 31, 32, 31, 32, 31, 37, 39, + 31, 83, 37, 32, 102, 128, 38, 83, 109, 102, + 37, 109, 38, 109, 38, 37, 38, 37, 128, 135, + 38, 44, 38, 38, 44, 655, 44, 655, 135, 44, + 62, 62, 62, 62, 62, 62, 62, 63, 154, 44, + + 63, 336, 63, 220, 652, 63, 336, 44, 48, 48, + 48, 48, 48, 48, 48, 63, 220, 162, 272, 48, + 348, 373, 652, 63, 154, 48, 48, 48, 48, 48, + 48, 49, 49, 49, 49, 49, 49, 49, 433, 440, + 1254, 446, 49, 162, 272, 454, 348, 373, 49, 49, + 49, 49, 49, 49, 50, 50, 50, 50, 50, 50, + 50, 50, 460, 1255, 433, 440, 50, 446, 596, 596, + 460, 454, 50, 50, 50, 50, 50, 50, 52, 52, + 52, 52, 52, 52, 52, 52, 54, 54, 54, 54, + 54, 54, 54, 282, 282, 282, 282, 54, 406, 647, + + 647, 479, 409, 54, 54, 54, 54, 54, 54, 56, + 479, 406, 56, 282, 56, 352, 409, 56, 368, 369, + 56, 56, 56, 56, 56, 56, 56, 56, 511, 352, + 648, 56, 368, 369, 1262, 56, 648, 56, 56, 56, + 56, 56, 56, 152, 481, 152, 152, 152, 152, 152, + 152, 152, 535, 481, 511, 352, 152, 551, 368, 369, + 535, 657, 152, 152, 152, 152, 152, 152, 153, 153, + 153, 153, 153, 153, 153, 153, 545, 639, 1263, 657, + 153, 604, 153, 551, 545, 639, 153, 153, 153, 153, + 153, 153, 264, 264, 264, 264, 264, 264, 264, 275, + + 275, 275, 275, 275, 275, 275, 449, 604, 153, 155, + 155, 155, 155, 155, 155, 155, 155, 607, 613, 1270, + 449, 155, 554, 554, 554, 554, 1271, 155, 155, 155, + 155, 155, 155, 156, 156, 156, 156, 156, 156, 156, + 156, 156, 1278, 607, 613, 156, 449, 620, 632, 666, + 666, 156, 156, 156, 156, 156, 156, 157, 157, 157, + 157, 157, 157, 157, 157, 159, 159, 159, 159, 159, + 159, 159, 159, 620, 632, 649, 159, 673, 650, 714, + 649, 650, 159, 159, 159, 159, 159, 159, 161, 161, + 161, 161, 161, 161, 161, 161, 161, 656, 1279, 1283, + + 161, 656, 161, 673, 306, 714, 161, 161, 161, 161, + 161, 161, 306, 358, 358, 358, 358, 358, 358, 358, + 1286, 1287, 450, 1291, 515, 306, 729, 653, 161, 258, + 258, 258, 258, 258, 258, 258, 450, 653, 515, 726, + 258, 306, 1293, 731, 729, 1299, 258, 258, 258, 258, + 258, 258, 260, 260, 260, 260, 260, 260, 260, 651, + 675, 731, 450, 260, 515, 726, 758, 761, 651, 260, + 260, 260, 260, 260, 260, 261, 261, 261, 261, 261, + 261, 261, 261, 263, 263, 263, 263, 263, 263, 263, + 696, 707, 758, 761, 263, 764, 675, 730, 696, 707, + + 263, 263, 263, 263, 263, 263, 266, 266, 266, 266, + 266, 266, 266, 266, 1300, 730, 1310, 1311, 266, 1315, + 1316, 764, 730, 1320, 266, 266, 266, 266, 266, 266, + 268, 268, 268, 268, 268, 268, 268, 268, 271, 271, + 271, 271, 271, 271, 271, 271, 271, 812, 341, 542, + 271, 1323, 271, 341, 1324, 812, 271, 271, 271, 271, + 271, 271, 341, 542, 341, 341, 770, 341, 362, 362, + 362, 362, 362, 362, 362, 741, 543, 732, 271, 276, + 276, 276, 276, 276, 276, 276, 276, 276, 1329, 542, + 543, 276, 770, 741, 741, 732, 546, 276, 276, 276, + + 276, 276, 276, 277, 277, 277, 277, 277, 277, 277, + 546, 1332, 732, 1333, 277, 1338, 543, 737, 1341, 743, + 277, 277, 277, 277, 277, 277, 346, 547, 346, 346, + 346, 346, 346, 346, 346, 737, 546, 743, 1342, 346, + 737, 547, 744, 738, 748, 346, 346, 346, 346, 346, + 346, 347, 347, 347, 347, 347, 347, 347, 347, 1347, + 744, 738, 748, 347, 738, 347, 1350, 547, 1351, 347, + 347, 347, 347, 347, 347, 430, 430, 430, 430, 430, + 430, 430, 458, 458, 458, 458, 458, 458, 458, 615, + 665, 347, 349, 349, 349, 349, 349, 349, 349, 349, + + 665, 1359, 1375, 615, 349, 1376, 819, 739, 1401, 616, + 349, 349, 349, 349, 349, 349, 353, 353, 353, 353, + 353, 353, 353, 616, 819, 739, 777, 353, 739, 615, + 750, 750, 742, 353, 353, 353, 353, 353, 353, 354, + 354, 354, 354, 354, 354, 354, 354, 1404, 750, 616, + 742, 354, 777, 742, 789, 792, 1415, 354, 354, 354, + 354, 354, 354, 355, 355, 355, 355, 355, 355, 355, + 355, 357, 357, 357, 357, 357, 357, 357, 804, 860, + 789, 792, 357, 1419, 820, 821, 1423, 860, 357, 357, + 357, 357, 357, 357, 361, 361, 361, 361, 361, 361, + + 361, 361, 820, 821, 804, 361, 1427, 820, 821, 822, + 824, 361, 361, 361, 361, 361, 361, 363, 363, 363, + 363, 363, 363, 363, 363, 363, 871, 822, 824, 363, + 1431, 826, 822, 824, 871, 363, 363, 363, 363, 363, + 363, 364, 364, 364, 364, 364, 364, 364, 364, 826, + 1439, 1448, 364, 835, 826, 827, 829, 831, 364, 364, + 364, 364, 364, 364, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 827, 829, 831, 370, 829, 827, 835, + 913, 916, 370, 370, 370, 370, 370, 370, 372, 372, + 372, 372, 372, 372, 372, 372, 372, 883, 913, 916, + + 372, 891, 372, 913, 903, 883, 372, 372, 372, 372, + 372, 372, 462, 462, 462, 462, 462, 462, 462, 528, + 528, 528, 528, 528, 528, 528, 1241, 891, 372, 392, + 903, 926, 1240, 392, 929, 917, 392, 910, 623, 392, + 624, 392, 392, 392, 392, 424, 424, 424, 424, 424, + 424, 424, 623, 917, 624, 910, 424, 926, 910, 918, + 929, 658, 424, 424, 424, 424, 424, 424, 426, 426, + 426, 426, 426, 426, 426, 658, 999, 918, 623, 426, + 624, 932, 935, 941, 999, 426, 426, 426, 426, 426, + 426, 427, 427, 427, 427, 427, 427, 427, 427, 429, + + 429, 429, 429, 429, 429, 429, 948, 932, 935, 941, + 429, 960, 915, 922, 1239, 1009, 429, 429, 429, 429, + 429, 429, 432, 432, 432, 432, 432, 432, 432, 432, + 915, 922, 948, 1009, 432, 1235, 432, 960, 915, 1232, + 432, 432, 432, 432, 432, 432, 533, 533, 533, 533, + 533, 533, 533, 537, 537, 537, 537, 537, 537, 537, + 733, 627, 432, 434, 434, 434, 434, 434, 434, 434, + 963, 1229, 975, 979, 434, 627, 991, 1226, 733, 661, + 434, 434, 434, 434, 434, 434, 435, 435, 435, 435, + 435, 435, 435, 661, 1223, 733, 963, 435, 975, 979, + + 1037, 627, 991, 435, 435, 435, 435, 435, 435, 436, + 436, 436, 436, 436, 436, 436, 436, 439, 439, 439, + 439, 439, 439, 439, 439, 439, 1037, 628, 1220, 439, + 1207, 439, 1203, 1196, 1195, 439, 439, 439, 439, 439, + 439, 628, 635, 635, 635, 635, 635, 635, 635, 637, + 637, 637, 637, 637, 637, 637, 1017, 439, 445, 445, + 445, 445, 445, 445, 445, 445, 445, 628, 1194, 1190, + 445, 1189, 445, 1186, 1017, 664, 445, 445, 445, 445, + 445, 445, 641, 641, 641, 641, 641, 641, 641, 664, + 689, 689, 689, 689, 689, 689, 689, 734, 445, 451, + + 451, 451, 451, 451, 451, 451, 451, 451, 1182, 1181, + 1090, 451, 1180, 1102, 1119, 734, 1012, 451, 451, 451, + 451, 451, 451, 453, 453, 453, 453, 453, 453, 453, + 453, 453, 734, 1176, 1012, 453, 1090, 453, 1012, 1102, + 1119, 453, 453, 453, 453, 453, 453, 694, 694, 694, + 694, 694, 694, 694, 698, 698, 698, 698, 698, 698, + 698, 717, 736, 453, 463, 463, 463, 463, 463, 463, + 463, 463, 463, 1175, 1172, 717, 463, 1122, 1015, 1168, + 736, 718, 463, 463, 463, 463, 463, 463, 464, 464, + 464, 464, 464, 464, 464, 718, 1015, 736, 1167, 464, + + 1015, 717, 1016, 1122, 1105, 464, 464, 464, 464, 464, + 464, 509, 721, 509, 509, 509, 509, 509, 509, 509, + 1016, 718, 1105, 1166, 509, 1016, 721, 1162, 1161, 1108, + 509, 509, 509, 509, 509, 509, 510, 510, 510, 510, + 510, 510, 510, 510, 1158, 1047, 1105, 1108, 510, 1108, + 510, 1155, 721, 1047, 510, 510, 510, 510, 510, 510, + 703, 703, 703, 703, 703, 703, 703, 705, 705, 705, + 705, 705, 705, 705, 722, 825, 510, 512, 512, 512, + 512, 512, 512, 512, 512, 1125, 1058, 1154, 722, 512, + 1128, 1153, 1131, 825, 1058, 512, 512, 512, 512, 512, + + 512, 516, 516, 516, 516, 516, 516, 516, 516, 1070, + 825, 1125, 1149, 516, 722, 1156, 1128, 1070, 1131, 516, + 516, 516, 516, 516, 516, 517, 517, 517, 517, 517, + 517, 517, 517, 518, 518, 518, 518, 518, 518, 518, + 1082, 1156, 1148, 1145, 518, 1170, 1184, 1218, 1082, 1144, + 518, 518, 518, 518, 518, 518, 519, 519, 519, 519, + 519, 519, 519, 519, 521, 521, 521, 521, 521, 521, + 521, 1170, 1184, 1218, 1281, 521, 1318, 1327, 1106, 1107, + 1109, 521, 521, 521, 521, 521, 521, 522, 522, 522, + 522, 522, 522, 522, 522, 522, 1106, 1107, 1109, 522, + + 1281, 1112, 1318, 1327, 772, 522, 522, 522, 522, 522, + 522, 523, 523, 523, 523, 523, 523, 523, 772, 1112, + 1106, 1107, 523, 1143, 1112, 1113, 1139, 1137, 523, 523, + 523, 523, 523, 523, 527, 527, 527, 527, 527, 527, + 527, 527, 1136, 1113, 772, 527, 1133, 1132, 1129, 1209, + 1110, 527, 527, 527, 527, 527, 527, 529, 529, 529, + 529, 529, 529, 529, 529, 529, 1202, 1209, 1110, 529, + 1126, 1123, 1210, 1211, 1202, 529, 529, 529, 529, 529, + 529, 530, 530, 530, 530, 530, 530, 530, 530, 1110, + 1210, 1211, 530, 1120, 1116, 1212, 1213, 1295, 530, 530, + + 530, 530, 530, 530, 538, 538, 538, 538, 538, 538, + 538, 538, 538, 1212, 1213, 1295, 538, 1104, 1295, 1213, + 1296, 1103, 538, 538, 538, 538, 538, 538, 539, 539, + 539, 539, 539, 539, 539, 539, 1246, 1100, 1296, 539, + 1336, 1296, 1096, 1297, 1246, 539, 539, 539, 539, 539, + 539, 548, 548, 548, 548, 548, 548, 548, 548, 548, + 1253, 1297, 1345, 548, 1399, 1413, 1336, 1095, 1253, 548, + 548, 548, 548, 548, 548, 550, 550, 550, 550, 550, + 550, 550, 550, 550, 1261, 1297, 1092, 550, 1345, 550, + 1399, 1413, 1261, 550, 550, 550, 550, 550, 550, 709, + + 709, 709, 709, 709, 709, 709, 715, 715, 715, 715, + 715, 715, 715, 823, 773, 550, 590, 590, 590, 590, + 590, 590, 590, 1417, 1269, 1421, 1425, 590, 773, 1087, + 1364, 823, 1269, 590, 590, 590, 590, 590, 590, 592, + 592, 592, 592, 592, 592, 592, 823, 1277, 1364, 1417, + 592, 1421, 1425, 1429, 773, 1277, 592, 592, 592, 592, + 592, 592, 593, 593, 593, 593, 593, 593, 593, 593, + 595, 595, 595, 595, 595, 595, 595, 1309, 1358, 1429, + 1437, 595, 1446, 1214, 1407, 1309, 1358, 595, 595, 595, + 595, 595, 595, 597, 597, 597, 597, 597, 597, 597, + + 597, 1214, 1407, 1086, 1083, 597, 1437, 1075, 1446, 1074, + 1214, 597, 597, 597, 597, 597, 597, 598, 598, 598, + 598, 598, 598, 598, 598, 599, 599, 599, 599, 599, + 599, 599, 1405, 1071, 1063, 1062, 599, 1059, 1052, 1051, + 1405, 1048, 599, 599, 599, 599, 599, 599, 600, 600, + 600, 600, 600, 600, 600, 600, 603, 603, 603, 603, + 603, 603, 603, 603, 603, 735, 780, 781, 603, 1043, + 603, 1409, 1042, 784, 603, 603, 603, 603, 603, 603, + 780, 781, 1039, 735, 1038, 1035, 1034, 784, 1031, 1409, + 745, 1028, 740, 1025, 746, 735, 603, 606, 606, 606, + + 606, 606, 606, 606, 606, 606, 780, 781, 745, 606, + 740, 606, 746, 784, 830, 606, 606, 606, 606, 606, + 606, 745, 740, 1021, 746, 752, 752, 752, 752, 752, + 752, 752, 830, 785, 795, 796, 909, 606, 612, 612, + 612, 612, 612, 612, 612, 612, 612, 785, 795, 796, + 612, 830, 612, 1004, 909, 799, 612, 612, 612, 612, + 612, 612, 793, 793, 793, 793, 793, 793, 793, 799, + 1363, 909, 1000, 785, 795, 796, 800, 993, 612, 617, + 617, 617, 617, 617, 617, 617, 617, 617, 1363, 992, + 800, 617, 989, 985, 1436, 799, 1363, 617, 617, 617, + + 617, 617, 617, 619, 619, 619, 619, 619, 619, 619, + 619, 619, 1436, 984, 981, 619, 800, 619, 977, 976, + 973, 619, 619, 619, 619, 619, 619, 808, 808, 808, + 808, 808, 808, 808, 810, 810, 810, 810, 810, 810, + 810, 894, 911, 619, 629, 629, 629, 629, 629, 629, + 629, 629, 629, 969, 968, 894, 629, 965, 962, 961, + 911, 911, 629, 629, 629, 629, 629, 629, 631, 631, + 631, 631, 631, 631, 631, 631, 631, 958, 911, 954, + 631, 894, 631, 953, 1014, 828, 631, 631, 631, 631, + 631, 631, 814, 814, 814, 814, 814, 814, 814, 950, + + 949, 946, 1014, 828, 942, 895, 898, 912, 631, 642, + 642, 642, 642, 642, 642, 642, 642, 642, 828, 895, + 898, 642, 1014, 938, 937, 912, 899, 642, 642, 642, + 642, 642, 642, 643, 643, 643, 643, 643, 643, 643, + 899, 912, 936, 933, 643, 895, 898, 930, 927, 924, + 643, 643, 643, 643, 643, 643, 646, 646, 646, 646, + 646, 646, 646, 923, 905, 904, 899, 646, 906, 907, + 908, 914, 1011, 646, 646, 646, 646, 646, 646, 853, + 853, 853, 853, 853, 853, 853, 906, 907, 908, 914, + 1011, 646, 669, 901, 669, 669, 669, 669, 669, 669, + + 669, 906, 907, 908, 908, 669, 914, 897, 1010, 1011, + 1114, 669, 669, 669, 669, 669, 669, 858, 858, 858, + 858, 858, 858, 858, 943, 944, 1010, 1294, 1114, 669, + 670, 670, 670, 670, 670, 670, 670, 670, 943, 944, + 1010, 896, 670, 1114, 893, 1294, 888, 884, 670, 670, + 670, 670, 670, 670, 862, 862, 862, 862, 862, 862, + 862, 876, 1294, 872, 943, 944, 670, 671, 671, 671, + 671, 671, 671, 671, 867, 867, 867, 867, 867, 867, + 867, 869, 869, 869, 869, 869, 869, 869, 873, 873, + 873, 873, 873, 873, 873, 879, 879, 879, 879, 879, + + 879, 879, 671, 672, 672, 672, 672, 672, 672, 672, + 865, 861, 856, 851, 672, 850, 849, 846, 843, 839, + 672, 672, 672, 672, 672, 672, 674, 674, 674, 674, + 674, 674, 674, 674, 676, 676, 676, 676, 676, 676, + 676, 676, 817, 813, 806, 805, 676, 802, 798, 797, + 794, 791, 676, 676, 676, 676, 676, 676, 677, 677, + 677, 677, 677, 677, 677, 677, 679, 679, 679, 679, + 679, 679, 679, 790, 787, 783, 782, 679, 779, 778, + 775, 771, 768, 679, 679, 679, 679, 679, 679, 680, + 680, 680, 680, 680, 680, 680, 680, 680, 767, 766, + + 765, 680, 762, 759, 756, 755, 951, 680, 680, 680, + 680, 680, 680, 681, 681, 681, 681, 681, 681, 681, + 951, 728, 727, 724, 681, 720, 719, 716, 712, 708, + 681, 681, 681, 681, 681, 681, 683, 683, 683, 683, + 683, 683, 683, 683, 683, 701, 951, 697, 683, 692, + 687, 686, 685, 952, 683, 683, 683, 683, 683, 683, + 684, 684, 684, 684, 684, 684, 684, 952, 682, 678, + 668, 684, 667, 663, 662, 660, 659, 684, 684, 684, + 684, 684, 684, 688, 688, 688, 688, 688, 688, 688, + 688, 654, 644, 952, 688, 640, 634, 633, 630, 626, + + 688, 688, 688, 688, 688, 688, 690, 690, 690, 690, + 690, 690, 690, 690, 690, 625, 622, 621, 690, 618, + 614, 611, 610, 609, 690, 690, 690, 690, 690, 690, + 691, 691, 691, 691, 691, 691, 691, 691, 608, 605, + 602, 691, 601, 594, 591, 589, 585, 691, 691, 691, + 691, 691, 691, 699, 699, 699, 699, 699, 699, 699, + 699, 699, 581, 580, 579, 699, 578, 574, 573, 571, + 570, 699, 699, 699, 699, 699, 699, 700, 700, 700, + 700, 700, 700, 700, 700, 569, 568, 567, 700, 566, + 565, 564, 563, 562, 700, 700, 700, 700, 700, 700, + + 710, 710, 710, 710, 710, 710, 710, 710, 710, 561, + 560, 557, 710, 556, 555, 553, 552, 549, 710, 710, + 710, 710, 710, 710, 711, 711, 711, 711, 711, 711, + 711, 711, 544, 540, 536, 711, 531, 526, 525, 524, + 520, 711, 711, 711, 711, 711, 711, 723, 723, 723, + 723, 723, 723, 723, 723, 723, 514, 513, 508, 723, + 507, 506, 505, 504, 503, 723, 723, 723, 723, 723, + 723, 725, 725, 725, 725, 725, 725, 725, 725, 725, + 502, 501, 500, 725, 499, 725, 498, 496, 493, 725, + 725, 725, 725, 725, 725, 881, 881, 881, 881, 881, + + 881, 881, 885, 885, 885, 885, 885, 885, 885, 955, + 956, 725, 747, 966, 747, 747, 747, 747, 747, 747, + 747, 492, 491, 955, 956, 747, 490, 966, 489, 488, + 747, 747, 747, 747, 747, 747, 747, 749, 749, 749, + 749, 749, 749, 749, 487, 485, 484, 483, 749, 955, + 956, 482, 480, 966, 749, 749, 749, 749, 749, 749, + 751, 751, 751, 751, 751, 751, 751, 478, 477, 476, + 475, 751, 474, 1362, 473, 472, 470, 751, 751, 751, + 751, 751, 751, 753, 753, 753, 753, 753, 753, 753, + 753, 1362, 469, 468, 465, 753, 461, 457, 456, 455, + + 1362, 753, 753, 753, 753, 753, 753, 754, 754, 754, + 754, 754, 754, 754, 754, 757, 757, 757, 757, 757, + 757, 757, 757, 757, 452, 448, 447, 757, 444, 757, + 443, 442, 441, 757, 757, 757, 757, 757, 757, 892, + 892, 892, 892, 892, 892, 892, 964, 964, 964, 964, + 964, 964, 964, 967, 438, 757, 760, 760, 760, 760, + 760, 760, 760, 760, 760, 437, 970, 967, 760, 428, + 760, 425, 971, 982, 760, 760, 760, 760, 760, 760, + 970, 423, 422, 421, 420, 419, 971, 982, 418, 417, + 416, 415, 1361, 967, 983, 414, 760, 763, 763, 763, + + 763, 763, 763, 763, 763, 763, 970, 413, 983, 763, + 1361, 763, 971, 982, 986, 763, 763, 763, 763, 763, + 763, 980, 980, 980, 980, 980, 980, 980, 986, 1361, + 412, 410, 408, 987, 983, 1093, 407, 763, 769, 769, + 769, 769, 769, 769, 769, 769, 769, 987, 405, 1093, + 769, 404, 769, 401, 986, 1094, 769, 769, 769, 769, + 769, 769, 995, 995, 995, 995, 995, 995, 995, 1094, + 400, 398, 396, 987, 1097, 1093, 1098, 395, 769, 774, + 774, 774, 774, 774, 774, 774, 774, 774, 1097, 394, + 1098, 774, 389, 388, 386, 1094, 385, 774, 774, 774, + + 774, 774, 774, 776, 776, 776, 776, 776, 776, 776, + 776, 776, 384, 383, 1097, 776, 1098, 776, 381, 376, + 375, 776, 776, 776, 776, 776, 776, 997, 997, 997, + 997, 997, 997, 997, 1001, 1001, 1001, 1001, 1001, 1001, + 1001, 1140, 374, 776, 786, 786, 786, 786, 786, 786, + 786, 786, 786, 371, 367, 1140, 786, 365, 360, 359, + 356, 1013, 786, 786, 786, 786, 786, 786, 788, 788, + 788, 788, 788, 788, 788, 788, 788, 1006, 1007, 1013, + 788, 1140, 788, 351, 350, 342, 788, 788, 788, 788, + 788, 788, 340, 1013, 339, 1006, 1007, 1040, 1040, 1040, + + 1040, 1040, 1040, 1040, 1141, 334, 1006, 1007, 788, 801, + 801, 801, 801, 801, 801, 801, 801, 801, 1141, 332, + 330, 801, 329, 328, 327, 326, 325, 801, 801, 801, + 801, 801, 801, 803, 803, 803, 803, 803, 803, 803, + 803, 803, 1008, 1146, 1141, 803, 324, 803, 322, 321, + 1408, 803, 803, 803, 803, 803, 803, 1146, 320, 315, + 1008, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1408, 312, + 1147, 1008, 311, 803, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 1146, 1147, 310, 815, 1408, 307, 300, + 299, 1150, 815, 815, 815, 815, 815, 815, 816, 816, + + 816, 816, 816, 816, 816, 1150, 297, 296, 294, 816, + 1147, 292, 291, 290, 288, 816, 816, 816, 816, 816, + 816, 832, 1151, 832, 832, 832, 832, 832, 832, 832, + 284, 1150, 283, 281, 832, 278, 1151, 274, 273, 832, + 832, 832, 832, 832, 832, 832, 833, 833, 833, 833, + 833, 833, 833, 270, 269, 267, 262, 833, 259, 257, + 256, 254, 1151, 833, 833, 833, 833, 833, 833, 834, + 834, 834, 834, 834, 834, 834, 834, 251, 247, 243, + 241, 834, 239, 834, 238, 236, 235, 834, 834, 834, + 834, 834, 834, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + + 1054, 1054, 1054, 1054, 1054, 1054, 1054, 234, 1159, 834, + 836, 836, 836, 836, 836, 836, 836, 233, 232, 231, + 230, 836, 1159, 228, 226, 224, 223, 836, 836, 836, + 836, 836, 836, 837, 837, 837, 837, 837, 837, 837, + 837, 221, 219, 218, 216, 837, 213, 212, 1159, 211, + 209, 837, 837, 837, 837, 837, 837, 838, 838, 838, + 838, 838, 838, 838, 838, 840, 840, 840, 840, 840, + 840, 840, 207, 206, 203, 202, 840, 200, 199, 198, + 197, 196, 840, 840, 840, 840, 840, 840, 841, 841, + 841, 841, 841, 841, 841, 841, 841, 195, 194, 193, + + 841, 192, 191, 190, 189, 1160, 841, 841, 841, 841, + 841, 841, 842, 842, 842, 842, 842, 842, 842, 1160, + 188, 187, 186, 842, 185, 184, 182, 181, 178, 842, + 842, 842, 842, 842, 842, 844, 844, 844, 844, 844, + 844, 844, 844, 844, 177, 1160, 176, 844, 175, 174, + 173, 172, 1163, 844, 844, 844, 844, 844, 844, 845, + 845, 845, 845, 845, 845, 845, 1163, 171, 169, 166, + 845, 165, 164, 163, 160, 158, 845, 845, 845, 845, + 845, 845, 847, 847, 847, 847, 847, 847, 847, 847, + 847, 149, 1163, 148, 847, 147, 146, 145, 144, 1164, + + 847, 847, 847, 847, 847, 847, 848, 848, 848, 848, + 848, 848, 848, 1164, 143, 141, 139, 848, 138, 136, + 134, 132, 131, 848, 848, 848, 848, 848, 848, 852, + 852, 852, 852, 852, 852, 852, 852, 130, 129, 1164, + 852, 127, 126, 125, 124, 123, 852, 852, 852, 852, + 852, 852, 854, 854, 854, 854, 854, 854, 854, 854, + 854, 122, 120, 118, 854, 117, 116, 115, 114, 113, + 854, 854, 854, 854, 854, 854, 855, 855, 855, 855, + 855, 855, 855, 855, 112, 111, 110, 855, 108, 107, + 100, 99, 98, 855, 855, 855, 855, 855, 855, 863, + + 863, 863, 863, 863, 863, 863, 863, 863, 96, 95, + 92, 863, 91, 90, 89, 88, 87, 863, 863, 863, + 863, 863, 863, 864, 864, 864, 864, 864, 864, 864, + 864, 86, 85, 84, 864, 82, 81, 80, 79, 78, + 864, 864, 864, 864, 864, 864, 874, 874, 874, 874, + 874, 874, 874, 874, 874, 77, 76, 75, 874, 74, + 73, 72, 71, 70, 874, 874, 874, 874, 874, 874, + 875, 875, 875, 875, 875, 875, 875, 875, 69, 67, + 66, 875, 65, 51, 43, 42, 40, 875, 875, 875, + 875, 875, 875, 886, 886, 886, 886, 886, 886, 886, + + 886, 886, 18, 10, 8, 886, 3, 0, 0, 0, + 0, 886, 886, 886, 886, 886, 886, 887, 887, 887, + 887, 887, 887, 887, 887, 0, 0, 0, 887, 0, + 0, 0, 0, 0, 887, 887, 887, 887, 887, 887, + 900, 900, 900, 900, 900, 900, 900, 900, 900, 0, + 0, 0, 900, 0, 0, 0, 0, 0, 900, 900, + 900, 900, 900, 900, 902, 902, 902, 902, 902, 902, + 902, 902, 902, 0, 0, 0, 902, 0, 902, 0, + 0, 0, 902, 902, 902, 902, 902, 902, 1056, 1056, + 1056, 1056, 1056, 1056, 1056, 1060, 1060, 1060, 1060, 1060, + + 1060, 1060, 0, 0, 902, 919, 919, 919, 919, 919, + 919, 919, 919, 919, 0, 0, 0, 0, 919, 0, + 0, 0, 0, 919, 919, 919, 919, 919, 919, 919, + 920, 920, 920, 920, 920, 920, 920, 920, 921, 921, + 921, 921, 921, 921, 921, 921, 921, 1066, 1066, 1066, + 1066, 1066, 1066, 1066, 0, 0, 921, 925, 925, 925, + 925, 925, 925, 925, 925, 925, 0, 0, 0, 925, + 0, 925, 0, 0, 0, 925, 925, 925, 925, 925, + 925, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1072, 1072, + 1072, 1072, 1072, 1072, 1072, 0, 0, 925, 928, 928, + + 928, 928, 928, 928, 928, 928, 928, 0, 0, 0, + 928, 0, 928, 0, 0, 0, 928, 928, 928, 928, + 928, 928, 1078, 1078, 1078, 1078, 1078, 1078, 1078, 1080, + 1080, 1080, 1080, 1080, 1080, 1080, 0, 0, 928, 931, + 931, 931, 931, 931, 931, 931, 931, 931, 0, 0, + 0, 931, 0, 931, 0, 0, 0, 931, 931, 931, + 931, 931, 931, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1091, 1091, 1091, 1091, 1091, 1091, 1091, 1111, 0, 931, + 934, 934, 934, 934, 934, 934, 934, 934, 934, 0, + 1173, 1174, 934, 0, 934, 1111, 0, 0, 934, 934, + + 934, 934, 934, 934, 1173, 1174, 1111, 1134, 1134, 1134, + 1134, 1134, 1134, 1134, 0, 1177, 0, 0, 0, 1178, + 934, 939, 939, 939, 939, 939, 939, 939, 939, 1177, + 1173, 1174, 939, 1178, 0, 0, 0, 0, 939, 939, + 939, 939, 939, 939, 940, 940, 940, 940, 940, 940, + 940, 940, 940, 0, 0, 1177, 940, 0, 940, 1178, + 0, 0, 940, 940, 940, 940, 940, 940, 1157, 1157, + 1157, 1157, 1157, 1157, 1157, 1171, 1171, 1171, 1171, 1171, + 1171, 1171, 1187, 0, 940, 945, 945, 945, 945, 945, + 945, 945, 945, 945, 0, 0, 1187, 945, 0, 0, + + 0, 0, 0, 945, 945, 945, 945, 945, 945, 947, + 947, 947, 947, 947, 947, 947, 947, 947, 0, 0, + 0, 947, 1187, 947, 0, 0, 1188, 947, 947, 947, + 947, 947, 947, 1185, 1185, 1185, 1185, 1185, 1185, 1185, + 1188, 0, 0, 0, 0, 1191, 0, 1192, 0, 947, + 957, 957, 957, 957, 957, 957, 957, 957, 957, 1191, + 0, 1192, 957, 0, 0, 0, 1188, 0, 957, 957, + 957, 957, 957, 957, 959, 959, 959, 959, 959, 959, + 959, 959, 959, 0, 0, 1191, 959, 1192, 959, 0, + 0, 0, 959, 959, 959, 959, 959, 959, 1198, 1198, + + 1198, 1198, 1198, 1198, 1198, 1200, 1200, 1200, 1200, 1200, + 1200, 1200, 1236, 0, 959, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 0, 0, 1236, 972, 0, 0, + 0, 0, 0, 972, 972, 972, 972, 972, 972, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 0, 0, + 0, 974, 1236, 974, 0, 0, 1237, 974, 974, 974, + 974, 974, 974, 1204, 1204, 1204, 1204, 1204, 1204, 1204, + 1237, 1244, 1244, 1244, 1244, 1244, 1244, 1244, 0, 974, + 988, 988, 988, 988, 988, 988, 988, 988, 988, 0, + 0, 0, 988, 0, 0, 0, 1237, 1215, 988, 988, + + 988, 988, 988, 988, 990, 990, 990, 990, 990, 990, + 990, 990, 990, 1216, 0, 1215, 990, 0, 990, 0, + 0, 0, 990, 990, 990, 990, 990, 990, 1215, 0, + 0, 1216, 1249, 1249, 1249, 1249, 1249, 1249, 1249, 0, + 0, 1284, 1216, 0, 990, 1002, 1002, 1002, 1002, 1002, + 1002, 1002, 1002, 1002, 0, 1284, 0, 1002, 0, 0, + 0, 0, 1285, 1002, 1002, 1002, 1002, 1002, 1002, 1003, + 1003, 1003, 1003, 1003, 1003, 1003, 1285, 0, 0, 0, + 1003, 1284, 0, 0, 0, 0, 1003, 1003, 1003, 1003, + 1003, 1003, 1018, 1018, 1018, 1018, 1018, 1018, 1018, 1018, + + 1018, 0, 1285, 0, 0, 1018, 0, 0, 0, 0, + 1018, 1018, 1018, 1018, 1018, 1018, 1018, 1019, 1019, 1019, + 1019, 1019, 1019, 1019, 1019, 1020, 1020, 1020, 1020, 1020, + 1020, 1020, 1020, 1020, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 0, 1288, 1020, 1022, 1022, 1022, 1022, 1022, 1022, + 1022, 0, 0, 0, 0, 1022, 1288, 0, 0, 0, + 0, 1022, 1022, 1022, 1022, 1022, 1022, 1023, 1023, 1023, + 1023, 1023, 1023, 1023, 1023, 1023, 0, 0, 0, 1023, + 0, 0, 1288, 0, 1289, 1023, 1023, 1023, 1023, 1023, + 1023, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1289, 0, + + 0, 0, 1024, 0, 0, 0, 0, 0, 1024, 1024, + 1024, 1024, 1024, 1024, 1026, 1026, 1026, 1026, 1026, 1026, + 1026, 1026, 1026, 0, 1289, 0, 1026, 0, 0, 0, + 0, 1313, 1026, 1026, 1026, 1026, 1026, 1026, 1027, 1027, + 1027, 1027, 1027, 1027, 1027, 1313, 0, 0, 0, 1027, + 0, 0, 0, 0, 0, 1027, 1027, 1027, 1027, 1027, + 1027, 1029, 1029, 1029, 1029, 1029, 1029, 1029, 1029, 1029, + 0, 1313, 0, 1029, 0, 0, 0, 0, 1314, 1029, + 1029, 1029, 1029, 1029, 1029, 1030, 1030, 1030, 1030, 1030, + 1030, 1030, 1314, 0, 0, 0, 1030, 0, 0, 0, + + 0, 0, 1030, 1030, 1030, 1030, 1030, 1030, 1032, 1032, + 1032, 1032, 1032, 1032, 1032, 1032, 1032, 0, 1314, 0, + 1032, 0, 0, 0, 0, 1321, 1032, 1032, 1032, 1032, + 1032, 1032, 1033, 1033, 1033, 1033, 1033, 1033, 1033, 1321, + 0, 0, 0, 1033, 0, 0, 0, 0, 0, 1033, + 1033, 1033, 1033, 1033, 1033, 1036, 1036, 1036, 1036, 1036, + 1036, 1036, 1036, 1036, 0, 1321, 0, 1036, 0, 1036, + 0, 0, 0, 1036, 1036, 1036, 1036, 1036, 1036, 1257, + 1257, 1257, 1257, 1257, 1257, 1257, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1322, 0, 1036, 1041, 1041, 1041, 1041, + + 1041, 1041, 1041, 1041, 1041, 0, 0, 1322, 1041, 0, + 0, 0, 0, 0, 1041, 1041, 1041, 1041, 1041, 1041, + 1050, 1050, 1050, 1050, 1050, 1050, 1050, 1050, 1050, 0, + 0, 0, 1050, 1322, 0, 0, 0, 0, 1050, 1050, + 1050, 1050, 1050, 1050, 1061, 1061, 1061, 1061, 1061, 1061, + 1061, 1061, 1061, 0, 0, 0, 1061, 0, 0, 0, + 0, 0, 1061, 1061, 1061, 1061, 1061, 1061, 1073, 1073, + 1073, 1073, 1073, 1073, 1073, 1073, 1073, 0, 0, 0, + 1073, 0, 0, 0, 0, 0, 1073, 1073, 1073, 1073, + 1073, 1073, 1085, 1085, 1085, 1085, 1085, 1085, 1085, 1085, + + 1085, 0, 0, 0, 1085, 0, 0, 0, 0, 0, + 1085, 1085, 1085, 1085, 1085, 1085, 1099, 1099, 1099, 1099, + 1099, 1099, 1099, 1099, 1099, 0, 0, 0, 1099, 0, + 0, 0, 0, 0, 1099, 1099, 1099, 1099, 1099, 1099, + 1101, 1101, 1101, 1101, 1101, 1101, 1101, 1101, 1101, 0, + 0, 0, 1101, 0, 1101, 0, 0, 0, 1101, 1101, + 1101, 1101, 1101, 1101, 1265, 1265, 1265, 1265, 1265, 1265, + 1265, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 0, 0, + 1101, 1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115, + 1273, 1273, 1273, 1273, 1273, 1273, 1273, 0, 1330, 1115, + + 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 0, 0, + 0, 1117, 1330, 0, 0, 0, 0, 1117, 1117, 1117, + 1117, 1117, 1117, 1118, 1118, 1118, 1118, 1118, 1118, 1118, + 1118, 1118, 0, 0, 0, 1118, 0, 1118, 1330, 0, + 0, 1118, 1118, 1118, 1118, 1118, 1118, 1275, 1275, 1275, + 1275, 1275, 1275, 1275, 1282, 1282, 1282, 1282, 1282, 1282, + 1282, 0, 0, 1118, 1121, 1121, 1121, 1121, 1121, 1121, + 1121, 1121, 1121, 0, 0, 0, 1121, 0, 1121, 0, + 0, 0, 1121, 1121, 1121, 1121, 1121, 1121, 1307, 1307, + 1307, 1307, 1307, 1307, 1307, 1319, 1319, 1319, 1319, 1319, + + 1319, 1319, 1331, 0, 1121, 1124, 1124, 1124, 1124, 1124, + 1124, 1124, 1124, 1124, 0, 0, 1331, 1124, 0, 1124, + 0, 0, 1339, 1124, 1124, 1124, 1124, 1124, 1124, 1328, + 1328, 1328, 1328, 1328, 1328, 1328, 1339, 0, 0, 0, + 0, 1340, 1331, 1348, 0, 1124, 1127, 1127, 1127, 1127, + 1127, 1127, 1127, 1127, 1127, 1340, 0, 1348, 1127, 0, + 1127, 0, 1339, 1349, 1127, 1127, 1127, 1127, 1127, 1127, + 1337, 1337, 1337, 1337, 1337, 1337, 1337, 1349, 0, 0, + 0, 1340, 0, 1348, 0, 0, 1127, 1130, 1130, 1130, + 1130, 1130, 1130, 1130, 1130, 1130, 0, 0, 0, 1130, + + 0, 1130, 0, 1349, 0, 1130, 1130, 1130, 1130, 1130, + 1130, 1346, 1346, 1346, 1346, 1346, 1346, 1346, 1354, 1354, + 1354, 1354, 1354, 1354, 1354, 1373, 0, 1130, 1135, 1135, + 1135, 1135, 1135, 1135, 1135, 1135, 1135, 0, 0, 1373, + 1135, 0, 0, 0, 0, 0, 1135, 1135, 1135, 1135, + 1135, 1135, 1142, 1142, 1142, 1142, 1142, 1142, 1142, 1142, + 1142, 0, 0, 0, 1142, 1373, 0, 0, 0, 0, + 1142, 1142, 1142, 1142, 1142, 1142, 1152, 1152, 1152, 1152, + 1152, 1152, 1152, 1152, 1152, 0, 0, 0, 1152, 0, + 0, 0, 0, 0, 1152, 1152, 1152, 1152, 1152, 1152, + + 1165, 1165, 1165, 1165, 1165, 1165, 1165, 1165, 1165, 0, + 0, 0, 1165, 0, 0, 0, 0, 0, 1165, 1165, + 1165, 1165, 1165, 1165, 1179, 1179, 1179, 1179, 1179, 1179, + 1179, 1179, 1179, 0, 0, 0, 1179, 0, 0, 0, + 0, 0, 1179, 1179, 1179, 1179, 1179, 1179, 1193, 1193, + 1193, 1193, 1193, 1193, 1193, 1193, 1193, 0, 0, 0, + 1193, 0, 0, 0, 0, 0, 1193, 1193, 1193, 1193, + 1193, 1193, 1205, 1205, 1205, 1205, 1205, 1205, 1205, 1205, + 1205, 0, 0, 0, 1205, 0, 0, 0, 0, 0, + 1205, 1205, 1205, 1205, 1205, 1205, 1217, 1217, 1217, 1217, + + 1217, 1217, 1217, 1217, 1217, 0, 0, 0, 1217, 0, + 1217, 0, 0, 1374, 1217, 1217, 1217, 1217, 1217, 1217, + 1356, 1356, 1356, 1356, 1356, 1356, 1356, 1374, 1379, 1379, + 1379, 1379, 1379, 1379, 1379, 0, 1217, 1221, 1221, 1221, + 1221, 1221, 1221, 1221, 1221, 1221, 0, 0, 0, 1221, + 0, 0, 0, 1374, 0, 1221, 1221, 1221, 1221, 1221, + 1221, 1224, 1224, 1224, 1224, 1224, 1224, 1224, 1224, 1224, + 0, 0, 0, 1224, 0, 0, 0, 0, 0, 1224, + 1224, 1224, 1224, 1224, 1224, 1227, 1227, 1227, 1227, 1227, + 1227, 1227, 1227, 1227, 0, 0, 0, 1227, 0, 0, + + 0, 0, 0, 1227, 1227, 1227, 1227, 1227, 1227, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 0, 0, + 0, 1230, 0, 0, 0, 0, 0, 1230, 1230, 1230, + 1230, 1230, 1230, 1233, 1233, 1233, 1233, 1233, 1233, 1233, + 1233, 1233, 0, 0, 0, 1233, 0, 0, 0, 0, + 0, 1233, 1233, 1233, 1233, 1233, 1233, 1238, 1238, 1238, + 1238, 1238, 1238, 1238, 1238, 1238, 0, 0, 0, 1238, + 0, 0, 0, 0, 0, 1238, 1238, 1238, 1238, 1238, + 1238, 1290, 1290, 1290, 1290, 1290, 1290, 1290, 1290, 1290, + 0, 0, 0, 1290, 0, 0, 0, 0, 0, 1290, + + 1290, 1290, 1290, 1290, 1290, 1298, 1298, 1298, 1298, 1298, + 1298, 1298, 1298, 1298, 0, 0, 0, 1298, 0, 0, + 0, 0, 0, 1298, 1298, 1298, 1298, 1298, 1298, 1383, + 1383, 1383, 1383, 1383, 1383, 1383, 1387, 1387, 1387, 1387, + 1387, 1387, 1387, 1391, 1391, 1391, 1391, 1391, 1391, 1391, + 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1400, 1400, 1400, + 1400, 1400, 1400, 1400, 1402, 1403, 1411, 1411, 1411, 1411, + 1411, 1411, 1411, 0, 0, 0, 0, 0, 1402, 1403, + 1414, 1414, 1414, 1414, 1414, 1414, 1414, 1418, 1418, 1418, + 1418, 1418, 1418, 1418, 1422, 1422, 1422, 1422, 1422, 1422, + + 1422, 0, 0, 0, 1402, 1403, 1426, 1426, 1426, 1426, + 1426, 1426, 1426, 1430, 1430, 1430, 1430, 1430, 1430, 1430, + 1433, 1433, 1433, 1433, 1433, 1433, 1433, 1438, 1438, 1438, + 1438, 1438, 1438, 1438, 1447, 1447, 1447, 1447, 1447, 1447, + 1447, 1459, 0, 0, 0, 0, 1459, 1459, 1459, 1460, + 0, 1460, 1460, 1460, 1460, 1460, 1460, 1460, 1461, 0, + 1461, 1462, 1462, 1462, 1463, 1463, 1463, 1464, 1464, 1464, + 1465, 1465, 1465, 1466, 1466, 1466, 1467, 1467, 1467, 1468, + 1468, 1468, 1469, 1469, 1469, 1470, 1470, 1470, 1471, 0, + 1471, 1472, 1472, 1472, 1473, 1473, 1473, 1474, 1474, 1474, + + 1475, 1475, 1475, 1476, 0, 1476, 1477, 1477, 1477, 1478, + 1478, 0, 0, 1478, 1479, 1479, 1479, 1480, 1480, 1480, + 1481, 1481, 1481, 1482, 1482, 1482, 1483, 1483, 1483, 1484, + 1484, 1484, 1485, 1485, 1485, 1486, 1486, 1486, 1487, 1487, + 1487, 1488, 1488, 0, 0, 1488, 1489, 1489, 1489, 1490, + 1490, 1490, 1491, 0, 1491, 1492, 1492, 1492, 1493, 1493, + 1493, 1494, 0, 1494, 1495, 1495, 1495, 1496, 1496, 1496, + 1497, 1497, 1497, 1498, 1498, 1498, 1499, 1499, 1499, 1500, + 0, 1500, 1501, 0, 1501, 1502, 1502, 1502, 1503, 1503, + 1503, 1504, 0, 1504, 1505, 1505, 0, 0, 1505, 1506, + + 1506, 0, 0, 1506, 1507, 1507, 1507, 1508, 1508, 1508, + 1509, 1509, 0, 1509, 1510, 1510, 1510, 1511, 1511, 1511, + 1512, 1512, 1512, 1513, 1513, 1513, 1514, 1514, 1514, 1515, + 1515, 1515, 1516, 1516, 1516, 1517, 1517, 0, 0, 1517, + 1518, 1518, 1518, 1519, 1519, 1519, 1520, 1520, 0, 1520, + 1521, 1521, 0, 0, 1521, 1522, 1522, 0, 1522, 1523, + 1523, 1524, 1524, 0, 0, 1524, 1525, 1525, 1525, 1526, + 1526, 1526, 1527, 1527, 0, 1527, 1528, 0, 1528, 1529, + 0, 1529, 1530, 1530, 1530, 1531, 1531, 1531, 1532, 0, + 1532, 1533, 1533, 1533, 1534, 1534, 1534, 1535, 1535, 1535, + + 1536, 1536, 1536, 1537, 1537, 1537, 1538, 1538, 1538, 1539, + 0, 1539, 1540, 0, 1540, 1541, 1541, 1541, 1542, 1542, + 1542, 1543, 0, 1543, 1544, 0, 1544, 1545, 0, 1545, + 1546, 1546, 1546, 1547, 1547, 1547, 1548, 0, 1548, 1549, + 0, 0, 1549, 1550, 1550, 0, 1550, 1551, 1551, 0, + 0, 1551, 1552, 1552, 0, 1552, 1553, 1553, 1554, 1554, + 0, 0, 1554, 1555, 1555, 1555, 1556, 1556, 1556, 1557, + 1557, 0, 1557, 1558, 1558, 1558, 0, 1558, 1558, 1559, + 1559, 1559, 1560, 1560, 1560, 1561, 1561, 1561, 1562, 1562, + 1562, 1563, 1563, 1563, 1564, 1564, 1564, 1565, 1565, 1565, + + 1566, 1566, 1566, 1567, 1567, 0, 0, 1567, 1568, 1568, + 1568, 1569, 1569, 1569, 1570, 1570, 0, 1570, 1571, 1571, + 0, 0, 1571, 1572, 1572, 0, 1572, 1573, 1573, 1574, + 1574, 0, 0, 1574, 1575, 1575, 1575, 1576, 1576, 1576, + 1577, 1577, 0, 1577, 1578, 0, 0, 1578, 1579, 1579, + 0, 1579, 1580, 1580, 0, 0, 1580, 1581, 1581, 0, + 1581, 1582, 1582, 1583, 1583, 0, 0, 1583, 1584, 1584, + 1584, 1585, 1585, 1585, 1586, 1586, 0, 1586, 1587, 0, + 1587, 1588, 0, 1588, 1589, 0, 1589, 1590, 1590, 1590, + 1591, 1591, 1591, 1592, 0, 1592, 1593, 1593, 1593, 0, + + 1593, 1593, 1594, 1594, 1594, 1595, 1595, 1595, 1596, 1596, + 1596, 1597, 1597, 1597, 1598, 1598, 1598, 1599, 1599, 1599, + 1600, 1600, 1600, 1601, 0, 1601, 1602, 0, 1602, 1603, + 1603, 1603, 1604, 1604, 1604, 1605, 0, 1605, 1606, 0, + 1606, 1607, 0, 1607, 1608, 1608, 1608, 1609, 1609, 1609, + 1610, 0, 1610, 1611, 0, 1611, 1612, 0, 1612, 1613, + 0, 1613, 1614, 1614, 1614, 1615, 1615, 1615, 1616, 0, + 1616, 1617, 0, 1617, 1618, 0, 0, 1618, 1619, 1619, + 0, 1619, 1620, 1620, 0, 0, 1620, 1621, 1621, 0, + 1621, 1622, 1622, 1623, 1623, 0, 0, 1623, 1624, 1624, + + 1624, 1625, 1625, 1625, 1626, 1626, 0, 1626, 1627, 1627, + 1627, 0, 1627, 1627, 1628, 1628, 1628, 1629, 1629, 1629, + 1630, 1630, 1630, 1631, 1631, 1631, 1632, 1632, 1632, 1633, + 1633, 1633, 1634, 1634, 1634, 1635, 1635, 1635, 1636, 1636, + 0, 0, 1636, 1637, 1637, 1637, 1638, 1638, 1638, 1639, + 1639, 0, 1639, 1640, 1640, 0, 0, 1640, 1641, 1641, + 0, 1641, 1642, 1642, 1643, 1643, 0, 0, 1643, 1644, + 1644, 1644, 1645, 1645, 1645, 1646, 1646, 0, 1646, 1647, + 0, 0, 1647, 1648, 1648, 0, 1648, 1649, 1649, 0, + 0, 1649, 1650, 1650, 0, 1650, 1651, 1651, 1652, 1652, + + 0, 0, 1652, 1653, 1653, 1653, 1654, 1654, 1654, 1655, + 1655, 0, 1655, 1656, 0, 1656, 1657, 0, 0, 1657, + 1658, 1658, 0, 1658, 1659, 1659, 0, 0, 1659, 1660, + 1660, 0, 1660, 1661, 1661, 1662, 1662, 0, 0, 1662, + 1663, 1663, 1663, 1664, 1664, 1664, 1665, 1665, 0, 1665, + 1666, 0, 1666, 1667, 0, 1667, 1668, 0, 1668, 1669, + 1669, 1669, 1670, 1670, 1670, 1671, 0, 1671, 1672, 1672, + 1672, 0, 1672, 1672, 1673, 1673, 1673, 1674, 1674, 1674, + 1675, 1675, 1675, 1676, 1676, 1676, 1677, 1677, 1677, 1678, + 1678, 1678, 1679, 1679, 1679, 1680, 1680, 1680, 1681, 1681, + + 1681, 1682, 1682, 1682, 1683, 0, 1683, 1684, 0, 1684, + 1685, 1685, 1685, 1686, 1686, 1686, 1687, 1687, 1687, 1688, + 0, 1688, 1689, 0, 1689, 1690, 0, 1690, 1691, 1691, + 1691, 1692, 1692, 1692, 1693, 1693, 1693, 1694, 0, 1694, + 1695, 0, 1695, 1696, 0, 1696, 1697, 0, 1697, 1698, + 1698, 1698, 1699, 1699, 1699, 1700, 1700, 1700, 1701, 0, + 1701, 1702, 0, 1702, 1703, 0, 1703, 1704, 0, 1704, + 1705, 1705, 1705, 1706, 1706, 1706, 1707, 1707, 1707, 1708, + 0, 1708, 1709, 0, 1709, 1710, 0, 0, 1710, 1711, + 1711, 0, 1711, 1712, 1712, 0, 0, 1712, 1713, 1713, + + 0, 1713, 1714, 1714, 1715, 1715, 0, 0, 1715, 1716, + 1716, 1716, 1717, 1717, 1717, 1718, 1718, 0, 1718, 1719, + 1719, 1719, 0, 1719, 1719, 1720, 1720, 1720, 1721, 1721, + 1721, 1722, 1722, 1722, 1723, 1723, 1723, 1724, 1724, 1724, + 1725, 1725, 1725, 1726, 1726, 1726, 1727, 1727, 1727, 1728, + 0, 1728, 1729, 1729, 1729, 1730, 1730, 0, 0, 1730, + 1731, 1731, 1731, 1732, 1732, 1732, 1733, 1733, 0, 1733, + 1734, 1734, 0, 0, 1734, 1735, 1735, 0, 1735, 1736, + 1736, 1737, 1737, 0, 0, 1737, 1738, 1738, 1738, 1739, + 1739, 1739, 1740, 1740, 0, 1740, 1741, 0, 0, 1741, + + 1742, 1742, 0, 1742, 1743, 1743, 0, 0, 1743, 1744, + 1744, 0, 1744, 1745, 1745, 1746, 1746, 0, 0, 1746, + 1747, 1747, 1747, 1748, 1748, 1748, 1749, 1749, 0, 1749, + 1750, 0, 1750, 1751, 0, 0, 1751, 1752, 1752, 0, + 1752, 1753, 1753, 0, 0, 1753, 1754, 1754, 0, 1754, + 1755, 1755, 1756, 1756, 0, 0, 1756, 1757, 1757, 1757, + 1758, 1758, 1758, 1759, 1759, 0, 1759, 1760, 0, 1760, + 1761, 0, 0, 1761, 1762, 1762, 0, 1762, 1763, 1763, + 0, 0, 1763, 1764, 1764, 0, 1764, 1765, 1765, 1766, + 1766, 0, 0, 1766, 1767, 1767, 1767, 1768, 1768, 1768, + + 1769, 1769, 0, 1769, 1770, 0, 1770, 1771, 0, 1771, + 1772, 0, 1772, 1773, 1773, 1773, 1774, 0, 1774, 1775, + 1775, 1775, 1776, 0, 1776, 1777, 1777, 1777, 0, 1777, + 1777, 1778, 0, 1778, 1779, 1779, 1779, 1780, 0, 1780, + 1781, 1781, 1781, 1782, 0, 1782, 1783, 1783, 1783, 1784, + 0, 1784, 1785, 1785, 1785, 1786, 0, 1786, 1787, 1787, + 1787, 1788, 0, 1788, 1789, 1789, 1789, 1790, 1790, 0, + 0, 1790, 1791, 1791, 1791, 1792, 1792, 1792, 1793, 1793, + 1793, 1794, 1794, 0, 1794, 1795, 1795, 1795, 1796, 0, + 1796, 1797, 1797, 1797, 1798, 1798, 1798, 1799, 0, 1799, + + 1800, 0, 1800, 1801, 1801, 1801, 1802, 1802, 1802, 1803, + 0, 1803, 1804, 0, 1804, 1805, 0, 1805, 1806, 1806, + 1806, 1807, 1807, 1807, 1808, 0, 1808, 1809, 0, 1809, + 1810, 0, 1810, 1811, 1811, 1811, 1812, 1812, 1812, 1813, + 0, 1813, 1814, 0, 1814, 1815, 0, 1815, 1816, 1816, + 1816, 1817, 1817, 1817, 1818, 0, 1818, 1819, 0, 0, + 1819, 1820, 1820, 0, 1820, 1821, 1821, 0, 0, 1821, + 1822, 1822, 0, 1822, 1823, 1823, 1824, 1824, 0, 0, + 1824, 1825, 1825, 1825, 1826, 0, 1826, 1827, 1827, 0, + 1827, 1828, 1828, 1828, 0, 1828, 1828, 1829, 1829, 1829, + + 1830, 1830, 1830, 1831, 0, 1831, 1832, 0, 1832, 1833, + 0, 1833, 1834, 0, 1834, 1835, 0, 1835, 1836, 0, + 1836, 1837, 0, 1837, 1838, 1838, 1838, 1839, 1839, 1839, + 1840, 0, 1840, 1841, 1841, 0, 0, 1841, 1842, 1842, + 0, 1842, 1843, 1843, 1844, 0, 1844, 1845, 0, 0, + 1845, 1846, 1846, 0, 1846, 1847, 1847, 0, 0, 1847, + 1848, 1848, 0, 1848, 1849, 1849, 1850, 0, 1850, 1851, + 0, 1851, 1852, 0, 0, 1852, 1853, 1853, 0, 1853, + 1854, 1854, 0, 0, 1854, 1855, 1855, 0, 1855, 1856, + 1856, 1857, 0, 1857, 1858, 0, 1858, 1859, 0, 0, + + 1859, 1860, 1860, 0, 1860, 1861, 1861, 0, 0, 1861, + 1862, 1862, 0, 1862, 1863, 1863, 1864, 0, 1864, 1865, + 0, 1865, 1866, 0, 0, 1866, 1867, 1867, 0, 1867, + 1868, 1868, 0, 0, 1868, 1869, 1869, 0, 1869, 1870, + 1870, 1871, 0, 1871, 1872, 0, 1872, 1873, 0, 1873, + 1874, 0, 1874, 1875, 1875, 1875, 1876, 0, 1876, 1877, + 1877, 1877, 0, 1877, 1877, 1878, 0, 1878, 1879, 0, + 1879, 1880, 0, 1880, 1881, 0, 1881, 1882, 0, 1882, + 1883, 0, 1883, 1884, 0, 1884, 1885, 1885, 0, 0, + 1885, 1886, 1886, 0, 1886, 1887, 1887, 1888, 0, 1888, + + 1889, 0, 1889, 1890, 0, 1890, 1891, 0, 1891, 1892, + 0, 1892, 1893, 0, 1893, 1894, 0, 1894, 1895, 0, + 1895, 1896, 0, 1896, 1897, 0, 1897, 1898, 0, 0, + 1898, 1899, 1899, 0, 0, 1899, 1900, 0, 1900, 1901, + 0, 1901, 1902, 0, 1902, 1903, 0, 0, 1903, 1904, + 0, 0, 1904, 1905, 0, 0, 1905, 1906, 0, 0, + 1906, 1907, 0, 0, 1907, 1908, 0, 1908, 1909, 0, + 1909, 1910, 0, 0, 1910, 1911, 0, 1911, 1912, 0, + 1912, 1913, 0, 1913, 1914, 0, 1914, 1915, 0, 1915, + 1916, 0, 0, 1916, 1917, 0, 1917, 1918, 0, 1918, + + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, + 1458, 1458, 1458, 1458 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int pcap__flex_debug; +int pcap__flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *pcap_text; +#line 1 "scanner.l" +#line 2 "scanner.l" +/* + * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that: (1) source code distributions + * retain the above copyright notice and this paragraph in its entirety, (2) + * distributions including binary code include the above copyright notice and + * this paragraph in its entirety in the documentation or other materials + * provided with the distribution, and (3) all advertising materials mentioning + * features or use of this software display the following acknowledgement: + * ``This product includes software developed by the University of California, + * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of + * the University 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 ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + +#ifndef lint +static const char rcsid[] _U_ = + "@(#) $Header: /tcpdump/master/libpcap/scanner.l,v 1.112 2008-02-06 10:21:30 guy Exp $ (LBL)"; +#endif + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef WIN32 +#include <pcap-stdinc.h> +#else /* WIN32 */ +#if HAVE_INTTYPES_H +#include <inttypes.h> +#elif HAVE_STDINT_H +#include <stdint.h> +#endif +#ifdef HAVE_SYS_BITYPES_H +#include <sys/bitypes.h> +#endif +#include <sys/types.h> +#endif /* WIN32 */ + +#include <ctype.h> +#include <string.h> + +#include "pcap-int.h" + +#include "gencode.h" +#ifdef INET6 +#ifdef WIN32 +#include <pcap-stdinc.h> + +#ifdef __MINGW32__ +#include "ip6_misc.h" +#endif +#else /* WIN32 */ +#include <sys/socket.h> /* for "struct sockaddr" in "struct addrinfo" */ +#include <netdb.h> /* for "struct addrinfo" */ +#endif /* WIN32 */ + +/* Workaround for AIX 4.3 */ +#if !defined(AI_NUMERICHOST) +#define AI_NUMERICHOST 0x04 +#endif +#endif /*INET6*/ +#include <pcap/namedb.h> +#include "tokdefs.h" + +#ifdef HAVE_OS_PROTO_H +#include "os-proto.h" +#endif + +static int stoi(char *); +static inline int xdtoi(int); + +#ifdef FLEX_SCANNER +#define YY_NO_INPUT +#define YY_NO_UNPUT +static YY_BUFFER_STATE in_buffer; +#else +static const char *in_buffer; + +#undef getc +#define getc(fp) (*in_buffer == 0 ? EOF : *in_buffer++) +#endif + +#define yylval pcap_lval +extern YYSTYPE yylval; + +#line 2792 "scanner.c" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include <unistd.h> +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals (void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int pcap_lex_destroy (void ); + +int pcap_get_debug (void ); + +void pcap_set_debug (int debug_flag ); + +YY_EXTRA_TYPE pcap_get_extra (void ); + +void pcap_set_extra (YY_EXTRA_TYPE user_defined ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int pcap_wrap (void ); +#else +extern int pcap_wrap (void ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ); +#endif + +#ifndef YY_NO_INPUT + +#ifdef __cplusplus +static int yyinput (void ); +#else +static int input (void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( pcap_text, pcap_leng, 1, pcap_out )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + size_t n; \ + for ( n = 0; n < max_size && \ + (c = getc( pcap_in )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( pcap_in ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, pcap_in))==0 && ferror(pcap_in)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(pcap_in); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int pcap_lex (void); + +#define YY_DECL int pcap_lex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after pcap_text and pcap_leng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 189 "scanner.l" + +#line 2963 "scanner.c" + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! pcap_in ) + pcap_in = stdin; + + if ( ! pcap_out ) + pcap_out = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + pcap_ensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + pcap__create_buffer(pcap_in,YY_BUF_SIZE ); + } + + pcap__load_buffer_state( ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of pcap_text. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1459 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 7401 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 190 "scanner.l" +return DST; + YY_BREAK +case 2: +YY_RULE_SETUP +#line 191 "scanner.l" +return SRC; + YY_BREAK +case 3: +YY_RULE_SETUP +#line 193 "scanner.l" +return LINK; + YY_BREAK +case 4: +YY_RULE_SETUP +#line 194 "scanner.l" +return LINK; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 195 "scanner.l" +return ARP; + YY_BREAK +case 6: +YY_RULE_SETUP +#line 196 "scanner.l" +return RARP; + YY_BREAK +case 7: +YY_RULE_SETUP +#line 197 "scanner.l" +return IP; + YY_BREAK +case 8: +YY_RULE_SETUP +#line 198 "scanner.l" +return SCTP; + YY_BREAK +case 9: +YY_RULE_SETUP +#line 199 "scanner.l" +return TCP; + YY_BREAK +case 10: +YY_RULE_SETUP +#line 200 "scanner.l" +return UDP; + YY_BREAK +case 11: +YY_RULE_SETUP +#line 201 "scanner.l" +return ICMP; + YY_BREAK +case 12: +YY_RULE_SETUP +#line 202 "scanner.l" +return IGMP; + YY_BREAK +case 13: +YY_RULE_SETUP +#line 203 "scanner.l" +return IGRP; + YY_BREAK +case 14: +YY_RULE_SETUP +#line 204 "scanner.l" +return PIM; + YY_BREAK +case 15: +YY_RULE_SETUP +#line 205 "scanner.l" +return VRRP; + YY_BREAK +case 16: +YY_RULE_SETUP +#line 206 "scanner.l" +return CARP; + YY_BREAK +case 17: +YY_RULE_SETUP +#line 207 "scanner.l" +return RADIO; + YY_BREAK +case 18: +YY_RULE_SETUP +#line 209 "scanner.l" +return IPV6; + YY_BREAK +case 19: +YY_RULE_SETUP +#line 210 "scanner.l" +return ICMPV6; + YY_BREAK +case 20: +YY_RULE_SETUP +#line 211 "scanner.l" +return AH; + YY_BREAK +case 21: +YY_RULE_SETUP +#line 212 "scanner.l" +return ESP; + YY_BREAK +case 22: +YY_RULE_SETUP +#line 214 "scanner.l" +return ATALK; + YY_BREAK +case 23: +YY_RULE_SETUP +#line 215 "scanner.l" +return AARP; + YY_BREAK +case 24: +YY_RULE_SETUP +#line 216 "scanner.l" +return DECNET; + YY_BREAK +case 25: +YY_RULE_SETUP +#line 217 "scanner.l" +return LAT; + YY_BREAK +case 26: +YY_RULE_SETUP +#line 218 "scanner.l" +return SCA; + YY_BREAK +case 27: +YY_RULE_SETUP +#line 219 "scanner.l" +return MOPRC; + YY_BREAK +case 28: +YY_RULE_SETUP +#line 220 "scanner.l" +return MOPDL; + YY_BREAK +case 29: +YY_RULE_SETUP +#line 222 "scanner.l" +return ISO; + YY_BREAK +case 30: +YY_RULE_SETUP +#line 223 "scanner.l" +return ESIS; + YY_BREAK +case 31: +YY_RULE_SETUP +#line 224 "scanner.l" +return ESIS; + YY_BREAK +case 32: +YY_RULE_SETUP +#line 225 "scanner.l" +return ISIS; + YY_BREAK +case 33: +YY_RULE_SETUP +#line 226 "scanner.l" +return ISIS; + YY_BREAK +case 34: +YY_RULE_SETUP +#line 227 "scanner.l" +return L1; + YY_BREAK +case 35: +YY_RULE_SETUP +#line 228 "scanner.l" +return L2; + YY_BREAK +case 36: +YY_RULE_SETUP +#line 229 "scanner.l" +return IIH; + YY_BREAK +case 37: +YY_RULE_SETUP +#line 230 "scanner.l" +return LSP; + YY_BREAK +case 38: +YY_RULE_SETUP +#line 231 "scanner.l" +return SNP; + YY_BREAK +case 39: +YY_RULE_SETUP +#line 232 "scanner.l" +return CSNP; + YY_BREAK +case 40: +YY_RULE_SETUP +#line 233 "scanner.l" +return PSNP; + YY_BREAK +case 41: +YY_RULE_SETUP +#line 235 "scanner.l" +return CLNP; + YY_BREAK +case 42: +YY_RULE_SETUP +#line 237 "scanner.l" +return STP; + YY_BREAK +case 43: +YY_RULE_SETUP +#line 239 "scanner.l" +return IPX; + YY_BREAK +case 44: +YY_RULE_SETUP +#line 241 "scanner.l" +return NETBEUI; + YY_BREAK +case 45: +YY_RULE_SETUP +#line 243 "scanner.l" +return HOST; + YY_BREAK +case 46: +YY_RULE_SETUP +#line 244 "scanner.l" +return NET; + YY_BREAK +case 47: +YY_RULE_SETUP +#line 245 "scanner.l" +return NETMASK; + YY_BREAK +case 48: +YY_RULE_SETUP +#line 246 "scanner.l" +return PORT; + YY_BREAK +case 49: +YY_RULE_SETUP +#line 247 "scanner.l" +return PORTRANGE; + YY_BREAK +case 50: +YY_RULE_SETUP +#line 248 "scanner.l" +return PROTO; + YY_BREAK +case 51: +YY_RULE_SETUP +#line 249 "scanner.l" +{ +#ifdef NO_PROTOCHAIN + bpf_error("%s not supported", pcap_text); +#else + return PROTOCHAIN; +#endif + } + YY_BREAK +case 52: +YY_RULE_SETUP +#line 257 "scanner.l" +return GATEWAY; + YY_BREAK +case 53: +YY_RULE_SETUP +#line 259 "scanner.l" +return TYPE; + YY_BREAK +case 54: +YY_RULE_SETUP +#line 260 "scanner.l" +return SUBTYPE; + YY_BREAK +case 55: +YY_RULE_SETUP +#line 261 "scanner.l" +return DIR; + YY_BREAK +case 56: +YY_RULE_SETUP +#line 262 "scanner.l" +return ADDR1; + YY_BREAK +case 57: +YY_RULE_SETUP +#line 263 "scanner.l" +return ADDR2; + YY_BREAK +case 58: +YY_RULE_SETUP +#line 264 "scanner.l" +return ADDR3; + YY_BREAK +case 59: +YY_RULE_SETUP +#line 265 "scanner.l" +return ADDR4; + YY_BREAK +case 60: +YY_RULE_SETUP +#line 266 "scanner.l" +return RA; + YY_BREAK +case 61: +YY_RULE_SETUP +#line 267 "scanner.l" +return TA; + YY_BREAK +case 62: +YY_RULE_SETUP +#line 269 "scanner.l" +return LESS; + YY_BREAK +case 63: +YY_RULE_SETUP +#line 270 "scanner.l" +return GREATER; + YY_BREAK +case 64: +YY_RULE_SETUP +#line 271 "scanner.l" +return CBYTE; + YY_BREAK +case 65: +YY_RULE_SETUP +#line 272 "scanner.l" +return TK_BROADCAST; + YY_BREAK +case 66: +YY_RULE_SETUP +#line 273 "scanner.l" +return TK_MULTICAST; + YY_BREAK +case 67: +YY_RULE_SETUP +#line 275 "scanner.l" +return AND; + YY_BREAK +case 68: +YY_RULE_SETUP +#line 276 "scanner.l" +return OR; + YY_BREAK +case 69: +YY_RULE_SETUP +#line 277 "scanner.l" +return '!'; + YY_BREAK +case 70: +YY_RULE_SETUP +#line 279 "scanner.l" +return LEN; + YY_BREAK +case 71: +YY_RULE_SETUP +#line 280 "scanner.l" +return INBOUND; + YY_BREAK +case 72: +YY_RULE_SETUP +#line 281 "scanner.l" +return OUTBOUND; + YY_BREAK +case 73: +YY_RULE_SETUP +#line 283 "scanner.l" +return VLAN; + YY_BREAK +case 74: +YY_RULE_SETUP +#line 284 "scanner.l" +return MPLS; + YY_BREAK +case 75: +YY_RULE_SETUP +#line 285 "scanner.l" +return PPPOED; + YY_BREAK +case 76: +YY_RULE_SETUP +#line 286 "scanner.l" +return PPPOES; + YY_BREAK +case 77: +YY_RULE_SETUP +#line 288 "scanner.l" +return LANE; + YY_BREAK +case 78: +YY_RULE_SETUP +#line 289 "scanner.l" +return LLC; + YY_BREAK +case 79: +YY_RULE_SETUP +#line 290 "scanner.l" +return METAC; + YY_BREAK +case 80: +YY_RULE_SETUP +#line 291 "scanner.l" +return BCC; + YY_BREAK +case 81: +YY_RULE_SETUP +#line 292 "scanner.l" +return OAM; + YY_BREAK +case 82: +YY_RULE_SETUP +#line 293 "scanner.l" +return OAMF4; + YY_BREAK +case 83: +YY_RULE_SETUP +#line 294 "scanner.l" +return OAMF4EC; + YY_BREAK +case 84: +YY_RULE_SETUP +#line 295 "scanner.l" +return OAMF4SC; + YY_BREAK +case 85: +YY_RULE_SETUP +#line 296 "scanner.l" +return SC; + YY_BREAK +case 86: +YY_RULE_SETUP +#line 297 "scanner.l" +return ILMIC; + YY_BREAK +case 87: +YY_RULE_SETUP +#line 298 "scanner.l" +return VPI; + YY_BREAK +case 88: +YY_RULE_SETUP +#line 299 "scanner.l" +return VCI; + YY_BREAK +case 89: +YY_RULE_SETUP +#line 300 "scanner.l" +return CONNECTMSG; + YY_BREAK +case 90: +YY_RULE_SETUP +#line 301 "scanner.l" +return METACONNECT; + YY_BREAK +case 91: +YY_RULE_SETUP +#line 303 "scanner.l" +return PF_IFNAME; + YY_BREAK +case 92: +YY_RULE_SETUP +#line 304 "scanner.l" +return PF_RSET; + YY_BREAK +case 93: +YY_RULE_SETUP +#line 305 "scanner.l" +return PF_RNR; + YY_BREAK +case 94: +YY_RULE_SETUP +#line 306 "scanner.l" +return PF_SRNR; + YY_BREAK +case 95: +YY_RULE_SETUP +#line 307 "scanner.l" +return PF_REASON; + YY_BREAK +case 96: +YY_RULE_SETUP +#line 308 "scanner.l" +return PF_ACTION; + YY_BREAK +case 97: +YY_RULE_SETUP +#line 310 "scanner.l" +return FISU; + YY_BREAK +case 98: +YY_RULE_SETUP +#line 311 "scanner.l" +return LSSU; + YY_BREAK +case 99: +YY_RULE_SETUP +#line 312 "scanner.l" +return LSSU; + YY_BREAK +case 100: +YY_RULE_SETUP +#line 313 "scanner.l" +return MSU; + YY_BREAK +case 101: +YY_RULE_SETUP +#line 314 "scanner.l" +return HFISU; + YY_BREAK +case 102: +YY_RULE_SETUP +#line 315 "scanner.l" +return HLSSU; + YY_BREAK +case 103: +YY_RULE_SETUP +#line 316 "scanner.l" +return HMSU; + YY_BREAK +case 104: +YY_RULE_SETUP +#line 317 "scanner.l" +return SIO; + YY_BREAK +case 105: +YY_RULE_SETUP +#line 318 "scanner.l" +return OPC; + YY_BREAK +case 106: +YY_RULE_SETUP +#line 319 "scanner.l" +return DPC; + YY_BREAK +case 107: +YY_RULE_SETUP +#line 320 "scanner.l" +return SLS; + YY_BREAK +case 108: +YY_RULE_SETUP +#line 321 "scanner.l" +return HSIO; + YY_BREAK +case 109: +YY_RULE_SETUP +#line 322 "scanner.l" +return HOPC; + YY_BREAK +case 110: +YY_RULE_SETUP +#line 323 "scanner.l" +return HDPC; + YY_BREAK +case 111: +YY_RULE_SETUP +#line 324 "scanner.l" +return HSLS; + YY_BREAK +case 112: +/* rule 112 can match eol */ +YY_RULE_SETUP +#line 326 "scanner.l" +; + YY_BREAK +case 113: +YY_RULE_SETUP +#line 327 "scanner.l" +return pcap_text[0]; + YY_BREAK +case 114: +YY_RULE_SETUP +#line 328 "scanner.l" +return GEQ; + YY_BREAK +case 115: +YY_RULE_SETUP +#line 329 "scanner.l" +return LEQ; + YY_BREAK +case 116: +YY_RULE_SETUP +#line 330 "scanner.l" +return NEQ; + YY_BREAK +case 117: +YY_RULE_SETUP +#line 331 "scanner.l" +return '='; + YY_BREAK +case 118: +YY_RULE_SETUP +#line 332 "scanner.l" +return LSH; + YY_BREAK +case 119: +YY_RULE_SETUP +#line 333 "scanner.l" +return RSH; + YY_BREAK +case 120: +YY_RULE_SETUP +#line 334 "scanner.l" +{ yylval.e = pcap_ether_aton(((char *)pcap_text)+1); + if (yylval.e == NULL) + bpf_error("malloc"); + return AID; } + YY_BREAK +case 121: +YY_RULE_SETUP +#line 338 "scanner.l" +{ yylval.e = pcap_ether_aton((char *)pcap_text); + if (yylval.e == NULL) + bpf_error("malloc"); + return EID; } + YY_BREAK +case 122: +YY_RULE_SETUP +#line 342 "scanner.l" +{ yylval.i = stoi((char *)pcap_text); return NUM; } + YY_BREAK +case 123: +YY_RULE_SETUP +#line 343 "scanner.l" +{ + yylval.s = sdup((char *)pcap_text); return HID; } + YY_BREAK +case 124: +YY_RULE_SETUP +#line 345 "scanner.l" +{ +#ifdef INET6 + struct addrinfo hints, *res; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_INET6; + hints.ai_flags = AI_NUMERICHOST; + if (getaddrinfo(pcap_text, NULL, &hints, &res)) + bpf_error("bogus IPv6 address %s", pcap_text); + else { + freeaddrinfo(res); + yylval.s = sdup((char *)pcap_text); return HID6; + } +#else + bpf_error("IPv6 address %s not supported", pcap_text); +#endif /*INET6*/ + } + YY_BREAK +case 125: +YY_RULE_SETUP +#line 361 "scanner.l" +{ bpf_error("bogus ethernet address %s", pcap_text); } + YY_BREAK +case 126: +YY_RULE_SETUP +#line 362 "scanner.l" +{ yylval.i = 0; return NUM; } + YY_BREAK +case 127: +YY_RULE_SETUP +#line 363 "scanner.l" +{ yylval.i = 1; return NUM; } + YY_BREAK +case 128: +YY_RULE_SETUP +#line 364 "scanner.l" +{ yylval.i = 0; return NUM; } + YY_BREAK +case 129: +YY_RULE_SETUP +#line 365 "scanner.l" +{ yylval.i = 3; return NUM; } + YY_BREAK +case 130: +YY_RULE_SETUP +#line 366 "scanner.l" +{ yylval.i = 4; return NUM; } + YY_BREAK +case 131: +YY_RULE_SETUP +#line 367 "scanner.l" +{ yylval.i = 5; return NUM; } + YY_BREAK +case 132: +YY_RULE_SETUP +#line 368 "scanner.l" +{ yylval.i = 8; return NUM; } + YY_BREAK +case 133: +YY_RULE_SETUP +#line 369 "scanner.l" +{ yylval.i = 9; return NUM; } + YY_BREAK +case 134: +YY_RULE_SETUP +#line 370 "scanner.l" +{ yylval.i = 10; return NUM; } + YY_BREAK +case 135: +YY_RULE_SETUP +#line 371 "scanner.l" +{ yylval.i = 11; return NUM; } + YY_BREAK +case 136: +YY_RULE_SETUP +#line 372 "scanner.l" +{ yylval.i = 12; return NUM; } + YY_BREAK +case 137: +YY_RULE_SETUP +#line 373 "scanner.l" +{ yylval.i = 13; return NUM; } + YY_BREAK +case 138: +YY_RULE_SETUP +#line 374 "scanner.l" +{ yylval.i = 14; return NUM; } + YY_BREAK +case 139: +YY_RULE_SETUP +#line 375 "scanner.l" +{ yylval.i = 15; return NUM; } + YY_BREAK +case 140: +YY_RULE_SETUP +#line 376 "scanner.l" +{ yylval.i = 16; return NUM; } + YY_BREAK +case 141: +YY_RULE_SETUP +#line 377 "scanner.l" +{ yylval.i = 17; return NUM; } + YY_BREAK +case 142: +YY_RULE_SETUP +#line 378 "scanner.l" +{ yylval.i = 18; return NUM; } + YY_BREAK +case 143: +YY_RULE_SETUP +#line 379 "scanner.l" +{ yylval.i = 13; return NUM; } + YY_BREAK +case 144: +YY_RULE_SETUP +#line 380 "scanner.l" +{ yylval.i = 0x01; return NUM; } + YY_BREAK +case 145: +YY_RULE_SETUP +#line 381 "scanner.l" +{ yylval.i = 0x02; return NUM; } + YY_BREAK +case 146: +YY_RULE_SETUP +#line 382 "scanner.l" +{ yylval.i = 0x04; return NUM; } + YY_BREAK +case 147: +YY_RULE_SETUP +#line 383 "scanner.l" +{ yylval.i = 0x08; return NUM; } + YY_BREAK +case 148: +YY_RULE_SETUP +#line 384 "scanner.l" +{ yylval.i = 0x10; return NUM; } + YY_BREAK +case 149: +YY_RULE_SETUP +#line 385 "scanner.l" +{ yylval.i = 0x20; return NUM; } + YY_BREAK +case 150: +YY_RULE_SETUP +#line 386 "scanner.l" +{ + yylval.s = sdup((char *)pcap_text); return ID; } + YY_BREAK +case 151: +YY_RULE_SETUP +#line 388 "scanner.l" +{ yylval.s = sdup((char *)pcap_text + 1); return ID; } + YY_BREAK +case 152: +YY_RULE_SETUP +#line 389 "scanner.l" +{ + bpf_error("illegal token: %s", pcap_text); } + YY_BREAK +case 153: +YY_RULE_SETUP +#line 391 "scanner.l" +{ bpf_error("illegal char '%c'", *pcap_text); } + YY_BREAK +case 154: +YY_RULE_SETUP +#line 392 "scanner.l" +ECHO; + YY_BREAK +#line 3847 "scanner.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed pcap_in at a new source and called + * pcap_lex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = pcap_in; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( pcap_wrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * pcap_text, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ +} /* end of pcap_lex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = (yytext_ptr); + register int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + pcap_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), (size_t) num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + pcap_restart(pcap_in ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pcap_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1459 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + register int yy_is_jam; + register char *yy_cp = (yy_c_buf_p); + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1459 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 1458); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (yy_c_buf_p) - (yytext_ptr); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + pcap_restart(pcap_in ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( pcap_wrap( ) ) + return EOF; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve pcap_text */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void pcap_restart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + pcap_ensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + pcap__create_buffer(pcap_in,YY_BUF_SIZE ); + } + + pcap__init_buffer(YY_CURRENT_BUFFER,input_file ); + pcap__load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void pcap__switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * pcap_pop_buffer_state(); + * pcap_push_buffer_state(new_buffer); + */ + pcap_ensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + pcap__load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (pcap_wrap()) processing, but the only time this flag + * is looked at is after pcap_wrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void pcap__load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + pcap_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE pcap__create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) pcap_alloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in pcap__create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) pcap_alloc(b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in pcap__create_buffer()" ); + + b->yy_is_our_buffer = 1; + + pcap__init_buffer(b,file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with pcap__create_buffer() + * + */ + void pcap__delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + pcap_free((void *) b->yy_ch_buf ); + + pcap_free((void *) b ); +} + +#ifndef __cplusplus +extern int isatty (int ); +#endif /* __cplusplus */ + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a pcap_restart() or at EOF. + */ + static void pcap__init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + pcap__flush_buffer(b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then pcap__init_buffer was _probably_ + * called from pcap_restart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void pcap__flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + pcap__load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void pcap_push_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + pcap_ensure_buffer_stack(); + + /* This block is copied from pcap__switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from pcap__switch_to_buffer. */ + pcap__load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void pcap_pop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + pcap__delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + pcap__load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void pcap_ensure_buffer_stack (void) +{ + int num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; + (yy_buffer_stack) = (struct yy_buffer_state**)pcap_alloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in pcap_ensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)pcap_realloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in pcap_ensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE pcap__scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) pcap_alloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in pcap__scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + pcap__switch_to_buffer(b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to pcap_lex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * pcap__scan_bytes() instead. + */ +YY_BUFFER_STATE pcap__scan_string (yyconst char * yystr ) +{ + + return pcap__scan_bytes(yystr,strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to pcap_lex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE pcap__scan_bytes (yyconst char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = _yybytes_len + 2; + buf = (char *) pcap_alloc(n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in pcap__scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = pcap__scan_buffer(buf,n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in pcap__scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yy_fatal_error (yyconst char* msg ) +{ + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up pcap_text. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + pcap_text[pcap_leng] = (yy_hold_char); \ + (yy_c_buf_p) = pcap_text + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + pcap_leng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current token. + * + */ + +int pcap_get_debug (void) +{ + return pcap__flex_debug; +} + +void pcap_set_debug (int bdebug ) +{ + pcap__flex_debug = bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from pcap_lex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = 0; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = (char *) 0; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + pcap_in = stdin; + pcap_out = stdout; +#else + pcap_in = (FILE *) 0; + pcap_out = (FILE *) 0; +#endif + + /* For future reference: Set errno on error, since we are called by + * pcap_lex_init() + */ + return 0; +} + +/* pcap_lex_destroy is for both reentrant and non-reentrant scanners. */ +int pcap_lex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + pcap__delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + pcap_pop_buffer_state(); + } + + /* Destroy the stack itself. */ + pcap_free((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * pcap_lex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +{ + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * s ) +{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *pcap_alloc (yy_size_t size ) +{ + return (void *) malloc( size ); +} + +void *pcap_realloc (void * ptr, yy_size_t size ) +{ + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); +} + +void pcap_free (void * ptr ) +{ + free( (char *) ptr ); /* see pcap_realloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 392 "scanner.l" + + +void +lex_init(buf) + const char *buf; +{ +#ifdef FLEX_SCANNER + in_buffer = pcap__scan_string(buf); +#else + in_buffer = buf; +#endif +} + +/* + * Do any cleanup necessary after parsing. + */ +void +lex_cleanup() +{ +#ifdef FLEX_SCANNER + if (in_buffer != NULL) + pcap__delete_buffer(in_buffer); + in_buffer = NULL; +#endif +} + +/* + * Also define a pcap_wrap. Note that if we're using flex, it will + * define a macro to map this identifier to pcap_wrap. + */ +int +pcap_wrap() +{ + return 1; +} + +/* Hex digit to integer. */ +static inline int +xdtoi(c) + register int c; +{ + if (isdigit(c)) + return c - '0'; + else if (islower(c)) + return c - 'a' + 10; + else + return c - 'A' + 10; +} + +/* + * Convert string to integer. Just like atoi(), but checks for + * preceding 0x or 0 and uses hex or octal instead of decimal. + */ +static int +stoi(s) + char *s; +{ + int base = 10; + int n = 0; + + if (*s == '0') { + if (s[1] == 'x' || s[1] == 'X') { + s += 2; + base = 16; + } + else { + base = 8; + s += 1; + } + } + while (*s) + n = n * base + xdtoi(*s++); + + return n; +} + diff --git a/scanner.h b/scanner.h new file mode 100644 index 00000000..934ca4cc --- /dev/null +++ b/scanner.h @@ -0,0 +1,6 @@ +/* This is generated by runlex.sh. Do not edit it. */ + +#ifndef YY_DECL +#define YY_DECL int yylex(void) +#endif +YY_DECL; diff --git a/tokdefs.h b/tokdefs.h new file mode 100644 index 00000000..75671d38 --- /dev/null +++ b/tokdefs.h @@ -0,0 +1,316 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + DST = 258, + SRC = 259, + HOST = 260, + GATEWAY = 261, + NET = 262, + NETMASK = 263, + PORT = 264, + PORTRANGE = 265, + LESS = 266, + GREATER = 267, + PROTO = 268, + PROTOCHAIN = 269, + CBYTE = 270, + ARP = 271, + RARP = 272, + IP = 273, + SCTP = 274, + TCP = 275, + UDP = 276, + ICMP = 277, + IGMP = 278, + IGRP = 279, + PIM = 280, + VRRP = 281, + CARP = 282, + ATALK = 283, + AARP = 284, + DECNET = 285, + LAT = 286, + SCA = 287, + MOPRC = 288, + MOPDL = 289, + TK_BROADCAST = 290, + TK_MULTICAST = 291, + NUM = 292, + INBOUND = 293, + OUTBOUND = 294, + PF_IFNAME = 295, + PF_RSET = 296, + PF_RNR = 297, + PF_SRNR = 298, + PF_REASON = 299, + PF_ACTION = 300, + TYPE = 301, + SUBTYPE = 302, + DIR = 303, + ADDR1 = 304, + ADDR2 = 305, + ADDR3 = 306, + ADDR4 = 307, + RA = 308, + TA = 309, + LINK = 310, + GEQ = 311, + LEQ = 312, + NEQ = 313, + ID = 314, + EID = 315, + HID = 316, + HID6 = 317, + AID = 318, + LSH = 319, + RSH = 320, + LEN = 321, + IPV6 = 322, + ICMPV6 = 323, + AH = 324, + ESP = 325, + VLAN = 326, + MPLS = 327, + PPPOED = 328, + PPPOES = 329, + ISO = 330, + ESIS = 331, + CLNP = 332, + ISIS = 333, + L1 = 334, + L2 = 335, + IIH = 336, + LSP = 337, + SNP = 338, + CSNP = 339, + PSNP = 340, + STP = 341, + IPX = 342, + NETBEUI = 343, + LANE = 344, + LLC = 345, + METAC = 346, + BCC = 347, + SC = 348, + ILMIC = 349, + OAMF4EC = 350, + OAMF4SC = 351, + OAM = 352, + OAMF4 = 353, + CONNECTMSG = 354, + METACONNECT = 355, + VPI = 356, + VCI = 357, + RADIO = 358, + FISU = 359, + LSSU = 360, + MSU = 361, + HFISU = 362, + HLSSU = 363, + HMSU = 364, + SIO = 365, + OPC = 366, + DPC = 367, + SLS = 368, + HSIO = 369, + HOPC = 370, + HDPC = 371, + HSLS = 372, + AND = 373, + OR = 374, + UMINUS = 375 + }; +#endif +/* Tokens. */ +#define DST 258 +#define SRC 259 +#define HOST 260 +#define GATEWAY 261 +#define NET 262 +#define NETMASK 263 +#define PORT 264 +#define PORTRANGE 265 +#define LESS 266 +#define GREATER 267 +#define PROTO 268 +#define PROTOCHAIN 269 +#define CBYTE 270 +#define ARP 271 +#define RARP 272 +#define IP 273 +#define SCTP 274 +#define TCP 275 +#define UDP 276 +#define ICMP 277 +#define IGMP 278 +#define IGRP 279 +#define PIM 280 +#define VRRP 281 +#define CARP 282 +#define ATALK 283 +#define AARP 284 +#define DECNET 285 +#define LAT 286 +#define SCA 287 +#define MOPRC 288 +#define MOPDL 289 +#define TK_BROADCAST 290 +#define TK_MULTICAST 291 +#define NUM 292 +#define INBOUND 293 +#define OUTBOUND 294 +#define PF_IFNAME 295 +#define PF_RSET 296 +#define PF_RNR 297 +#define PF_SRNR 298 +#define PF_REASON 299 +#define PF_ACTION 300 +#define TYPE 301 +#define SUBTYPE 302 +#define DIR 303 +#define ADDR1 304 +#define ADDR2 305 +#define ADDR3 306 +#define ADDR4 307 +#define RA 308 +#define TA 309 +#define LINK 310 +#define GEQ 311 +#define LEQ 312 +#define NEQ 313 +#define ID 314 +#define EID 315 +#define HID 316 +#define HID6 317 +#define AID 318 +#define LSH 319 +#define RSH 320 +#define LEN 321 +#define IPV6 322 +#define ICMPV6 323 +#define AH 324 +#define ESP 325 +#define VLAN 326 +#define MPLS 327 +#define PPPOED 328 +#define PPPOES 329 +#define ISO 330 +#define ESIS 331 +#define CLNP 332 +#define ISIS 333 +#define L1 334 +#define L2 335 +#define IIH 336 +#define LSP 337 +#define SNP 338 +#define CSNP 339 +#define PSNP 340 +#define STP 341 +#define IPX 342 +#define NETBEUI 343 +#define LANE 344 +#define LLC 345 +#define METAC 346 +#define BCC 347 +#define SC 348 +#define ILMIC 349 +#define OAMF4EC 350 +#define OAMF4SC 351 +#define OAM 352 +#define OAMF4 353 +#define CONNECTMSG 354 +#define METACONNECT 355 +#define VPI 356 +#define VCI 357 +#define RADIO 358 +#define FISU 359 +#define LSSU 360 +#define MSU 361 +#define HFISU 362 +#define HLSSU 363 +#define HMSU 364 +#define SIO 365 +#define OPC 366 +#define DPC 367 +#define SLS 368 +#define HSIO 369 +#define HOPC 370 +#define HDPC 371 +#define HSLS 372 +#define AND 373 +#define OR 374 +#define UMINUS 375 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ + +/* Line 2068 of yacc.c */ +#line 242 "grammar.y" + + int i; + bpf_u_int32 h; + u_char *e; + char *s; + struct stmt *stmt; + struct arth *a; + struct { + struct qual q; + int atmfieldtype; + int mtp3fieldtype; + struct block *b; + } blk; + struct block *rblk; + + + +/* Line 2068 of yacc.c */ +#line 308 "y.tab.h" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + +extern YYSTYPE pcap_lval; + + diff --git a/version.c b/version.c new file mode 100644 index 00000000..795bf1ed --- /dev/null +++ b/version.c @@ -0,0 +1 @@ +char pcap_version[] = "1.5.2"; diff --git a/version.h b/version.h new file mode 100644 index 00000000..29c81da3 --- /dev/null +++ b/version.h @@ -0,0 +1 @@ +static const char pcap_version_string[] = "libpcap version 1.5.2"; |