#include <stdlib.h>

#include <string.h>

#define YYBYACC 1

#define YYMAJOR 1

#define YYMINOR 9

#define YYLEX yylex()

#define YYEMPTY -1

#define yyclearin (yychar=(YYEMPTY))

#define yyerrok (yyerrflag=0)

#define YYRECOVERING() (yyerrflag!=0)

#define YYPREFIX "yy"

#line 30 "parse.y"

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <net/if.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

#include <netinet/icmp6.h>

#include <net/pfvar.h>

#include <arpa/inet.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <netdb.h>

#include <stdarg.h>

#include <errno.h>

#include <string.h>

#include <ctype.h>

#include <math.h>

#include <err.h>

#include <limits.h>

#include <pwd.h>

#include <grp.h>

#include <md5.h>

#include "pfctl_parser.h"

#include "pfctl.h"

static struct pfctl	*pf = NULL;

static int		 debug = 0;

static u_int16_t	 returnicmpdefault =

			    (ICMP_UNREACH << 8) | ICMP_UNREACH_PORT;

static u_int16_t	 returnicmp6default =

			    (ICMP6_DST_UNREACH << 8) | ICMP6_DST_UNREACH_NOPORT;

static int		 blockpolicy = PFRULE_DROP;

static int		 default_statelock;

TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);

static struct file {

	TAILQ_ENTRY(file)	 entry;

	FILE			*stream;

	char			*name;

	int			 lineno;

	int			 errors;

} *file;

struct file	*pushfile(const char *, int);

int		 popfile(void);

int		 check_file_secrecy(int, const char *);

int		 yyparse(void);

int		 yylex(void);

int		 yyerror(const char *, ...);

int		 kw_cmp(const void *, const void *);

int		 lookup(char *);

int		 lgetc(int);

int		 lungetc(int);

int		 findeol(void);

TAILQ_HEAD(symhead, sym)	 symhead = TAILQ_HEAD_INITIALIZER(symhead);

struct sym {

	TAILQ_ENTRY(sym)	 entry;

	int			 used;

	int			 persist;

	char			*nam;

	char			*val;

};

int		 symset(const char *, const char *, int);

char		*symget(const char *);

int		 atoul(char *, u_long *);

struct node_proto {

	u_int8_t		 proto;

	struct node_proto	*next;

	struct node_proto	*tail;

};

struct node_port {

	u_int16_t		 port[2];

	u_int8_t		 op;

	struct node_port	*next;

	struct node_port	*tail;

};

struct node_uid {

	uid_t			 uid[2];

	u_int8_t		 op;

	struct node_uid		*next;

	struct node_uid		*tail;

};

struct node_gid {

	gid_t			 gid[2];

	u_int8_t		 op;

	struct node_gid		*next;

	struct node_gid		*tail;

};

struct node_icmp {

	u_int8_t		 code;

	u_int8_t		 type;

	u_int8_t		 proto;

	struct node_icmp	*next;

	struct node_icmp	*tail;

};

enum	{ PF_STATE_OPT_MAX, PF_STATE_OPT_NOSYNC, PF_STATE_OPT_SRCTRACK,

	    PF_STATE_OPT_MAX_SRC_STATES, PF_STATE_OPT_MAX_SRC_CONN,

	    PF_STATE_OPT_MAX_SRC_CONN_RATE, PF_STATE_OPT_MAX_SRC_NODES,

	    PF_STATE_OPT_OVERLOAD, PF_STATE_OPT_STATELOCK,

	    PF_STATE_OPT_TIMEOUT, PF_STATE_OPT_SLOPPY,

	    PF_STATE_OPT_PFLOW };

enum	{ PF_SRCTRACK_NONE, PF_SRCTRACK, PF_SRCTRACK_GLOBAL, PF_SRCTRACK_RULE };

struct node_state_opt {

	int			 type;

	union {

		u_int32_t	 max_states;

		u_int32_t	 max_src_states;

		u_int32_t	 max_src_conn;

		struct {

			u_int32_t	limit;

			u_int32_t	seconds;

		}		 max_src_conn_rate;

		struct {

			u_int8_t	flush;

			char		tblname[PF_TABLE_NAME_SIZE];

		}		 overload;

		u_int32_t	 max_src_nodes;

		u_int8_t	 src_track;

		u_int32_t	 statelock;

		struct {

			int		number;

			u_int32_t	seconds;

		}		 timeout;

	}			 data;

	struct node_state_opt	*next;

	struct node_state_opt	*tail;

};

struct peer {

	struct node_host	*host;

	struct node_port	*port;

};

struct node_queue {

	char			 queue[PF_QNAME_SIZE];

	char			 parent[PF_QNAME_SIZE];

	char			 ifname[IFNAMSIZ];

	int			 scheduler;

	struct node_queue	*next;

	struct node_queue	*tail;

};

struct node_qassign {

	char		*qname;

	char		*pqname;

};

struct range {

	int		 a;

	int		 b;

	int		 t;

};

struct redirection {

	struct node_host	*host;

	struct range		 rport;

};

struct pool_opts {

	int			 marker;

#define POM_TYPE		0x01

#define POM_STICKYADDRESS	0x02

	u_int8_t		 opts;

	int			 type;

	int			 staticport;

	struct pf_poolhashkey	*key;

} pool_opts;

struct divertspec {

	struct node_host	*addr;

	u_int16_t		 port;

};

struct redirspec {

	struct redirection      *rdr;

	struct pool_opts         pool_opts;

	int			 binat;

	int			 af;

};

struct filter_opts {

	int			 marker;

#define FOM_FLAGS	0x0001

#define FOM_ICMP	0x0002

#define FOM_TOS		0x0004

#define FOM_KEEP	0x0008

#define FOM_SRCTRACK	0x0010

#define FOM_MINTTL	0x0020

#define FOM_MAXMSS	0x0040

#define FOM_AFTO	0x0080

#define FOM_SETTOS	0x0100

#define FOM_SCRUB_TCP	0x0200

#define FOM_SETPRIO	0x0400

#define FOM_ONCE	0x1000

#define FOM_PRIO	0x2000

	struct node_uid		*uid;

	struct node_gid		*gid;

	struct node_if		*rcv;

	struct {

		u_int8_t	 b1;

		u_int8_t	 b2;

		u_int16_t	 w;

		u_int16_t	 w2;

	} flags;

	struct node_icmp	*icmpspec;

	u_int32_t		 tos;

	u_int32_t		 prob;

	struct {

		int			 action;

		struct node_state_opt	*options;

	} keep;

	int			 fragment;

	int			 allowopts;

	char			*label;

	struct node_qassign	 queues;

	char			*tag;

	char			*match_tag;

	u_int8_t		 match_tag_not;

	u_int			 rtableid;

	u_int8_t		 prio;

	u_int8_t		 set_prio[2];

	struct divertspec	 divert;

	struct divertspec	 divert_packet;

	struct redirspec	 nat;

	struct redirspec	 rdr;

	struct redirspec	 rroute;

	/* scrub opts */

	int			 nodf;

	int			 minttl;

	int			 settos;

	int			 randomid;

	int			 max_mss;

	/* route opts */

	struct {

		struct node_host	*host;

		u_int8_t		 rt;

		u_int8_t		 pool_opts;

		sa_family_t		 af;

		struct pf_poolhashkey	*key;

	}			 route;

} filter_opts;

struct antispoof_opts {

	char			*label;

	u_int			 rtableid;

} antispoof_opts;

struct scrub_opts {

	int			marker;

	int			nodf;

	int			minttl;

	int			maxmss;

	int			settos;

	int			randomid;

	int			reassemble_tcp;

} scrub_opts;

struct node_sc {

	struct node_queue_bw	m1;

	u_int			d;

	struct node_queue_bw	m2;

};

struct node_fq {

	u_int			flows;

	u_int			quantum;

	u_int			target;

	u_int			interval;

};

struct queue_opts {

	int		 marker;

#define	QOM_BWSPEC	0x01

#define	QOM_PARENT	0x02

#define	QOM_DEFAULT	0x04

#define	QOM_QLIMIT	0x08

#define	QOM_FLOWS	0x10

#define	QOM_QUANTUM	0x20

	struct node_sc	 realtime;

	struct node_sc	 linkshare;

	struct node_sc	 upperlimit;

	struct node_fq	 flowqueue;

	char		*parent;

	int		 flags;

	u_int		 qlimit;

} queue_opts;

struct table_opts {

	int			flags;

	int			init_addr;

	struct node_tinithead	init_nodes;

} table_opts;

struct node_hfsc_opts	 hfsc_opts;

struct node_state_opt	*keep_state_defaults = NULL;

int		 disallow_table(struct node_host *, const char *);

int		 disallow_urpf_failed(struct node_host *, const char *);

int		 disallow_alias(struct node_host *, const char *);

int		 rule_consistent(struct pf_rule *, int);

int		 process_tabledef(char *, struct table_opts *, int);

void		 expand_label_str(char *, size_t, const char *, const char *);

void		 expand_label_if(const char *, char *, size_t, const char *);

void		 expand_label_addr(const char *, char *, size_t, u_int8_t,

		    struct node_host *);

void		 expand_label_port(const char *, char *, size_t,

		    struct node_port *);

void		 expand_label_proto(const char *, char *, size_t, u_int8_t);

void		 expand_label_nr(const char *, char *, size_t);

void		 expand_label(char *, size_t, const char *, u_int8_t,

		    struct node_host *, struct node_port *, struct node_host *,

		    struct node_port *, u_int8_t);

int		 expand_divertspec(struct pf_rule *, struct divertspec *);

int		 collapse_redirspec(struct pf_pool *, struct pf_rule *,

		    struct redirspec *rs, u_int8_t);

int		 apply_redirspec(struct pf_pool *, struct pf_rule *,

		    struct redirspec *, int, struct node_port *);

void		 expand_rule(struct pf_rule *, int, struct node_if *,

		    struct redirspec *, struct redirspec *, struct redirspec *,

		    struct node_proto *,

		    struct node_os *, struct node_host *, struct node_port *,

		    struct node_host *, struct node_port *, struct node_uid *,

		    struct node_gid *, struct node_if *, struct node_icmp *,

		    const char *);

int		 expand_queue(char *, struct node_if *, struct queue_opts *);

int		 expand_skip_interface(struct node_if *);

int	 getservice(char *);

int	 rule_label(struct pf_rule *, char *);

void	 mv_rules(struct pf_ruleset *, struct pf_ruleset *);

void	 decide_address_family(struct node_host *, sa_family_t *);

int	 invalid_redirect(struct node_host *, sa_family_t);

u_int16_t parseicmpspec(char *, sa_family_t);

int	 kw_casecmp(const void *, const void *);

int	 map_tos(char *string, int *);

TAILQ_HEAD(loadanchorshead, loadanchors)

    loadanchorshead = TAILQ_HEAD_INITIALIZER(loadanchorshead);

struct loadanchors {

	TAILQ_ENTRY(loadanchors)	 entries;

	char				*anchorname;

	char				*filename;

};

typedef struct {

	union {

		int64_t			 number;

		double			 probability;

		int			 i;

		char			*string;

		u_int			 rtableid;

		u_int16_t		 weight;

		struct {

			u_int8_t	 b1;

			u_int8_t	 b2;

			u_int16_t	 w;

			u_int16_t	 w2;

		}			 b;

		struct range		 range;

		struct node_if		*interface;

		struct node_proto	*proto;

		struct node_icmp	*icmp;

		struct node_host	*host;

		struct node_os		*os;

		struct node_port	*port;

		struct node_uid		*uid;

		struct node_gid		*gid;

		struct node_state_opt	*state_opt;

		struct peer		 peer;

		struct {

			struct peer	 src, dst;

			struct node_os	*src_os;

		}			 fromto;

		struct redirection	*redirection;

		struct {

			int			 action;

			struct node_state_opt	*options;

		}			 keep_state;

		struct {

			u_int8_t	 log;

			u_int8_t	 logif;

			u_int8_t	 quick;

		}			 logquick;

		struct {

			int		 neg;

			char		*name;

		}			 tagged;

		struct pf_poolhashkey	*hashkey;

		struct node_queue	*queue;

		struct node_queue_opt	 queue_options;

		struct node_queue_bw	 queue_bwspec;

		struct node_qassign	 qassign;

		struct node_sc		 sc;

		struct filter_opts	 filter_opts;

		struct antispoof_opts	 antispoof_opts;

		struct queue_opts	 queue_opts;

		struct scrub_opts	 scrub_opts;

		struct table_opts	 table_opts;

		struct pool_opts	 pool_opts;

		struct node_hfsc_opts	 hfsc_opts;

	} v;

	int lineno;

} YYSTYPE;

#define PPORT_RANGE	1

#define PPORT_STAR	2

int	parseport(char *, struct range *r, int);

#define DYNIF_MULTIADDR(addr) ((addr).type == PF_ADDR_DYNIFTL && \

	(!((addr).iflags & PFI_AFLAG_NOALIAS) ||		 \

	!isdigit((unsigned char)(addr).v.ifname[strlen((addr).v.ifname)-1])))

#line 443 "parse.c"

#define PASS 257

#define BLOCK 258

#define MATCH 259

#define SCRUB 260

#define RETURN 261

#define IN 262

#define OS 263

#define OUT 264

#define LOG 265

#define QUICK 266

#define ON 267

#define FROM 268

#define TO 269

#define FLAGS 270

#define RETURNRST 271

#define RETURNICMP 272

#define RETURNICMP6 273

#define PROTO 274

#define INET 275

#define INET6 276

#define ALL 277

#define ANY 278

#define ICMPTYPE 279

#define ICMP6TYPE 280

#define CODE 281

#define KEEP 282

#define MODULATE 283

#define STATE 284

#define PORT 285

#define BINATTO 286

#define NODF 287

#define MINTTL 288

#define ERROR 289

#define ALLOWOPTS 290

#define FILENAME 291

#define ROUTETO 292

#define DUPTO 293

#define REPLYTO 294

#define NO 295

#define LABEL 296

#define NOROUTE 297

#define URPFFAILED 298

#define FRAGMENT 299

#define USER 300

#define GROUP 301

#define MAXMSS 302

#define MAXIMUM 303

#define TTL 304

#define TOS 305

#define DROP 306

#define TABLE 307

#define REASSEMBLE 308

#define ANCHOR 309

#define SET 310

#define OPTIMIZATION 311

#define TIMEOUT 312

#define LIMIT 313

#define LOGINTERFACE 314

#define BLOCKPOLICY 315

#define RANDOMID 316

#define SYNPROXY 317

#define FINGERPRINTS 318

#define NOSYNC 319

#define DEBUG 320

#define SKIP 321

#define HOSTID 322

#define ANTISPOOF 323

#define FOR 324

#define INCLUDE 325

#define MATCHES 326

#define BITMASK 327

#define RANDOM 328

#define SOURCEHASH 329

#define ROUNDROBIN 330

#define LEASTSTATES 331

#define STATICPORT 332

#define PROBABILITY 333

#define WEIGHT 334

#define BANDWIDTH 335

#define FLOWS 336

#define QUANTUM 337

#define QUEUE 338

#define PRIORITY 339

#define QLIMIT 340

#define RTABLE 341

#define RDOMAIN 342

#define MINIMUM 343

#define BURST 344

#define PARENT 345

#define LOAD 346

#define RULESET_OPTIMIZATION 347

#define PRIO 348

#define ONCE 349

#define DEFAULT 350

#define STICKYADDRESS 351

#define MAXSRCSTATES 352

#define GLOBAL 355

#define RULE 356

#define MAXSRCCONN 357

#define MAXSRCCONNRATE 358

#define TAGGED 363

#define IFBOUND 365

#define ROUTE 369

#define DIVERTTO 370

#define DIVERTREPLY 371

#define DIVERTPACKET 372

#define NATTO 373

#define AFTO 374

#define RDRTO 375

#define RECEIVEDON 376

#define NE 377

#define LE 378

#define GE 379

#define STRING 380

#define NUMBER 381

   13,  116,  116,  116,  116,  116,  116,  116,  116,  116,

  130,  130,  130,  130,  132,  131,  131,  118,  119,  133,

  106,  108,  108,  107,  107,  107,  107,  107,  122,   87,

   87,   88,   88,   89,   89,  135,   98,   98,  100,  100,

   99,   99,   11,   11,  123,  136,  109,  109,  111,  111,

   92,   92,   94,   94,   93,   93,   93,   93,   93,   93,

   93,   93,   93,   93,   93,   93,   93,   93,   93,   93,

   93,   93,   93,   93,   95,   95,   97,   97,   96,   96,

   17,   17,   17,   32,   32,   32,   33,   33,   34,   35,

   45,   46,   46,   44,   44,   44,  126,  126,   47,   47,

   36,   36,   36,   36,   37,   37,   39,   39,   38,   38,

   38,   40,   40,   40,    6,    6,    7,    7,   10,   10,

   19,   19,   19,   22,   22,   78,   78,   78,   78,   20,

   20,   20,   79,   79,   80,   80,   81,   81,   81,   81,

   81,   81,   81,   81,   81,   81,   81,   81,   72,   90,

   90,   90,   29,   55,   55,   54,   54,   71,   71,   31,

};

	{                                         2,

    2,    1,    2,    1,    1,    1,    3,    1,    0,    0,

    2,    3,    1,    1,    2,    2,    2,    1,    5,    2,

    3,    3,    6,    6,    1,    5,    1,    1,    8,    0,

    2,    2,    6,    1,    1,    1,    1,    2,    0,    1,

    2,    4,    1,    2,    3,    1,    1,    1,    4,    2,

    4,    1,    2,    3,    1,    1,    1,    4,    3,    2,

    3,    1,    3,    3,    1,    1,    1,    1,    1,    1,

    3,    5,    1,    2,    4,    3,    5,    1,    3,    0,

    2,    4,    2,    4,    2,    2,    4,    2,    1,    0,

};

const short yydefred[] =

    0,    0,    0,    0,  166,    0,  167,    0,    0,    0,

    0,    0,  184,  185,    0,    2,    4,    5,    6,    7,

    0,    0,    0,  381,  382,    0,   23,    0,    0,   25,

  191,  100,    0,   46,   45,   47,    0,    0,    0,  179,

  180,    0,  181,  182,    0,    0,  187,    0,   21,   22,

  373,    0,    0,  376,    0,    0,   83,  203,    0,   41,

    0,    0,   43,    0,    0,  175,    0,  176,   85,    0,

    0,  237,    0,    0,    0,    0,    0,  207,    0,    0,

  326,  201,  194,    0,  210,    0,    0,   69,    0,    0,

   75,    0,    0,   80,    0,  117,  118,    0,    0,  108,

    0,    0,    0,  204,    0,  205,    0,  332,   71,    0,

    0,  215,  219,    0,  222,    0,    0,    0,   92,    0,

   73,    0,    0,    0,    0,    0,  384,  385,  387,    0,

  383,  386,  388,    0,    0,  236,  260,  268,    0,    0,

    0,    0,    0,    0,    0,    0,    0,  133,    0,    0,

    0,    0,    0,  132,    0,    0,    0,    0,    0,    0,

    0,    0,    0,  153,    0,    0,  141,    0,    0,    0,

    0,    0,  305,  306,    0,    0,  291,  307,  308,    0,

    0,    0,    0,    0,    0,    0,    0,  316,  134,  276,

  277,    0,    0,    0,  125,  269,  285,  286,    0,    0,

    0,  126,  278,  309,  310,  130,    0,    0,    0,    0,

    0,    0,  289,    0,    0,    0,    0,    0,    0,  317,

    0,  371,  149,  151,  150,    0,    0,  274,    0,    0,

  283,  161,  160,  162,    0,  158,    0,  319,    0,    0,

  142,  144,    0,  147,  137,  152,    0,    0,   50,  114,

    0,  366,  367,    0,    0,  275,    0,    0,  284,    0,

  294,    0,  297,  323,    0,  345,    0,  359,  351,  355,

    0,  372,    0,  368,  270,    0,  271,  279,    0,  280,

    0,  157,    0,    0,    0,   51,   56,    0,    0,    0,

  263,   62,    0,    0,  346,    0,  369,    0,    0,    0,

  300,   86,  150,  486,  335,   65,  189,  108,  166,  278,

  648,  266,  345,  292,  293,  394,  586,  437,  590,  442,

  142,  145,  296,  317,  297,  403,  318,  319,  446,  333,

  190,  226,  227,  287,  259,  521,  583,  584,  199,  235,

  236,  535,  606,  607,   18,   19,   20,   21,   22,   23,

const short yysindex[] =

	{                                    -22,

    0,  147, 1004,  196,    0,  482,    0,  167, -112, 1802,

 -170,  -80,  -46,  -51,  229,    0,   11,  407,  415,  428,

  430,  450,  470,  493,  501,  506,  525,    0,  528,  546,

  549,    0,    0,  413,  503,  536,    0,    0,   47,    0,

   11, -190,  198,  -97,  -77, -205,  -20,  205, -244,  320,

  119,  211, -155, 1135,  559,  345,  297,  361,    0,  320,

  211,  170,    0,    0, -170,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,  329,  214,

  290,  659,    0,    0,    0,    0,    0,    0,    0,    0,

    0,   50,    0,    0,    0,    0,  211,    0,    0,    0,

    0,    0,  293,    0,  300,  315,  312,  321,  337,  633,

    0,  659,  383,    0,  390,  659,    0,    0, -166,    0,

    0,    0,    0,    0,    0,    0,    0,  739,  410,    0,

    0, 1135,  211,    0,    0,    0,    0,  280,    0,    0,

  435,    0,  659, -166,    0,    0,    0,    0,    0,    0,

  847,  211,    0,  342,  753,    0,  232,    0,    0,  -99,

  342,    0,  659,   63,  659,   73,  791,    0,  444,  764,

    0,    0,    0,  440,    0,  154,  790,    0,  -52,  296,

  512,    0,  844,  513,    0,    0,   58,    0,  770,    0,

    0,    0,    0,  170,  518,    0,    0,    0,   20,  761,

  861,   21,  -74,  -54,  619,  620,   49,    0,  -31,  -31,

  -31,  625,  476,    0,  992, 1027,  319,  -18,  627,  334,

  -21,  535,  539,    0,  211,  547,    0,  634,   49,  342,

   49, -265,    0,    0,    0,    0, 5270,    0,    0,  659,

  565,    0,  659,    0,    0,    0,  600,  644,    0,  298,

    0,  603,    0,  170,  659,  155,    0,    0,    0,    0,

    0,  659,  589,  371,    0,    0,    0,    0,  659,  591,

    0,    0,  913,    0,    0,    0,    0,  596,    0,    0,

    0,    0,  689,  119,    0,  709,    0,  211, -166,    0,

    0,    0,    0,    0,  613,    0,  411,    0,  417,  170,

    0,    0,    0,  603,    0,  659,    0,    0,  615,  616,

  621,    0,    0,  691,    0,  421,  659,    0,    0,  480,

  659,    0,    0,  443,  538,  486,    0,    0,    0,    0,

 1011,  659,    0,    0,    0,    0,  811,    0,  402,    0,

  618,    0,  972,  747,  659,    0,    0, 1008, 1009, 1010,

    0,    0,  659,  659,    0,  538,    0,  538,  659,  659,

	{                                      8,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,   33,    0,    0,    0,

    0,    0,    0,    0,    0,    0, 1038, 3717,    0,    0,

    0,  422,    0,    0,    0,   22,    0, 3403,    0,    0,

 3834,    0,    3,  676,    3,  676, -140,    0,    0,    0,

    0,    0,    0,    0,  546,    0,    0,  562,  672,    0,

 4284,    3,    3,    0, -140,    0,  516,    0,    0,    0,

  -47,    0, 4876,  234,    0,    0,    0,  356,    0,    0,

    0,    0,  578,  771,  422,   34,    0,    0,    0, 1000,

 1157,    0, 4974, 4974,  212, 2505, 2972, 3502, 1323,   30,

    0,    0,    0,    0, 3502,    0, 3502,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    3,  676,    0,    0,

    0,    0,    0,    0,    0,   64,    0,    0,    0,    0,

   34,    0,    0, 1188,    1,  217,    0,    0,    0,    0,

 3070,    0,    0,    0,    0,    0, 4678,    0,    4,   39,

    0,    0,    0, 1091,  873,    0, 1091,  873,    0,  685,

    0,  873,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0, 5073,    3,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,  172,

  -37,    0,    0,    0, 3502,    0,    0,    0,};

  164,    0,   72, -119,  575,    0,    0, -379, -280,  593,

   91, 1020,    0,    0, -372,    0,    0,    0,    0, -221,

    0,  839,    0, -250,    0,    0,    0, -488,    0, -496,

    0,  737,    0, -395,    0,    0, -494,    0,    0, -495,

  932, 1044,    0, 1054,    0,  891,    0,    0,   -9,  636,

  826,  813,  723,    0,    0, -455,    0,    0,  867,    0,

};

const short yytable[] =

  238,  480,  238,  234,  556,   89,  516,  248,  452,  332,

  591,   88,  452,  609,  248,  203,  587,  291,  248,  208,

  248,  567,  311,  248,  248,   92,  238,  248,  435,  160,

  499,  180,  238,  238,  241,  212,  171,  248,  406,  248,

  301,  211,  316,  269,   86,  674,  171,  495,  678,  497,

  417,  418,  420,  132,  238,  359,   39,  279,  330,  507,

  238,  238,  330,  336,  419,  543,  544,  545,  330,   84,

   97,  503,  196,  252,  238,  171,  496,  238,  331,  238,

   78,  238,  331,  294,  238,  421,  380,   61,  331,  422,

  238,  595,  295,    1,    1,    1,    1,   40,  611,  619,

    1,  314,    1,   60,  518,  311,  238,  238,  315,  570,

  248,  248,  238,  248,  311,  311,  311,    1,  249,  311,

  311,  180,  238,  238,  622,  238,  624,   68,  238,   69,

  312,   12,  211,  647,  320,  698,  628,  598,  249,   71,

  326,  656,   14,  238,  659,  181,  640,  661,  104,  105,

  643,  159,   72,  626,  238,  238,  181,  320,  320,  320,

  238,  671,   80,  649,  182,  638,  380,  380,  380,  134,

  135,  238,  238,  238,  675,   77,  321,  327,   78,  321,

  238,  115,  328,  329,  684,   81,  171,   87,  328,  329,

  646,  143,  144,   84,   84,  249,  187,  188,  249,  380,

  129,  453,  453,  453,  249,  249,  131,  669,  670,  380,

  380,  380,  139,  249,  249,  249,  464,  249,  249,  471,

  249,  249,  146,  652,  655,  249,  147,  249,  249,  249,

  249,  249,  249,  249,  249,  249,  249,  658,  149,  380,

  249,  151,  352,  351,  353,  249,  164,  165,  152,  477,

  380,  167,  478,  249,  249,  264,  249,  533,  173,  352,

  392,  264,  264,  264,  249,  249,  249,  249,  249,  249,