Connect flex 2.5.37 to the build and bump __FreeBSD_version.

33 files changed, 9880 insertions, 15378 deletions

diff --git a/Makefile.inc1 b/Makefile.inc1
index 1e58f47100bb..f0649efbca2d 100644
--- a/Makefile.inc1
+++ b/Makefile.inc1
@@ -1206,6 +1206,10 @@ _sed=		usr.bin/sed
 _lex=		usr.bin/lex
 .endif
 
+.if ${BOOTSTRAPPING} < 1000002
+_m4=		usr.bin/m4
+.endif
+
 .if ${BOOTSTRAPPING} < 1000013
 _yacc=		lib/liby \
 		usr.bin/yacc
@@ -1283,6 +1287,7 @@ bootstrap-tools:
     usr.bin/rpcgen \
     ${_sed} \
     ${_yacc} \
+    ${_m4} \
     ${_lex} \
     lib/libmd \
     usr.bin/xinstall \
diff --git a/sys/sys/param.h b/sys/sys/param.h
index c90f61633fa0..b6820988a2cd 100644
--- a/sys/sys/param.h
+++ b/sys/sys/param.h
@@ -58,7 +58,7 @@
  *		in the range 5 to 9.
  */
 #undef __FreeBSD_version
-#define __FreeBSD_version 1000032	/* Master, propagated to newvers */
+#define __FreeBSD_version 1000033	/* Master, propagated to newvers */
 
 /*
  * __FreeBSD_kernel__ indicates that this system uses the kernel of FreeBSD,
diff --git a/usr.bin/lex/COPYING b/usr.bin/lex/COPYING
deleted file mode 100644
index dcb775e7c606..000000000000
--- a/usr.bin/lex/COPYING
+++ /dev/null
@@ -1,38 +0,0 @@
-Flex carries the copyright used for BSD software, slightly modified
-because it originated at the Lawrence Berkeley (not Livermore!) Laboratory,
-which operates under a contract with the Department of Energy:
-
-	Copyright (c) 1990 The Regents of the University of California.
-	All rights reserved.
-
-	This code is derived from software contributed to Berkeley by
-	Vern Paxson.
-
-	The United States Government has rights in this work pursuant
-	to contract no. DE-AC03-76SF00098 between the United States
-	Department of Energy and the University of California.
-
-	Redistribution and use in source and binary forms are permitted
-	provided that: (1) source distributions retain this entire
-	copyright notice and comment, and (2) distributions including
-	binaries display the following acknowledgement:  ``This product
-	includes software developed by the University of California,
-	Berkeley and its contributors'' in the documentation or other
-	materials provided with the distribution and in all advertising
-	materials mentioning features or use of this software.  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.
-
-This basically says "do whatever you please with this software except
-remove this notice or take advantage of the University's (or the flex
-authors') name".
-
-Note that the "flex.skl" scanner skeleton carries no copyright notice.
-You are free to do whatever you please with scanners generated using flex;
-for them, you are not even bound by the above copyright.
diff --git a/usr.bin/lex/FlexLexer.h b/usr.bin/lex/FlexLexer.h
deleted file mode 100644
index 12e8ec32f61f..000000000000
--- a/usr.bin/lex/FlexLexer.h
+++ /dev/null
@@ -1,186 +0,0 @@
-// $Header: /home/daffy/u0/vern/flex/RCS/FlexLexer.h,v 1.19 96/05/25 20:43:02 vern Exp $
-// $FreeBSD$
-
-// FlexLexer.h -- define interfaces for lexical analyzer classes generated
-//		  by flex
-
-// Copyright (c) 1993 The Regents of the University of California.
-// All rights reserved.
-//
-// This code is derived from software contributed to Berkeley by
-// Kent Williams and Tom Epperly.
-//
-// Redistribution and use in source and binary forms are permitted provided
-// that: (1) source distributions retain this entire copyright notice and
-// comment, and (2) distributions including binaries display the following
-// acknowledgement:  ``This product includes software developed by the
-// University of California, Berkeley and its contributors'' in the
-// documentation or other materials provided with the distribution and in
-// all advertising materials mentioning features or use of this software.
-// 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.
-
-// This file defines FlexLexer, an abstract class which specifies the
-// external interface provided to flex C++ lexer objects, and yyFlexLexer,
-// which defines a particular lexer class.
-//
-// If you want to create multiple lexer classes, you use the -P flag
-// to rename each yyFlexLexer to some other xxFlexLexer.  You then
-// include <FlexLexer.h> in your other sources once per lexer class:
-//
-//	#undef yyFlexLexer
-//	#define yyFlexLexer xxFlexLexer
-//	#include <FlexLexer.h>
-//
-//	#undef yyFlexLexer
-//	#define yyFlexLexer zzFlexLexer
-//	#include <FlexLexer.h>
-//	...
-
-#ifndef __FLEX_LEXER_H
-// Never included before - need to define base class.
-#define __FLEX_LEXER_H
-#include <iostream>
-
-extern "C++" {
-
-struct yy_buffer_state;
-typedef int yy_state_type;
-
-class FlexLexer {
-public:
-	virtual ~FlexLexer()	{ }
-
-	const char* YYText()	{ return yytext; }
-	int YYLeng()		{ return yyleng; }
-
-	virtual void
-		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
-	virtual struct yy_buffer_state*
-		yy_create_buffer( std::istream* s, int size ) = 0;
-	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
-	virtual void yyrestart( std::istream* s ) = 0;
-
-	virtual int yylex() = 0;
-
-	// Call yylex with new input/output sources.
-	int yylex( std::istream* new_in, std::ostream* new_out = 0 )
-		{
-		switch_streams( new_in, new_out );
-		return yylex();
-		}
-
-	// Switch to new input/output streams.  A nil stream pointer
-	// indicates "keep the current one".
-	virtual void switch_streams( std::istream* new_in = 0,
-					std::ostream* new_out = 0 ) = 0;
-
-	int lineno() const		{ return yylineno; }
-
-	int debug() const		{ return yy_flex_debug; }
-	void set_debug( int flag )	{ yy_flex_debug = flag; }
-
-protected:
-	char* yytext;
-	int yyleng;
-	int yylineno;		// only maintained if you use %option yylineno
-	int yy_flex_debug;	// only has effect with -d or "%option debug"
-};
-
-}
-#endif
-
-#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
-// Either this is the first time through (yyFlexLexerOnce not defined),
-// or this is a repeated include to define a different flavor of
-// yyFlexLexer, as discussed in the flex man page.
-#define yyFlexLexerOnce
-
-class yyFlexLexer : public FlexLexer {
-public:
-	// arg_yyin and arg_yyout default to the cin and cout, but we
-	// only make that assignment when initializing in yylex().
-	yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
-
-	virtual ~yyFlexLexer();
-
-	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
-	struct yy_buffer_state* yy_create_buffer( std::istream* s, int size );
-	void yy_delete_buffer( struct yy_buffer_state* b );
-	void yyrestart( std::istream* s );
-
-	virtual int yylex();
-	virtual void switch_streams( std::istream* new_in, std::ostream* new_out );
-
-protected:
-	virtual int LexerInput( char* buf, int max_size );
-	virtual void LexerOutput( const char* buf, int size );
-	virtual void LexerError( const char* msg );
-
-	void yyunput( int c, char* buf_ptr );
-	int yyinput();
-
-	void yy_load_buffer_state();
-	void yy_init_buffer( struct yy_buffer_state* b, std::istream* s );
-	void yy_flush_buffer( struct yy_buffer_state* b );
-
-	int yy_start_stack_ptr;
-	int yy_start_stack_depth;
-	int* yy_start_stack;
-
-	void yy_push_state( int new_state );
-	void yy_pop_state();
-	int yy_top_state();
-
-	yy_state_type yy_get_previous_state();
-	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
-	int yy_get_next_buffer();
-
-	std::istream* yyin;	// input source for default LexerInput
-	std::ostream* yyout;	// output sink for default LexerOutput
-
-	struct yy_buffer_state* yy_current_buffer;
-
-	// yy_hold_char holds the character lost when yytext is formed.
-	char yy_hold_char;
-
-	// Number of characters read into yy_ch_buf.
-	int yy_n_chars;
-
-	// Points to current character in buffer.
-	char* yy_c_buf_p;
-
-	int yy_init;		// whether we need to initialize
-	int yy_start;		// start state number
-
-	// Flag which is used to allow yywrap()'s to do buffer switches
-	// instead of setting up a fresh yyin.  A bit of a hack ...
-	int yy_did_buffer_switch_on_eof;
-
-	// The following are not always needed, but may be depending
-	// on use of certain flex features (like REJECT or yymore()).
-
-	yy_state_type yy_last_accepting_state;
-	char* yy_last_accepting_cpos;
-
-	yy_state_type* yy_state_buf;
-	yy_state_type* yy_state_ptr;
-
-	char* yy_full_match;
-	int* yy_full_state;
-	int yy_full_lp;
-
-	int yy_lp;
-	int yy_looking_for_trail_begin;
-
-	int yy_more_flag;
-	int yy_more_len;
-	int yy_more_offset;
-	int yy_prev_more_offset;
-};
-
-#endif
diff --git a/usr.bin/lex/Makefile b/usr.bin/lex/Makefile
index 947eba184a68..f89609210e49 100644
--- a/usr.bin/lex/Makefile
+++ b/usr.bin/lex/Makefile
@@ -14,37 +14,51 @@ LINKS+=	${BINDIR}/lex ${BINDIR}/lex++
 LINKS+=	${BINDIR}/lex ${BINDIR}/flex
 LINKS+=	${BINDIR}/lex ${BINDIR}/flex++
 
-SRCS=		scan.c ccl.c dfa.c ecs.c gen.c main.c misc.c nfa.c parse.y \
-		skel.c sym.c tblcmp.c yylex.c
+FLEXDIR=	${.CURDIR}/../../contrib/flex
+
+.PATH:		${FLEXDIR}
+
+SRCS=		buf.c ccl.c dfa.c ecs.c filter.c gen.c main.c misc.c \
+		nfa.c options.c parse.y regex.c scan.c scanflags.c \
+		scanopt.c skel.c sym.c tables.c tables_shared.c \
+		tblcmp.c yylex.c
 LFLAGS+=	-is
-CFLAGS+=	-I. -I${.CURDIR}
+CFLAGS+=	-I. -I${.CURDIR} -I${FLEXDIR} -DHAVE_CONFIG_H
 INCS=		FlexLexer.h
 INCSDIR=	${INCLUDEDIR}
 MLINKS+=	lex.1 flex.1
 MLINKS+=	lex.1 flex++.1
 MLINKS+=	lex.1 lex++.1
 
-WARNS?=		2
+WARNS?=		3
 
 CLEANFILES=	scan.c skel.c
+GENFILES=	parse.c parse.h scan.c skel.c
 
 SUBDIR=		lib
 
-skel.c: mkskel.sh flex.skl
-	sh ${.CURDIR}/mkskel.sh ${.CURDIR}/flex.skl > skel.c
+FLEX_VERSION=	`awk -f ${.CURDIR}/version.awk ${.CURDIR}/config.h`
+
+skel.c: config.h mkskel.sh flex.skl version.awk
+	sed 's/m4_/m4postproc_/g; s/m4preproc_/m4_/g' \
+	    ${FLEXDIR}/flex.skl | \
+	m4 -I${FLEXDIR} -P ${FLEX_VERSION} | \
+	sed 's/m4postproc_/m4_/g' | \
+	sh ${FLEXDIR}/mkskel.sh > ${.TARGET}
 
-bootstrap: initscan.c
-	@cmp -s ${.CURDIR}/initscan.c scan.c || { \
-		echo "Bootstrapping flex" ; \
-		rm -f scan.c ; \
-		cp -f ${.CURDIR}/initscan.c scan.c ; \
+bootstrap: ${GENFILES:S/^/init/g}
+.for _f in ${GENFILES}
+	@diff -I '^#line ' -I '\$$FreeBS[D]: .*\$$' -q \
+	    ${.CURDIR}/init${_f} ${_f} 2> /dev/null || { \
+		echo "Bootstrapping ${_f}" ; \
+		cp -f ${.CURDIR}/init${_f} ${_f} ; \
 	}
+.endfor
 
 test: check
-check: $(PROG)
-	./$(PROG) $(LFLAGS) -t $(COMPRESSION) $(.CURDIR)/scan.l \
-	| sed s,\"$(.CURDIR)/scan.l",\"scan.l", \
-	| diff -I '\$$FreeBS[D]:.*\$$' $(.CURDIR)/initscan.c -
+check: ${PROG}
+	./${PROG} ${LFLAGS} -t ${COMPRESSION} ${FLEXDIR}/scan.l | \
+	diff -I '^#line ' -I '\$$FreeBS[D]: .*\$$' ${.CURDIR}/initscan.c -
 	@echo "Check successful"
 
 .include <bsd.prog.mk>
diff --git a/usr.bin/lex/NEWS b/usr.bin/lex/NEWS
deleted file mode 100644
index 1f8a8cc336b6..000000000000
--- a/usr.bin/lex/NEWS
+++ /dev/null
@@ -1,1235 +0,0 @@
-$FreeBSD$
-
-Changes between release 2.5.4 (11Sep96) and release 2.5.3:
-
-	- Fixed a bug introduced in 2.5.3 that blew it when a call
-	  to input() occurred at the end of an input file.
-
-	- Fixed scanner skeleton so the example in the man page of
-	  scanning strings using exclusive start conditions works.
-
-	- Minor Makefile tweaks.
-
-
-Changes between release 2.5.3 (29May96) and release 2.5.2:
-
-	- Some serious bugs in yymore() have been fixed.  In particular,
-	  when using AT&T-lex-compatibility or %array, you can intermix
-	  calls to input(), unput(), and yymore().  (This still doesn't
-	  work for %pointer, and isn't likely to in the future.)
-
-	- A bug in handling NUL's in the input stream of scanners using
-	  REJECT has been fixed.
-
-	- The default main() in libfl.a now repeatedly calls yylex() until
-	  it returns 0, rather than just calling it once.
-
-	- Minor tweak for Windows NT Makefile, MISC/NT/Makefile.
-
-
-Changes between release 2.5.2 (25Apr95) and release 2.5.1:
-
-	- The --prefix configuration option now works.
-
-	- A bug that completely broke the "-Cf" table compression
-	  option has been fixed.
-
-	- A major headache involving "const" declarators and Solaris
-	  systems has been fixed.
-
-	- An octal escape sequence in a flex regular expression must
-	  now contain only the digits 0-7.
-
-	- You can now use "--" on the flex command line to mark the
-	  end of flex options.
-
-	- You can now specify the filename '-' as a synonym for stdin.
-
-	- By default, the scanners generated by flex no longer
-	  statically initialize yyin and yyout to stdin and stdout.
-	  This change is necessary because in some ANSI environments,
-	  stdin and stdout are not compile-time constant.  You can
-	  force the initialization using "%option stdinit" in the first
-	  section of your flex input.
-
-	- "%option nounput" now correctly omits the unput() routine
-	  from the output.
-
-	- "make clean" now removes config.log, config.cache, and the
-	  flex binary.  The fact that it removes the flex binary means
-	  you should take care if making changes to scan.l, to make
-	  sure you don't wind up in a bootstrap problem.
-
-	- In general, the Makefile has been reworked somewhat (thanks
-	  to Francois Pinard) for added flexibility - more changes will
-	  follow in subsequent releases.
-
-	- The .texi and .info files in MISC/texinfo/ have been updated,
-	  thanks also to Francois Pinard.
-
-	- The FlexLexer::yylex(istream* new_in, ostream* new_out) method
-	  now does not have a default for the first argument, to disambiguate
-	  it from FlexLexer::yylex().
-
-	- A bug in destructing a FlexLexer object before doing any scanning
-	  with it has been fixed.
-
-	- A problem with including FlexLexer.h multiple times has been fixed.
-
-	- The alloca() chud necessary to accommodate bison has grown
-	  even uglier, but hopefully more correct.
-
-	- A portability tweak has been added to accommodate compilers that
-	  use char* generic pointers.
-
-	- EBCDIC contact information in the file MISC/EBCDIC has been updated.
-
-	- An OS/2 Makefile and config.h for flex 2.5 is now available in
-	  MISC/OS2/, contributed by Kai Uwe Rommel.
-
-	- The descrip.mms file for building flex under VMS has been updated,
-	  thanks to Pat Rankin.
-
-	- The notes on building flex for the Amiga have been updated for
-	  flex 2.5, contributed by Andreas Scherer.
-
-
-Changes between release 2.5.1 (28Mar95) and release 2.4.7:
-
-	- A new concept of "start condition" scope has been introduced.
-	  A start condition scope is begun with:
-
-		<SCs>{
-
-	  where SCs is a list of one or more start conditions.  Inside
-	  the start condition scope, every rule automatically has the
-	  prefix <SCs> applied to it, until a '}' which matches the
-	  initial '{'.  So, for example:
-
-		<ESC>{
-			"\\n"	return '\n';
-			"\\r"	return '\r';
-			"\\f"	return '\f';
-			"\\0"	return '\0';
-		}
-
-	  is equivalent to:
-
-		<ESC>"\\n"	return '\n';
-		<ESC>"\\r"	return '\r';
-		<ESC>"\\f"	return '\f';
-		<ESC>"\\0"	return '\0';
-
-	  As indicated in this example, rules inside start condition scopes
-	  (and any rule, actually, other than the first) can be indented,
-	  to better show the extent of the scope.
-
-	  Start condition scopes may be nested.
-
-	- The new %option directive can be used in the first section of
-	  a flex scanner to control scanner-generation options.  Most
-	  options are given simply as names, optionally preceded by the
-	  word "no" (with no intervening whitespace) to negate their
-	  meaning.  Some are equivalent to flex flags, so putting them
-	  in your scanner source is equivalent to always specifying
-	  the flag (%option's take precedence over flags):
-
-		7bit	-7 option
-		8bit	-8 option
-		align	-Ca option
-		backup	-b option
-		batch	-B option
-		c++	-+ option
-		caseful	opposite of -i option (caseful is the default);
-		case-sensitive	same as above
-		caseless	-i option;
-		case-insensitive	same as above
-		debug	-d option
-		default	opposite of -s option
-		ecs	-Ce option
-		fast	-F option
-		full	-f option
-		interactive	-I option
-		lex-compat	-l option
-		meta-ecs	-Cm option
-		perf-report	-p option
-		read	-Cr option
-		stdout	-t option
-		verbose	-v option
-		warn	opposite of -w option (so use "%option nowarn" for -w)
-
-		array	equivalent to "%array"
-		pointer	equivalent to "%pointer" (default)
-
-	  Some provide new features:
-
-		always-interactive	generate a scanner which always
-			considers its input "interactive" (no call to isatty()
-			will be made when the scanner runs)
-		main	supply a main program for the scanner, which
-			simply calls yylex().  Implies %option noyywrap.
-		never-interactive	generate a scanner which never
-			considers its input "interactive" (no call to isatty()
-			will be made when the scanner runs)
-		stack	if set, enable start condition stacks (see below)
-		stdinit	if unset ("%option nostdinit"), initialize yyin
-			and yyout statically to nil FILE* pointers, instead
-			of stdin and stdout
-		yylineno	if set, keep track of the current line
-			number in global yylineno (this option is expensive
-			in terms of performance).  The line number is available
-			to C++ scanning objects via the new member function
-			lineno().
-		yywrap	if unset ("%option noyywrap"), scanner does not
-			call yywrap() upon EOF but simply assumes there
-			are no more files to scan
-
-	  Flex scans your rule actions to determine whether you use the
-	  REJECT or yymore features (this is not new).  Two %options can be
-	  used to override its decision, either by setting them to indicate
-	  the feature is indeed used, or unsetting them to indicate it
-	  actually is not used:
-
-		reject
-		yymore
-
-	  Three %option's take string-delimited values, offset with '=':
-
-		outfile="<name>"	equivalent to -o<name>
-		prefix="<name>"		equivalent to -P<name>
-		yyclass="<name>"	set the name of the C++ scanning class
-					(see below)
-
-	  A number of %option's are available for lint purists who
-	  want to suppress the appearance of unneeded routines in
-	  the generated scanner.  Each of the following, if unset,
-	  results in the corresponding routine not appearing in the
-	  generated scanner:
-
-		input, unput
-		yy_push_state, yy_pop_state, yy_top_state
-		yy_scan_buffer, yy_scan_bytes, yy_scan_string
-
-	  You can specify multiple options with a single %option directive,
-	  and multiple directives in the first section of your flex input file.
-
-	- The new function:
-
-		YY_BUFFER_STATE yy_scan_string( const char *str )
-
-	  returns a YY_BUFFER_STATE (which also becomes the current input
-	  buffer) for scanning the given string, which occurs starting
-	  with the next call to yylex().  The string must be NUL-terminated.
-	  A related function:
-
-		YY_BUFFER_STATE yy_scan_bytes( const char *bytes, int len )
-
-	  creates a buffer for scanning "len" bytes (including possibly NUL's)
-	  starting at location "bytes".
-
-	  Note that both of these functions create and scan a *copy* of
-	  the string/bytes.  (This may be desirable, since yylex() modifies
-	  the contents of the buffer it is scanning.)  You can avoid the
-	  copy by using:
-
-		YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-
-	  which scans in place the buffer starting at "base", consisting
-	  of "size" bytes, the last two bytes of which *must* be
-	  YY_END_OF_BUFFER_CHAR (these bytes are not scanned; thus, scanning
-	  consists of base[0] through base[size-2], inclusive).  If you
-	  fail to set up "base" in this manner, yy_scan_buffer returns a
-	  nil pointer instead of creating a new input buffer.
-
-	  The type yy_size_t is an integral type to which you can cast
-	  an integer expression reflecting the size of the buffer.
-
-	- Three new routines are available for manipulating stacks of
-	  start conditions:
-
-		void yy_push_state( int new_state )
-
-	  pushes the current start condition onto the top of the stack
-	  and BEGIN's "new_state" (recall that start condition names are
-	  also integers).
-
-		void yy_pop_state()
-
-	  pops the top of the stack and BEGIN's to it, and
-
-		int yy_top_state()
-
-	  returns the top of the stack without altering the stack's
-	  contents.
-
-	  The start condition stack grows dynamically and so has no built-in
-	  size limitation.  If memory is exhausted, program execution
-	  is aborted.
-
-	  To use start condition stacks, your scanner must include
-	  a "%option stack" directive.
-
-	- flex now supports POSIX character class expressions.  These
-	  are expressions enclosed inside "[:" and ":]" delimiters (which
-	  themselves must appear between the '[' and ']' of a character
-	  class; other elements may occur inside the character class, too).
-	  The expressions flex recognizes are:
-
-		[:alnum:] [:alpha:] [:blank:] [:cntrl:] [:digit:] [:graph:]	
-		[:lower:] [:print:] [:punct:] [:space:] [:upper:] [:xdigit:]
-
-	  These expressions all designate a set of characters equivalent to
-	  the corresponding isXXX function (for example, [:alnum:] designates
-	  those characters for which isalnum() returns true - i.e., any
-	  alphabetic or numeric).  Some systems don't provide isblank(),
-	  so flex defines [:blank:] as a blank or a tab.
-
-	  For example, the following character classes are all equivalent:
-
-		[[:alnum:]]
-		[[:alpha:][:digit:]
-		[[:alpha:]0-9]
-		[a-zA-Z0-9]
-
-	  If your scanner is case-insensitive (-i flag), then [:upper:]
-	  and [:lower:] are equivalent to [:alpha:].
-
-	- The promised rewrite of the C++ FlexLexer class has not yet
-	  been done.  Support for FlexLexer is limited at the moment to
-	  fixing show-stopper bugs, so, for example, the new functions
-	  yy_scan_string() & friends are not available to FlexLexer
-	  objects.
-
-	- The new macro
-
-		yy_set_interactive(is_interactive)
-
-	  can be used to control whether the current buffer is considered
-	  "interactive".  An interactive buffer is processed more slowly,
-	  but must be used when the scanner's input source is indeed
-	  interactive to avoid problems due to waiting to fill buffers
-	  (see the discussion of the -I flag in flex.1).  A non-zero value
-	  in the macro invocation marks the buffer as interactive, a zero
-	  value as non-interactive.  Note that use of this macro overrides
-	  "%option always-interactive" or "%option never-interactive".
-
-	  yy_set_interactive() must be invoked prior to beginning to
-	  scan the buffer.
-
-	- The new macro
-
-		yy_set_bol(at_bol)
-
-	  can be used to control whether the current buffer's scanning
-	  context for the next token match is done as though at the
-	  beginning of a line (non-zero macro argument; makes '^' anchored
-	  rules active) or not at the beginning of a line (zero argument,
-	  '^' rules inactive).
-
-	- Related to this change, the mechanism for determining when a scan is
-	  starting at the beginning of a line has changed.  It used to be
-	  that '^' was active iff the character prior to that at which the
-	  scan started was a newline.  The mechanism now is that '^' is
-	  active iff the last token ended in a newline (or the last call to
-	  input() returned a newline).  For most users, the difference in
-	  mechanisms is negligible.  Where it will make a difference,
-	  however, is if unput() or yyless() is used to alter the input
-	  stream.  When in doubt, use yy_set_bol().
-
-	- The new beginning-of-line mechanism involved changing some fairly
-	  twisted code, so it may have introduced bugs - beware ...
-
-	- The macro YY_AT_BOL() returns true if the next token scanned from
-	  the current buffer will have '^' rules active, false otherwise.
-
-	- The new function
-
-		void yy_flush_buffer( struct yy_buffer_state* b )
-
-	  flushes the contents of the current buffer (i.e., next time
-	  the scanner attempts to match a token using b as the current
-	  buffer, it will begin by invoking YY_INPUT to fill the buffer).
-	  This routine is also available to C++ scanners (unlike some
-	  of the other new routines).
-
-	  The related macro
-
-		YY_FLUSH_BUFFER
-
-	  flushes the contents of the current buffer.
-
-	- A new "-ooutput" option writes the generated scanner to "output".
-	  If used with -t, the scanner is still written to stdout, but
-	  its internal #line directives (see previous item) use "output".
-
-	- Flex now generates #line directives relating the code it
-	  produces to the output file; this means that error messages
-	  in the flex-generated code should be correctly pinpointed.
-
-	- When generating #line directives, filenames with embedded '\'s
-	  have those characters escaped (i.e., turned into '\\').  This
-	  feature helps with reporting filenames for some MS-DOS and OS/2
-	  systems.
-
-	- The FlexLexer class includes two new public member functions:
-
-		virtual void switch_streams( istream* new_in = 0,
-						ostream* new_out = 0 )
-
-	  reassigns yyin to new_in (if non-nil) and yyout to new_out
-	  (ditto), deleting the previous input buffer if yyin is
-	  reassigned.  It is used by:
-
-		int yylex( istream* new_in = 0, ostream* new_out = 0 )
-
-	  which first calls switch_streams() and then returns the value
-	  of calling yylex().
-
-	- C++ scanners now have yy_flex_debug as a member variable of
-	  FlexLexer rather than a global, and member functions for testing
-	  and setting it.
-
-	- When generating a C++ scanning class, you can now use
-
-		%option yyclass="foo"
-
-	  to inform flex that you have derived "foo" as a subclass of
-	  yyFlexLexer, so flex will place your actions in the member
-	  function foo::yylex() instead of yyFlexLexer::yylex().  It also
-	  generates a yyFlexLexer::yylex() member function that generates a
-	  run-time error if called (by invoking yyFlexLexer::LexerError()).
-	  This feature is necessary if your subclass "foo" introduces some
-	  additional member functions or variables that you need to access
-	  from yylex().
-
-	- Current texinfo files in MISC/texinfo, contributed by Francois
-	  Pinard.
-
-	- You can now change the name "flex" to something else (e.g., "lex")
-	  by redefining $(FLEX) in the Makefile.
-
-	- Two bugs (one serious) that could cause "bigcheck" to fail have
-	  been fixed.
-
-	- A number of portability/configuration changes have been made
-	  for easier portability.
-
-	- You can use "YYSTATE" in your scanner as an alias for YY_START
-	  (for AT&T lex compatibility).
-
-	- input() now maintains yylineno.
-
-	- input() no longer trashes yytext.
-
-	- interactive scanners now read characters in YY_INPUT up to a
-	  newline, a large performance gain.
-
-	- C++ scanner objects now work with the -P option.  You include
-	  <FlexLexer.h> once per scanner - see comments in <FlexLexer.h>
-	  (or flex.1) for details.
-
-	- C++ FlexLexer objects now use the "cerr" stream to report -d output
-	  instead of stdio.
-
-	- The -c flag now has its full glorious POSIX interpretation (do
-	  nothing), rather than being interpreted as an old-style -C flag.
-
-	- Scanners generated by flex now include two #define's giving
-	  the major and minor version numbers (YY_FLEX_MAJOR_VERSION,
-	  YY_FLEX_MINOR_VERSION).  These can then be tested to see
-	  whether certain flex features are available.
-
-	- Scanners generated using -l lex compatibility now have the symbol
-	  YY_FLEX_LEX_COMPAT #define'd.
-
-	- When initializing (i.e., yy_init is non-zero on entry to yylex()),
-	  generated scanners now set yy_init to zero before executing
-	  YY_USER_INIT.  This means that you can set yy_init back to a
-	  non-zero value in YY_USER_INIT if you need the scanner to be
-	  reinitialized on the next call.
-
-	- You can now use "#line" directives in the first section of your
-	  scanner specification.
-
-	- When generating full-table scanners (-Cf), flex now puts braces
-	  around each row of the 2-d array initialization, to silence warnings
-	  on over-zealous compilers.
-
-	- Improved support for MS-DOS.  The flex sources have been successfully
-	  built, unmodified, for Borland 4.02 (all that's required is a
-	  Borland Makefile and config.h file, which are supplied in
-	  MISC/Borland - contributed by Terrence O Kane).
-
-	- Improved support for Macintosh using Think C - the sources should
-	  build for this platform "out of the box".  Contributed by Scott
-	  Hofmann.
-
-	- Improved support for VMS, in MISC/VMS/, contributed by Pat Rankin.
-
-	- Support for the Amiga, in MISC/Amiga/, contributed by Andreas
-	  Scherer.  Note that the contributed files were developed for
-	  flex 2.4 and have not been tested with flex 2.5.
-
-	- Some notes on support for the NeXT, in MISC/NeXT, contributed
-	  by Raf Schietekat.
-
-	- The MISC/ directory now includes a preformatted version of flex.1
-	  in flex.man, and pre-yacc'd versions of parse.y in parse.{c,h}.
-
-	- The flex.1 and flexdoc.1 manual pages have been merged.  There
-	  is now just one document, flex.1, which includes an overview
-	  at the beginning to help you find the section you need.
-
-	- Documentation now clarifies that start conditions persist across
-	  switches to new input files or different input buffers.  If you
-	  want to e.g., return to INITIAL, you must explicitly do so.
-
-	- The "Performance Considerations" section of the manual has been
-	  updated.
-
-	- Documented the "yy_act" variable, which when YY_USER_ACTION is
-	  invoked holds the number of the matched rule, and added an
-	  example of using yy_act to profile how often each rule is matched.
-
-	- Added YY_NUM_RULES, a definition that gives the total number
-	  of rules in the file, including the default rule (even if you
-	  use -s).
-
-	- Documentation now clarifies that you can pass a nil FILE* pointer
-	  to yy_create_buffer() or yyrestart() if you've arrange YY_INPUT
-	  to not need yyin.
-
-	- Documentation now clarifies that YY_BUFFER_STATE is a pointer to
-	  an opaque "struct yy_buffer_state".
-
-	- Documentation now stresses that you gain the benefits of removing
-	  backing-up states only if you remove *all* of them.
-
-	- Documentation now points out that traditional lex allows you
-	  to put the action on a separate line from the rule pattern if
-	  the pattern has trailing whitespace (ugh!), but flex doesn't
-	  support this.
-
-	- A broken example in documentation of the difference between
-	  inclusive and exclusive start conditions is now fixed.
-
-	- Usage (-h) report now goes to stdout.
-
-	- Version (-V) info now goes to stdout.
-
-	- More #ifdef chud has been added to the parser in attempt to
-	  deal with bison's use of alloca().
-
-	- "make clean" no longer deletes emacs backup files (*~).
-
-	- Some memory leaks have been fixed.
-
-	- A bug was fixed in which dynamically-expanded buffers were
-	  reallocated a couple of bytes too small.
-
-	- A bug was fixed which could cause flex to read and write beyond
-	  the end of the input buffer.
-
-	- -S will not be going away.
-
-
-Changes between release 2.4.7 (03Aug94) and release 2.4.6:
-
-	- Fixed serious bug in reading multiple files.
-
-	- Fixed bug in scanning NUL's.
-
-	- Fixed bug in input() returning 8-bit characters.
-
-	- Fixed bug in matching text with embedded NUL's when
-	  using %array or lex compatibility.
-
-	- Fixed multiple invocations of YY_USER_ACTION when using '|'
-	  continuation action.
-
-	- Minor prototyping fixes.
-
-Changes between release 2.4.6 (04Jan94) and release 2.4.5:
-
-	- Linking with -lfl no longer required if your program includes
-	  its own yywrap() and main() functions.  (This change will cause
-	  problems if you have a non-ANSI compiler on a system for which
-	  sizeof(int) != sizeof(void*) or sizeof(int) != sizeof(size_t).)
-
-	- The use of 'extern "C++"' in FlexLexer.h has been modified to
-	  get around an incompatibility with g++'s header files.
-
-Changes between release 2.4.5 (11Dec93) and release 2.4.4:
-
-	- Fixed bug breaking C++ scanners that use REJECT or variable
-	  trailing context.
-
-	- Fixed serious input problem for interactive scanners on
-	  systems for which char is unsigned.
-
-	- Fixed bug in incorrectly treating '$' operator as variable
-	  trailing context.
-
-	- Fixed bug in -CF table representation that could lead to
-	  corrupt tables.
-
-	- Fixed fairly benign memory leak.
-
-	- Added `extern "C++"' wrapper to FlexLexer.h header.  This
-	  should overcome the g++ 2.5.X problems mentioned in the
-	  NEWS for release 2.4.3.
-
-	- Changed #include of FlexLexer.h to use <> instead of "".
-
-	- Added feature to control whether the scanner attempts to
-	  refill the input buffer once it's exhausted.  This feature
-	  will be documented in the 2.5 release.
-
-
-Changes between release 2.4.4 (07Dec93) and release 2.4.3:
-
-	- Fixed two serious bugs in scanning 8-bit characters.
-
-	- Fixed bug in YY_USER_ACTION that caused it to be executed
-	  inappropriately (on the scanner's own internal actions, and
-	  with incorrect yytext/yyleng values).
-
-	- Fixed bug in pointing yyin at a new file and resuming scanning.
-
-	- Portability fix regarding min/max/abs macros conflicting with
-	  function definitions in standard header files.
-
-	- Added a virtual LexerError() method to the C++ yyFlexLexer class
-	  for reporting error messages instead of always using cerr.
-
-	- Added warning in flexdoc that the C++ scanning class is presently
-	  experimental and subject to considerable change between major
-	  releases.
-
-
-Changes between release 2.4.3 (03Dec93) and release 2.4.2:
-
-	- Fixed bug causing fatal scanner messages to fail to print.
-
-	- Fixed things so FlexLexer.h can be included in other C++
-	  sources.  One side-effect of this change is that -+ and -CF
-	  are now incompatible.
-
-	- libfl.a now supplies private versions of the <string.h>/
-	  <strings.h> string routines needed by flex and the scanners
-	  it generates, to enhance portability to some BSD systems.
-
-	- More robust solution to 2.4.2's flexfatal() bug fix.
-
-	- Added ranlib of installed libfl.a.
-
-	- Some lint tweaks.
-
-	- NOTE: problems have been encountered attempting to build flex
-	  C++ scanners using g++ version 2.5.X.  The problem is due to an
-	  unfortunate heuristic in g++ 2.5.X that attempts to discern between
-	  C and C++ headers.  Because FlexLexer.h is installed (by default)
-	  in /usr/local/include and not /usr/local/lib/g++-include, g++ 2.5.X
-	  decides that it's a C header :-(.  So if you have problems, install
-	  the header in /usr/local/lib/g++-include instead.
-
-
-Changes between release 2.4.2 (01Dec93) and release 2.4.1:
-
-	- Fixed bug in libfl.a referring to non-existent "flexfatal" function.
-
-	- Modified to produce both compress'd and gzip'd tar files for
-	  distributions (you probably don't care about this change!).
-
-
-Changes between release 2.4.1 (30Nov93) and release 2.3.8:
-
-	- The new '-+' flag instructs flex to generate a C++ scanner class
-	  (thanks to Kent Williams).  flex writes an implementation of the
-	  class defined in FlexLexer.h to lex.yy.cc.  You may include
-	  multiple scanner classes in your program using the -P flag.  Note
-	  that the scanner class also provides a mechanism for creating
-	  reentrant scanners.  The scanner class uses C++ streams for I/O
-	  instead of FILE*'s (thanks to Tom Epperly).  If the flex executable's
-	  name ends in '+' then the '-+' flag is automatically on, so creating
-	  a symlink or copy of "flex" to "flex++" results in a version of
-	  flex that can be used exclusively for C++ scanners.
-
-	  Note that without the '-+' flag, flex-generated scanners can still
-	  be compiled using C++ compilers, though they use FILE*'s for I/O
-	  instead of streams.
-
-	  See the "GENERATING C++ SCANNERS" section of flexdoc for details.
-
-	- The new '-l' flag turns on maximum AT&T lex compatibility.  In
-	  particular, -l includes support for "yylineno" and makes yytext
-	  be an array instead of a pointer.  It does not, however, do away
-	  with all incompatibilities.  See the "INCOMPATIBILITIES WITH LEX
-	  AND POSIX" section of flexdoc for details.
-
-	- The new '-P' option specifies a prefix to use other than "yy"
-	  for the scanner's globally-visible variables, and for the
-	  "lex.yy.c" filename.  Using -P you can link together multiple
-	  flex scanners in the same executable.
-
-	- The distribution includes a "texinfo" version of flexdoc.1,
-	  contributed by Roland Pesch (thanks also to Marq Kole, who
-	  contributed another version).  It has not been brought up to
-	  date, but reflects version 2.3.  See MISC/flex.texinfo.
-
-	  The flex distribution will soon include G.T. Nicol's flex
-	  manual; he is presently bringing it up-to-date for version 2.4.
-
-	- yywrap() is now a function, and you now *must* link flex scanners
-	  with libfl.a.
-
-	- Site-configuration is now done via an autoconf-generated
-	  "configure" script contributed by Francois Pinard.
-
-	- Scanners now use fread() (or getc(), if interactive) and not
-	  read() for input.  A new "table compression" option, -Cr,
-	  overrides this change and causes the scanner to use read()
-	  (because read() is a bit faster than fread()).  -f and -F
-	  are now equivalent to -Cfr and -CFr; i.e., they imply the
-	  -Cr option.
-
-	- In the blessed name of POSIX compliance, flex supports "%array"
-	  and "%pointer" directives in the definitions (first) section of
-	  the scanner specification.  The former specifies that yytext
-	  should be an array (of size YYLMAX), the latter, that it should
-	  be a pointer.  The array version of yytext is universally slower
-	  than the pointer version, but has the advantage that its contents
-	  remain unmodified across calls to input() and unput() (the pointer
-	  version of yytext is, still, trashed by such calls).
-
-	  "%array" cannot be used with the '-+' C++ scanner class option.
-
-	- The new '-Ca' option directs flex to trade off memory for
-	  natural alignment when generating a scanner's tables.  In
-	  particular, table entries that would otherwise be "short"
-	  become "long".
-
-	- The new '-h' option produces a summary of the flex flags.
-
-	- The new '-V' option reports the flex version number and exits.
-
-	- The new scanner macro YY_START returns an integer value
-	  corresponding to the current start condition.  You can return
-	  to that start condition by passing the value to a subsequent
-	  "BEGIN" action.  You also can implement "start condition stacks"
-	  by storing the values in an integer stack.
-
-	- You can now redefine macros such as YY_INPUT by just #define'ing
-	  them to some other value in the first section of the flex input;
-	  no need to first #undef them.
-
-	- flex now generates warnings for rules that can't be matched.
-	  These warnings can be turned off using the new '-w' flag.  If
-	  your scanner uses REJECT then you will not get these warnings.
-
-	- If you specify the '-s' flag but the default rule can be matched,
-	  flex now generates a warning.
-
-	- "yyleng" is now a global, and may be modified by the user (though
-	  doing so and then using yymore() will yield weird results).
-
-	- Name definitions in the first section of a scanner specification
-	  can now include a leading '^' or trailing '$' operator.  In this
-	  case, the definition is *not* pushed back inside of parentheses.
-
-	- Scanners with compressed tables are now "interactive" (-I option)
-	  by default.  You can suppress this attribute (which makes them
-	  run slightly slower) using the new '-B' flag.
-
-	- Flex now generates 8-bit scanners by default, unless you use the
-	  -Cf or -CF compression options (-Cfe  and -CFe result in 8-bit
-	  scanners).  You can force it to generate a 7-bit scanner using
-	  the new '-7' flag.  You can build flex to generate 8-bit scanners
-	  for -Cf and -CF, too, by adding -DDEFAULT_CSIZE=256 to CFLAGS
-	  in the Makefile.
-
-	- You no longer need to call the scanner routine yyrestart() to
-	  inform the scanner that you have switched to a new file after
-	  having seen an EOF on the current input file.  Instead, just
-	  point yyin at the new file and continue scanning.
-
-	- You no longer need to invoke YY_NEW_FILE in an <<EOF>> action
-	  to indicate you wish to continue scanning.  Simply point yyin
-	  at a new file.
-
-	- A leading '#' no longer introduces a comment in a flex input.
-
-	- flex no longer considers formfeed ('\f') a whitespace character.
-
-	- %t, I'm happy to report, has been nuked.
-
-	- The '-p' option may be given twice ('-pp') to instruct flex to
-	  report minor performance problems as well as major ones.
-
-	- The '-v' verbose output no longer includes start/finish time
-	  information.
-
-	- Newlines in flex inputs can optionally include leading or
-	  trailing carriage-returns ('\r'), in support of several PC/Mac
-	  run-time libraries that automatically include these.
-
-	- A start condition of the form "<*>" makes the following rule
-	  active in every start condition, whether exclusive or inclusive.
-
-	- The following items have been corrected in the flex documentation:
-
-		- '-C' table compression options *are* cumulative.
-
-		- You may modify yytext but not lengthen it by appending
-		  characters to the end.  Modifying its final character
-		  will affect '^' anchoring for the next rule matched
-		  if the character is changed to or from a newline.
-
-		- The term "backtracking" has been renamed "backing up",
-		  since it is a one-time repositioning and not a repeated
-		  search.  What used to be the "lex.backtrack" file is now
-		  "lex.backup".
-
-		- Unindented "/* ... */" comments are allowed in the first
-		  flex input section, but not in the second.
-
-		- yyless() can only be used in the flex input source, not
-		  externally.
-
-		- You can use "yyrestart(yyin)" to throw away the
-		  current contents of the input buffer.
-
-		- To write high-speed scanners, attempt to match as much
-		  text as possible with each rule.  See MISC/fastwc/README
-		  for more information.
-
-		- Using the beginning-of-line operator ('^') is fairly
-		  cheap.  Using unput() is expensive.  Using yyless() is
-		  cheap.
-
-		- An example of scanning strings with embedded escape
-		  sequences has been added.
-
-		- The example of backing-up in flexdoc was erroneous; it
-		  has been corrected.
-
-	- A flex scanner's internal buffer now dynamically grows if needed
-	  to match large tokens.  Note that growing the buffer presently
-	  requires rescanning the (large) token, so consuming a lot of
-	  text this way is a slow process.  Also note that presently the
-	  buffer does *not* grow if you unput() more text than can fit
-	  into the buffer.
-
-	- The MISC/ directory has been reorganized; see MISC/README for
-	  details.
-
-	- yyless() can now be used in the third (user action) section
-	  of a scanner specification, thanks to Ceriel Jacobs.  yyless()
-	  remains a macro and cannot be used outside of the scanner source.
-
-	- The skeleton file is no longer opened at run-time, but instead
-	  compiled into a large string array (thanks to John Gilmore and
-	  friends at Cygnus).  You can still use the -S flag to point flex
-	  at a different skeleton file.
-
-	- flex no longer uses a temporary file to store the scanner's
-	  actions.
-
-	- A number of changes have been made to decrease porting headaches.
-	  In particular, flex no longer uses memset() or ctime(), and
-	  provides a single simple mechanism for dealing with C compilers
-	  that still define malloc() as returning char* instead of void*.
-
-	- Flex now detects if the scanner specification requires the -8 flag
-	  but the flag was not given or on by default.
-
-	- A number of table-expansion fencepost bugs have been fixed,
-	  making flex more robust for generating large scanners.
-
-	- flex more consistently identifies the location of errors in
-	  its input.
-
-	- YY_USER_ACTION is now invoked only for "real" actions, not for
-	  internal actions used by the scanner for things like filling
-	  the buffer or handling EOF.
-
-	- The rule "[^]]" now matches any character other than a ']';
-	  formerly it matched any character at all followed by a ']'.
-	  This change was made for compatibility with AT&T lex.
-
-	- A large number of miscellaneous bugs have been found and fixed
-	  thanks to Gerhard Wilhelms.
-
-	- The source code has been heavily reformatted, making patches
-	  relative to previous flex releases no longer accurate.
-
-
-Changes between 2.3 Patch #8 (21Feb93) and 2.3 Patch #7:
-
-	- Fixed bugs in dynamic memory allocation leading to grievous
-	  fencepost problems when generating large scanners.
-	- Fixed bug causing infinite loops on character classes with 8-bit
-	  characters in them.
-	- Fixed bug in matching repetitions with a lower bound of 0.
-	- Fixed bug in scanning NUL characters using an "interactive" scanner.
-	- Fixed bug in using yymore() at the end of a file.
-	- Fixed bug in misrecognizing rules with variable trailing context.
-	- Fixed bug compiling flex on Suns using gcc 2.
-	- Fixed bug in not recognizing that input files with the character
-	  ASCII 128 in them require the -8 flag.
-	- Fixed bug that could cause an infinite loop writing out
-	  error messages.
-	- Fixed bug in not recognizing old-style lex % declarations if
-	  followed by a tab instead of a space.
-	- Fixed potential crash when flex terminated early (usually due
-	  to a bad flag) and the -v flag had been given.
-	- Added some missing declarations of void functions.
-	- Changed to only use '\a' for __STDC__ compilers.
-	- Updated mailing addresses.
-
-
-Changes between 2.3 Patch #7 (28Mar91) and 2.3 Patch #6:
-
-	- Fixed out-of-bounds array access that caused bad tables
-	  to be produced on machines where the bad reference happened
-	  to yield a 1.  This caused problems installing or running
-	  flex on some Suns, in particular.
-
-
-Changes between 2.3 Patch #6 (29Aug90) and 2.3 Patch #5:
-
-	- Fixed a serious bug in yymore() which basically made it
-	  completely broken.  Thanks goes to Jean Christophe of
-	  the Nethack development team for finding the problem
-	  and passing along the fix.
-
-
-Changes between 2.3 Patch #5 (16Aug90) and 2.3 Patch #4:
-
-	- An up-to-date version of initscan.c so "make test" will
-	  work after applying the previous patches
-
-
-Changes between 2.3 Patch #4 (14Aug90) and 2.3 Patch #3:
-
-	- Fixed bug in hexadecimal escapes which allowed only digits,
-	  not letters, in escapes
-	- Fixed bug in previous "Changes" file!
-
-
-Changes between 2.3 Patch #3 (03Aug90) and 2.3 Patch #2:
-
-	- Correction to patch #2 for gcc compilation; thanks goes to
-	  Paul Eggert for catching this.
-
-
-Changes between 2.3 Patch #2 (02Aug90) and original 2.3 release:
-
-	- Fixed (hopefully) headaches involving declaring malloc()
-	  and free() for gcc, which defines __STDC__ but (often) doesn't
-	  come with the standard include files such as <stdlib.h>.
-	  Reordered #ifdef maze in the scanner skeleton in the hope of
-	  getting the declarations right for cfront and g++, too.
-
-	- Note that this patch supercedes patch #1 for release 2.3,
-	  which was never announced but was available briefly for
-	  anonymous ftp.
-
-
-Changes between 2.3 (full) release of 28Jun90 and 2.2 (alpha) release:
-
-    User-visible:
-
-	- A lone <<EOF>> rule (that is, one which is not qualified with
-	  a list of start conditions) now specifies the EOF action for
-	  *all* start conditions which haven't already had <<EOF>> actions
-	  given.  To specify an end-of-file action for just the initial
-	  state, use <INITIAL><<EOF>>.
-
-	- -d debug output is now contingent on the global yy_flex_debug
-	  being set to a non-zero value, which it is by default.
-
-	- A new macro, YY_USER_INIT, is provided for the user to specify
-	  initialization action to be taken on the first call to the
-	  scanner.  This action is done before the scanner does its
-	  own initialization.
-
-	- yy_new_buffer() has been added as an alias for yy_create_buffer()
-
-	- Comments beginning with '#' and extending to the end of the line
-	  now work, but have been deprecated (in anticipation of making
-	  flex recognize #line directives).
-
-	- The funky restrictions on when semi-colons could follow the
-	  YY_NEW_FILE and yyless macros have been removed.  They now
-	  behave identically to functions.
-
-	- A bug in the sample redefinition of YY_INPUT in the documentation
-	  has been corrected.
-
-	- A bug in the sample simple tokener in the documentation has
-	  been corrected.
-
-	- The documentation on the incompatibilities between flex and
-	  lex has been reordered so that the discussion of yylineno
-	  and input() come first, as it's anticipated that these will
-	  be the most common source of headaches.
-
-
-    Things which didn't used to be documented but now are:
-
-	- flex interprets "^foo|bar" differently from lex.  flex interprets
-	  it as "match either a 'foo' or a 'bar', providing it comes at the
-	  beginning of a line", whereas lex interprets it as "match either
-	  a 'foo' at the beginning of a line, or a 'bar' anywhere".
-
-	- flex initializes the global "yyin" on the first call to the
-	  scanner, while lex initializes it at compile-time.
-
-	- yy_switch_to_buffer() can be used in the yywrap() macro/routine.
-
-	- flex scanners do not use stdio for their input, and hence when
-	  writing an interactive scanner one must explicitly call fflush()
-	  after writing out a prompt.
-
-	- flex scanner can be made reentrant (after a fashion) by using
-	  "yyrestart( yyin );".  This is useful for interactive scanners
-	  which have interrupt handlers that long-jump out of the scanner.
-
-	- a defense of why yylineno is not supported is included, along
-	  with a suggestion on how to convert scanners which rely on it.
-
-
-    Other changes:
-
-	- Prototypes and proper declarations of void routines have
-	  been added to the flex source code, courtesy of Kevin B. Kenny.
-
-	- Routines dealing with memory allocation now use void* pointers
-	  instead of char* - see Makefile for porting implications.
-
-	- Error-checking is now done when flex closes a file.
-
-	- Various lint tweaks were added to reduce the number of gripes.
-
-	- Makefile has been further parameterized to aid in porting.
-
-	- Support for SCO Unix added.
-
-	- Flex now sports the latest & greatest UC copyright notice
-	  (which is only slightly different from the previous one).
-
-	- A note has been added to flexdoc.1 mentioning work in progress
-	  on modifying flex to generate straight C code rather than a
-	  table-driven automaton, with an email address of whom to contact
-	  if you are working along similar lines.
-
-
-Changes between 2.2 Patch #3 (30Mar90) and 2.2 Patch #2:
-
-	- fixed bug which caused -I scanners to bomb
-
-
-Changes between 2.2 Patch #2 (27Mar90) and 2.2 Patch #1:
-
-	- fixed bug writing past end of input buffer in yyunput()
-	- fixed bug detecting NUL's at the end of a buffer
-
-
-Changes between 2.2 Patch #1 (23Mar90) and 2.2 (alpha) release:
-
-	- Makefile fixes: definition of MAKE variable for systems
-	  which don't have it; installation of flexdoc.1 along with
-	  flex.1; fixed two bugs which could cause "bigtest" to fail.
-
-	- flex.skel fix for compiling with g++.
-
-	- README and flexdoc.1 no longer list an out-of-date BITNET address
-	  for contacting me.
-
-	- minor typos and formatting changes to flex.1 and flexdoc.1.
-
-
-Changes between 2.2 (alpha) release of March '90 and previous release:
-
-    User-visible:
-
-	- Full user documentation now available.
-
-	- Support for 8-bit scanners.
-
-	- Scanners now accept NUL's.
-
-	- A facility has been added for dealing with multiple
-	  input buffers.
-
-	- Two manual entries now.  One which fully describes flex
-	  (rather than just its differences from lex), and the
-	  other for quick(er) reference.
-
-	- A number of changes to bring flex closer into compliance
-	  with the latest POSIX lex draft:
-
-		%t support
-		flex now accepts multiple input files and concatenates
-		    them together to form its input
-		previous -c (compress) flag renamed -C
-		do-nothing -c and -n flags added
-		Any indented code or code within %{}'s in section 2 is
-		    now copied to the output
-
-	- yyleng is now a bona fide global integer.
-
-	- -d debug information now gives the line number of the
-	  matched rule instead of which number rule it was from
-	  the beginning of the file.
-
-	- -v output now includes a summary of the flags used to generate
-	  the scanner.
-
-	- unput() and yyrestart() are now globally callable.
-
-	- yyrestart() no longer closes the previous value of yyin.
-
-	- C++ support; generated scanners can be compiled with C++ compiler.
-
-	- Primitive -lfl library added, containing default main()
-	  which calls yylex().  A number of routines currently living
-	  in the scanner skeleton will probably migrate to here
-	  in the future (in particular, yywrap() will probably cease
-	  to be a macro and instead be a function in the -lfl library).
-
-	- Hexadecimal (\x) escape sequences added.
-
-	- Support for MS-DOS, VMS, and Turbo-C integrated.
-
-	- The %used/%unused operators have been deprecated.  They
-	  may go away soon.
-
-
-    Other changes:
-
-	- Makefile enhanced for easier testing and installation.
-	- The parser has been tweaked to detect some erroneous
-	  constructions which previously were missed.
-	- Scanner input buffer overflow is now detected.
-	- Bugs with missing "const" declarations fixed.
-	- Out-of-date Minix/Atari patches provided.
-	- Scanners no longer require printf() unless FLEX_DEBUG is being used.
-	- A subtle input() bug has been fixed.
-	- Line numbers for "continued action" rules (those following
-	  the special '|' action) are now correct.
-	- unput() bug fixed; had been causing problems porting flex to VMS.
-	- yymore() handling rewritten to fix bug with interaction
-	  between yymore() and trailing context.
-	- EOF in actions now generates an error message.
-	- Bug involving -CFe and generating equivalence classes fixed.
-	- Bug which made -CF be treated as -Cf fixed.
-	- Support for SysV tmpnam() added.
-	- Unused #define's for scanner no longer generated.
-	- Error messages which are associated with a particular input
-	  line are now all identified with their input line in standard
-	  format.
-	- % directives which are valid to lex but not to flex are
-	  now ignored instead of generating warnings.
-	- -DSYS_V flag can now also be specified -DUSG for System V
-	  compilation.
-
-
-Changes between 2.1 beta-test release of June '89 and previous release:
-
-    User-visible:
-
-	- -p flag generates a performance report to stderr.  The report
-	  consists of comments regarding features of the scanner rules
-	  which result in slower scanners.
-
-	- -b flag generates backtracking information to lex.backtrack.
-	  This is a list of scanner states which require backtracking
-	  and the characters on which they do so.  By adding rules
-	  one can remove backtracking states.  If all backtracking states
-	  are eliminated, the generated scanner will run faster.
-	  Backtracking is not yet documented in the manual entry.
-
-	- Variable trailing context now works, i.e., one can have
-	  rules like "(foo)*/[ \t]*bletch".  Some trailing context
-	  patterns still cannot be properly matched and generate
-	  error messages.  These are patterns where the ending of the
-	  first part of the rule matches the beginning of the second
-	  part, such as "zx*/xy*", where the 'x*' matches the 'x' at
-	  the beginning of the trailing context.  Lex won't get these
-	  patterns right either.
-
-	- Faster scanners.
-
-	- End-of-file rules.  The special rule "<<EOF>>" indicates
-	  actions which are to be taken when an end-of-file is
-	  encountered and yywrap() returns non-zero (i.e., indicates
-	  no further files to process).  See manual entry for example.
-
-	- The -r (reject used) flag is gone.  flex now scans the input
-	  for occurrences of the string "REJECT" to determine if the
-	  action is needed.  It tries to be intelligent about this but
-	  can be fooled.  One can force the presence or absence of
-	  REJECT by adding a line in the first section of the form
-	  "%used REJECT" or "%unused REJECT".
-
-	- yymore() has been implemented.  Similarly to REJECT, flex
-	  detects the use of yymore(), which can be overridden using
-	  "%used" or "%unused".
-
-	- Patterns like "x{0,3}" now work (i.e., with lower-limit == 0).
-
-	- Removed '\^x' for ctrl-x misfeature.
-
-	- Added '\a' and '\v' escape sequences.
-
-	- \<digits> now works for octal escape sequences; previously
-	  \0<digits> was required.
-
-	- Better error reporting; line numbers are associated with rules.
-
-	- yyleng is a macro; it cannot be accessed outside of the
-	  scanner source file.
-
-	- yytext and yyleng should not be modified within a flex action.
-
-	- Generated scanners #define the name FLEX_SCANNER.
-
-	- Rules are internally separated by YY_BREAK in lex.yy.c rather
-	  than break, to allow redefinition.
-
-	- The macro YY_USER_ACTION can be redefined to provide an action
-	  which is always executed prior to the matched rule's action.
-	
-	- yyrestart() is a new action which can be used to restart
-	  the scanner after it has seen an end-of-file (a "real" one,
-	  that is, one for which yywrap() returned non-zero).  It takes
-	  a FILE* argument indicating a new file to scan and sets
-	  things up so that a subsequent call to yylex() will start
-	  scanning that file.
-
-	- Internal scanner names all preceded by "yy_"
-
-	- lex.yy.c is deleted if errors are encountered during processing.
-
-	- Comments may be put in the first section of the input by preceding
-	  them with '#'.
-
-
-
-    Other changes:
-
-	- Some portability-related bugs fixed, in particular for machines
-	  with unsigned characters or sizeof( int* ) != sizeof( int ).
-	  Also, tweaks for VMS and Microsoft C (MS-DOS), and identifiers all
-	  trimmed to be 31 or fewer characters.  Shortened file names
-	  for dinosaur OS's.  Checks for allocating > 64K memory
-	  on 16 bit'ers.  Amiga tweaks.  Compiles using gcc on a Sun-3.
-	- Compressed and fast scanner skeletons merged.
-	- Skeleton header files done away with.
-	- Generated scanner uses prototypes and "const" for __STDC__.
-	- -DSV flag is now -DSYS_V for System V compilation.
-	- Removed all references to FTL language.
-	- Software now covered by BSD Copyright.
-	- flex will replace lex in subsequent BSD releases.
diff --git a/usr.bin/lex/README b/usr.bin/lex/README
deleted file mode 100644
index 7a4224dca3b7..000000000000
--- a/usr.bin/lex/README
+++ /dev/null
@@ -1,60 +0,0 @@
-This is release 2.5 of flex.  See "version.h" for the exact patch-level.
-
-See the file "NEWS" to find out what is new in this Flex release.
-
-Read the file "INSTALL" for general installation directives.  Peek near
-the beginning of the file "Makefile.in" for special DEFS values.  On most
-systems, you can just run the "configure" script and type "make" to build
-flex; then "make check" to test whether it built correctly; and if it did,
-then "make install" to install it.
-
-If you're feeling adventurous, you can also issue "make bigcheck" (be
-prepared to wait a while).
-
-Note that flex is distributed under a copyright very similar to that of
-BSD Unix, and not under the GNU General Public License (GPL), except for
-the "configure" script, which is covered by the GPL.
-
-Many thanks to the 2.5 beta-testers for finding bugs and helping test and
-increase portability: Stan Adermann, Scott David Daniels, Charles Elliott,
-Joe Gayda, Chris Meier, James Nordby, Terrence O'Kane, Karsten Pahnke,
-Francois Pinard, Pat Rankin, Andreas Scherer, Marc Wiese, Nathan Zelle.
-
-Please send bug reports and feedback to: Vern Paxson (vern@ee.lbl.gov).
-
-
-The flex distribution consists of the following files:
-
-	README		This message
-
-	NEWS		Differences between the various releases
-
-	INSTALL		General installation information
-
-	COPYING		flex's copyright
-
-	conf.in, configure.in, configure, Makefile.in, install.sh,
-		mkinstalldirs
-			elements of the "autoconf" auto-configuration process
-
-	flexdef.h, parse.y, scan.l, ccl.c, dfa.c, ecs.c, gen.c, main.c,
-	misc.c, nfa.c, sym.c, tblcmp.c, yylex.c	 
-			source files
-
-	version.h	version of this flex release
-
-	flex.skl	flex scanner skeleton
-	mkskel.sh	script for converting flex.skl to C source file skel.c
-	skel.c		pre-converted C version of flex.skl
-
-	libmain.c	flex library (-lfl) sources
-	libyywrap.c
-
-	initscan.c	pre-flex'd version of scan.l
-
-	FlexLexer.h	header file for C++ lexer class
-
-	flex.1		user documentation
-
-	MISC/		a directory containing miscellaneous contributions.
-			See MISC/README for details.
diff --git a/usr.bin/lex/ccl.c b/usr.bin/lex/ccl.c
deleted file mode 100644
index f2607bfa9094..000000000000
--- a/usr.bin/lex/ccl.c
+++ /dev/null
@@ -1,151 +0,0 @@
-/* ccl - routines for character classes */
-
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Vern Paxson.
- * 
- * The United States Government has rights in this work pursuant
- * to contract no. DE-AC03-76SF00098 between the United States
- * Department of Energy and the University of California.
- *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * 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.
- */
-
-/* $Header: /home/daffy/u0/vern/flex/RCS/ccl.c,v 2.9 93/09/16 20:32:14 vern Exp $ */
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include "flexdef.h"
-
-/* ccladd - add a single character to a ccl */
-
-void ccladd( cclp, ch )
-int cclp;
-int ch;
-	{
-	int ind, len, newpos, i;
-
-	check_char( ch );
-
-	len = ccllen[cclp];
-	ind = cclmap[cclp];
-
-	/* check to see if the character is already in the ccl */
-
-	for ( i = 0; i < len; ++i )
-		if ( ccltbl[ind + i] == ch )
-			return;
-
-	newpos = ind + len;
-
-	if ( newpos >= current_max_ccl_tbl_size )
-		{
-		current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
-
-		++num_reallocs;
-
-		ccltbl = reallocate_Character_array( ccltbl,
-						current_max_ccl_tbl_size );
-		}
-
-	ccllen[cclp] = len + 1;
-	ccltbl[newpos] = ch;
-	}
-
-
-/* cclinit - return an empty ccl */
-
-int cclinit()
-	{
-	if ( ++lastccl >= current_maxccls )
-		{
-		current_maxccls += MAX_CCLS_INCREMENT;
-
-		++num_reallocs;
-
-		cclmap = reallocate_integer_array( cclmap, current_maxccls );
-		ccllen = reallocate_integer_array( ccllen, current_maxccls );
-		cclng = reallocate_integer_array( cclng, current_maxccls );
-		}
-
-	if ( lastccl == 1 )
-		/* we're making the first ccl */
-		cclmap[lastccl] = 0;
-
-	else
-		/* The new pointer is just past the end of the last ccl.
-		 * Since the cclmap points to the \first/ character of a
-		 * ccl, adding the length of the ccl to the cclmap pointer
-		 * will produce a cursor to the first free space.
-		 */
-		cclmap[lastccl] = cclmap[lastccl - 1] + ccllen[lastccl - 1];
-
-	ccllen[lastccl] = 0;
-	cclng[lastccl] = 0;	/* ccl's start out life un-negated */
-
-	return lastccl;
-	}
-
-
-/* cclnegate - negate the given ccl */
-
-void cclnegate( cclp )
-int cclp;
-	{
-	cclng[cclp] = 1;
-	}
-
-
-/* list_character_set - list the members of a set of characters in CCL form
- *
- * Writes to the given file a character-class representation of those
- * characters present in the given CCL.  A character is present if it
- * has a non-zero value in the cset array.
- */
-
-void list_character_set( file, cset )
-FILE *file;
-int cset[];
-	{
-	int i;
-
-	putc( '[', file );
-
-	for ( i = 0; i < csize; ++i )
-		{
-		if ( cset[i] )
-			{
-			int start_char = i;
-
-			putc( ' ', file );
-
-			fputs( readable_form( i ), file );
-
-			while ( ++i < csize && cset[i] )
-				;
-
-			if ( i - 1 > start_char )
-				/* this was a run */
-				fprintf( file, "-%s", readable_form( i - 1 ) );
-
-			putc( ' ', file );
-			}
-		}
-
-	putc( ']', file );
-	}
diff --git a/usr.bin/lex/config.h b/usr.bin/lex/config.h
index 2e0b5b43747b..88361dfb93df 100644
--- a/usr.bin/lex/config.h
+++ b/usr.bin/lex/config.h
@@ -1,26 +1,208 @@
-/* config.h.  Generated automatically by configure.  */
+/* config.h.  Generated from conf.in by configure.  */
+/* conf.in.  Generated from configure.in by autoheader.  */
 /* $FreeBSD$ */
 
-/* Define to empty if the keyword does not work.  */
-/* #undef const */
+/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
+   systems. This function is required for `alloca.c' support on those systems.
+   */
+/* #undef CRAY_STACKSEG_END */
 
-/* Define to `unsigned' if <sys/types.h> doesn't define.  */
-/* #undef size_t */
+/* Define to 1 if using `alloca.c'. */
+/* #undef C_ALLOCA */
 
-/* Define if you have the ANSI C header files.  */
-#define STDC_HEADERS 1
+/* Define to 1 if translation of program messages to the user's native
+   language is requested. */
+/* #undef ENABLE_NLS */
+
+/* Define to 1 if you have `alloca', as a function or macro. */
+#define HAVE_ALLOCA 1
+
+/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
+   */
+/* #undef HAVE_ALLOCA_H */
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+/* #undef HAVE_DCGETTEXT */
+
+/* Define to 1 if you have the `dup2' function. */
+#define HAVE_DUP2 1
+
+/* Define to 1 if you have the `fork' function. */
+#define HAVE_FORK 1
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+/* #undef HAVE_GETTEXT */
+
+/* Define if you have the iconv() function. */
+/* #undef HAVE_ICONV */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `isascii' function. */
+#define HAVE_ISASCII 1
+
+/* Define to 1 if you have the <libintl.h> header file. */
+/* #undef HAVE_LIBINTL_H */
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* pthread library */
+#define HAVE_LIBPTHREAD 1
 
-/* Define if you have the <malloc.h> header file.  */
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <locale.h> header file. */
+#define HAVE_LOCALE_H 1
+
+/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
+   to 0 otherwise. */
+#define HAVE_MALLOC 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
 /* #undef HAVE_MALLOC_H */
 
-/* Define if you have the <string.h> header file.  */
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `memset' function. */
+#define HAVE_MEMSET 1
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#define HAVE_NETINET_IN_H 1
+
+/* Define to 1 if you have the `pow' function. */
+#define HAVE_POW 1
+
+/* Define to 1 if you have the <pthread.h> header file. */
+#define HAVE_PTHREAD_H 1
+
+/* Define to 1 if your system has a GNU libc compatible `realloc' function,
+   and to 0 otherwise. */
+#define HAVE_REALLOC 1
+
+/* Define to 1 if you have the `regcomp' function. */
+#define HAVE_REGCOMP 1
+
+/* Define to 1 if you have the <regex.h> header file. */
+#define HAVE_REGEX_H 1
+
+/* Define to 1 if you have the `setlocale' function. */
+#define HAVE_SETLOCALE 1
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#define HAVE_STDBOOL_H 1
+
+/* Define to 1 if you have the <stddef.h> header file. */
+#define HAVE_STDDEF_H 1
+
+/* 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 `strchr' function. */
+#define HAVE_STRCHR 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 if you have the <sys/types.h> header file.  */
+/* Define to 1 if you have the `strtol' function. */
+#define HAVE_STRTOL 1
+
+/* 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
 
-/* Define if you have <alloca.h> and it should be used (not on Ultrix).  */
-/* #undef HAVE_ALLOCA_H */
+/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
+#define HAVE_SYS_WAIT_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `vfork' function. */
+#define HAVE_VFORK 1
+
+/* Define to 1 if you have the <vfork.h> header file. */
+/* #undef HAVE_VFORK_H */
+
+/* Define to 1 if `fork' works. */
+#define HAVE_WORKING_FORK 1
+
+/* Define to 1 if `vfork' works. */
+#define HAVE_WORKING_VFORK 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#define HAVE__BOOL 1
+
+/* Define to the m4 executable name. */
+#define M4 "m4"
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
+
+/* Name of package */
+#define PACKAGE "flex"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "flex-help@lists.sourceforge.net"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "the fast lexical analyser generator"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "the fast lexical analyser generator 2.5.37"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "flex"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "2.5.37"
+
+/* If using the C implementation of alloca, define if you know the
+   direction of stack growth for your system; otherwise it will be
+   automatically deduced at runtime.
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown */
+/* #undef STACK_DIRECTION */
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "2.5.37"
+
+/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
+   `char[]'. */
+#define YYTEXT_POINTER 1
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to rpl_malloc if the replacement function should be used. */
+/* #undef malloc */
+
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef pid_t */
+
+/* Define to rpl_realloc if the replacement function should be used. */
+/* #undef realloc */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
 
-/* Define if platform-specific command line handling is necessary.  */
-/* #undef NEED_ARGV_FIXUP */
+/* Define as `fork' if `vfork' does not work. */
+/* #undef vfork */
diff --git a/usr.bin/lex/dfa.c b/usr.bin/lex/dfa.c
deleted file mode 100644
index 5a86af16a344..000000000000
--- a/usr.bin/lex/dfa.c
+++ /dev/null
@@ -1,1097 +0,0 @@
-/* dfa - DFA construction routines */
-
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Vern Paxson.
- * 
- * The United States Government has rights in this work pursuant
- * to contract no. DE-AC03-76SF00098 between the United States
- * Department of Energy and the University of California.
- *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * 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.
- */
-
-/* $Header: /home/daffy/u0/vern/flex/RCS/dfa.c,v 2.26 95/04/20 13:53:14 vern Exp $ */
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include "flexdef.h"
-
-
-/* declare functions that have forward references */
-
-void dump_associated_rules PROTO((FILE*, int));
-void dump_transitions PROTO((FILE*, int[]));
-void sympartition PROTO((int[], int, int[], int[]));
-int symfollowset PROTO((int[], int, int, int[]));
-
-
-/* check_for_backing_up - check a DFA state for backing up
- *
- * synopsis
- *     void check_for_backing_up( int ds, int state[numecs] );
- *
- * ds is the number of the state to check and state[] is its out-transitions,
- * indexed by equivalence class.
- */
-
-void check_for_backing_up( ds, state )
-int ds;
-int state[];
-	{
-	if ( (reject && ! dfaacc[ds].dfaacc_set) ||
-	     (! reject && ! dfaacc[ds].dfaacc_state) )
-		{ /* state is non-accepting */
-		++num_backing_up;
-
-		if ( backing_up_report )
-			{
-			fprintf( backing_up_file,
-				_( "State #%d is non-accepting -\n" ), ds );
-
-			/* identify the state */
-			dump_associated_rules( backing_up_file, ds );
-
-			/* Now identify it further using the out- and
-			 * jam-transitions.
-			 */
-			dump_transitions( backing_up_file, state );
-
-			putc( '\n', backing_up_file );
-			}
-		}
-	}
-
-
-/* check_trailing_context - check to see if NFA state set constitutes
- *                          "dangerous" trailing context
- *
- * synopsis
- *    void check_trailing_context( int nfa_states[num_states+1], int num_states,
- *				int accset[nacc+1], int nacc );
- *
- * NOTES
- *  Trailing context is "dangerous" if both the head and the trailing
- *  part are of variable size \and/ there's a DFA state which contains
- *  both an accepting state for the head part of the rule and NFA states
- *  which occur after the beginning of the trailing context.
- *
- *  When such a rule is matched, it's impossible to tell if having been
- *  in the DFA state indicates the beginning of the trailing context or
- *  further-along scanning of the pattern.  In these cases, a warning
- *  message is issued.
- *
- *    nfa_states[1 .. num_states] is the list of NFA states in the DFA.
- *    accset[1 .. nacc] is the list of accepting numbers for the DFA state.
- */
-
-void check_trailing_context( nfa_states, num_states, accset, nacc )
-int *nfa_states, num_states;
-int *accset;
-int nacc;
-	{
-	int i, j;
-
-	for ( i = 1; i <= num_states; ++i )
-		{
-		int ns = nfa_states[i];
-		int type = state_type[ns];
-		int ar = assoc_rule[ns];
-
-		if ( type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE )
-			{ /* do nothing */
-			}
-
-		else if ( type == STATE_TRAILING_CONTEXT )
-			{
-			/* Potential trouble.  Scan set of accepting numbers
-			 * for the one marking the end of the "head".  We
-			 * assume that this looping will be fairly cheap
-			 * since it's rare that an accepting number set
-			 * is large.
-			 */
-			for ( j = 1; j <= nacc; ++j )
-				if ( accset[j] & YY_TRAILING_HEAD_MASK )
-					{
-					line_warning(
-					_( "dangerous trailing context" ),
-						rule_linenum[ar] );
-					return;
-					}
-			}
-		}
-	}
-
-
-/* dump_associated_rules - list the rules associated with a DFA state
- *
- * Goes through the set of NFA states associated with the DFA and
- * extracts the first MAX_ASSOC_RULES unique rules, sorts them,
- * and writes a report to the given file.
- */
-
-void dump_associated_rules( file, ds )
-FILE *file;
-int ds;
-	{
-	int i, j;
-	int num_associated_rules = 0;
-	int rule_set[MAX_ASSOC_RULES + 1];
-	int *dset = dss[ds];
-	int size = dfasiz[ds];
-
-	for ( i = 1; i <= size; ++i )
-		{
-		int rule_num = rule_linenum[assoc_rule[dset[i]]];
-
-		for ( j = 1; j <= num_associated_rules; ++j )
-			if ( rule_num == rule_set[j] )
-				break;
-
-		if ( j > num_associated_rules )
-			{ /* new rule */
-			if ( num_associated_rules < MAX_ASSOC_RULES )
-				rule_set[++num_associated_rules] = rule_num;
-			}
-		}
-
-	bubble( rule_set, num_associated_rules );
-
-	fprintf( file, _( " associated rule line numbers:" ) );
-
-	for ( i = 1; i <= num_associated_rules; ++i )
-		{
-		if ( i % 8 == 1 )
-			putc( '\n', file );
-
-		fprintf( file, "\t%d", rule_set[i] );
-		}
-
-	putc( '\n', file );
-	}
-
-
-/* dump_transitions - list the transitions associated with a DFA state
- *
- * synopsis
- *     dump_transitions( FILE *file, int state[numecs] );
- *
- * Goes through the set of out-transitions and lists them in human-readable
- * form (i.e., not as equivalence classes); also lists jam transitions
- * (i.e., all those which are not out-transitions, plus EOF).  The dump
- * is done to the given file.
- */
-
-void dump_transitions( file, state )
-FILE *file;
-int state[];
-	{
-	int i, ec;
-	int out_char_set[CSIZE];
-
-	for ( i = 0; i < csize; ++i )
-		{
-		ec = ABS( ecgroup[i] );
-		out_char_set[i] = state[ec];
-		}
-
-	fprintf( file, _( " out-transitions: " ) );
-
-	list_character_set( file, out_char_set );
-
-	/* now invert the members of the set to get the jam transitions */
-	for ( i = 0; i < csize; ++i )
-		out_char_set[i] = ! out_char_set[i];
-
-	fprintf( file, _( "\n jam-transitions: EOF " ) );
-
-	list_character_set( file, out_char_set );
-
-	putc( '\n', file );
-	}
-
-
-/* epsclosure - construct the epsilon closure of a set of ndfa states
- *
- * synopsis
- *    int *epsclosure( int t[num_states], int *numstates_addr,
- *			int accset[num_rules+1], int *nacc_addr,
- *			int *hashval_addr );
- *
- * NOTES
- *  The epsilon closure is the set of all states reachable by an arbitrary
- *  number of epsilon transitions, which themselves do not have epsilon
- *  transitions going out, unioned with the set of states which have non-null
- *  accepting numbers.  t is an array of size numstates of nfa state numbers.
- *  Upon return, t holds the epsilon closure and *numstates_addr is updated.
- *  accset holds a list of the accepting numbers, and the size of accset is
- *  given by *nacc_addr.  t may be subjected to reallocation if it is not
- *  large enough to hold the epsilon closure.
- *
- *  hashval is the hash value for the dfa corresponding to the state set.
- */
-
-int *epsclosure( t, ns_addr, accset, nacc_addr, hv_addr )
-int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
-	{
-	int stkpos, ns, tsp;
-	int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
-	int stkend, nstate;
-	static int did_stk_init = false, *stk; 
-
-#define MARK_STATE(state) \
-trans1[state] = trans1[state] - MARKER_DIFFERENCE;
-
-#define IS_MARKED(state) (trans1[state] < 0)
-
-#define UNMARK_STATE(state) \
-trans1[state] = trans1[state] + MARKER_DIFFERENCE;
-
-#define CHECK_ACCEPT(state) \
-{ \
-nfaccnum = accptnum[state]; \
-if ( nfaccnum != NIL ) \
-accset[++nacc] = nfaccnum; \
-}
-
-#define DO_REALLOCATION \
-{ \
-current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \
-++num_reallocs; \
-t = reallocate_integer_array( t, current_max_dfa_size ); \
-stk = reallocate_integer_array( stk, current_max_dfa_size ); \
-} \
-
-#define PUT_ON_STACK(state) \
-{ \
-if ( ++stkend >= current_max_dfa_size ) \
-DO_REALLOCATION \
-stk[stkend] = state; \
-MARK_STATE(state) \
-}
-
-#define ADD_STATE(state) \
-{ \
-if ( ++numstates >= current_max_dfa_size ) \
-DO_REALLOCATION \
-t[numstates] = state; \
-hashval += state; \
-}
-
-#define STACK_STATE(state) \
-{ \
-PUT_ON_STACK(state) \
-CHECK_ACCEPT(state) \
-if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
-ADD_STATE(state) \
-}
-
-
-	if ( ! did_stk_init )
-		{
-		stk = allocate_integer_array( current_max_dfa_size );
-		did_stk_init = true;
-		}
-
-	nacc = stkend = hashval = 0;
-
-	for ( nstate = 1; nstate <= numstates; ++nstate )
-		{
-		ns = t[nstate];
-
-		/* The state could be marked if we've already pushed it onto
-		 * the stack.
-		 */
-		if ( ! IS_MARKED(ns) )
-			{
-			PUT_ON_STACK(ns)
-			CHECK_ACCEPT(ns)
-			hashval += ns;
-			}
-		}
-
-	for ( stkpos = 1; stkpos <= stkend; ++stkpos )
-		{
-		ns = stk[stkpos];
-		transsym = transchar[ns];
-
-		if ( transsym == SYM_EPSILON )
-			{
-			tsp = trans1[ns] + MARKER_DIFFERENCE;
-
-			if ( tsp != NO_TRANSITION )
-				{
-				if ( ! IS_MARKED(tsp) )
-					STACK_STATE(tsp)
-
-				tsp = trans2[ns];
-
-				if ( tsp != NO_TRANSITION && ! IS_MARKED(tsp) )
-					STACK_STATE(tsp)
-				}
-			}
-		}
-
-	/* Clear out "visit" markers. */
-
-	for ( stkpos = 1; stkpos <= stkend; ++stkpos )
-		{
-		if ( IS_MARKED(stk[stkpos]) )
-			UNMARK_STATE(stk[stkpos])
-		else
-			flexfatal(
-			_( "consistency check failed in epsclosure()" ) );
-		}
-
-	*ns_addr = numstates;
-	*hv_addr = hashval;
-	*nacc_addr = nacc;
-
-	return t;
-	}
-
-
-/* increase_max_dfas - increase the maximum number of DFAs */
-
-void increase_max_dfas()
-	{
-	current_max_dfas += MAX_DFAS_INCREMENT;
-
-	++num_reallocs;
-
-	base = reallocate_integer_array( base, current_max_dfas );
-	def = reallocate_integer_array( def, current_max_dfas );
-	dfasiz = reallocate_integer_array( dfasiz, current_max_dfas );
-	accsiz = reallocate_integer_array( accsiz, current_max_dfas );
-	dhash = reallocate_integer_array( dhash, current_max_dfas );
-	dss = reallocate_int_ptr_array( dss, current_max_dfas );
-	dfaacc = reallocate_dfaacc_union( dfaacc, current_max_dfas );
-
-	if ( nultrans )
-		nultrans =
-			reallocate_integer_array( nultrans, current_max_dfas );
-	}
-
-
-/* ntod - convert an ndfa to a dfa
- *
- * Creates the dfa corresponding to the ndfa we've constructed.  The
- * dfa starts out in state #1.
- */
-
-void ntod()
-	{
-	int *accset, ds, nacc, newds;
-	int sym, hashval, numstates, dsize;
-	int num_full_table_rows;	/* used only for -f */
-	int *nset, *dset;
-	int targptr, totaltrans, i, comstate, comfreq, targ;
-	int symlist[CSIZE + 1];
-	int num_start_states;
-	int todo_head, todo_next;
-
-	/* Note that the following are indexed by *equivalence classes*
-	 * and not by characters.  Since equivalence classes are indexed
-	 * beginning with 1, even if the scanner accepts NUL's, this
-	 * means that (since every character is potentially in its own
-	 * equivalence class) these arrays must have room for indices
-	 * from 1 to CSIZE, so their size must be CSIZE + 1.
-	 */
-	int duplist[CSIZE + 1], state[CSIZE + 1];
-	int targfreq[CSIZE + 1], targstate[CSIZE + 1];
-
-	accset = allocate_integer_array( num_rules + 1 );
-	nset = allocate_integer_array( current_max_dfa_size );
-
-	/* The "todo" queue is represented by the head, which is the DFA
-	 * state currently being processed, and the "next", which is the
-	 * next DFA state number available (not in use).  We depend on the
-	 * fact that snstods() returns DFA's \in increasing order/, and thus
-	 * need only know the bounds of the dfas to be processed.
-	 */
-	todo_head = todo_next = 0;
-
-	for ( i = 0; i <= csize; ++i )
-		{
-		duplist[i] = NIL;
-		symlist[i] = false;
-		}
-
-	for ( i = 0; i <= num_rules; ++i )
-		accset[i] = NIL;
-
-	if ( trace )
-		{
-		dumpnfa( scset[1] );
-		fputs( _( "\n\nDFA Dump:\n\n" ), stderr );
-		}
-
-	inittbl();
-
-	/* Check to see whether we should build a separate table for
-	 * transitions on NUL characters.  We don't do this for full-speed
-	 * (-F) scanners, since for them we don't have a simple state
-	 * number lying around with which to index the table.  We also
-	 * don't bother doing it for scanners unless (1) NUL is in its own
-	 * equivalence class (indicated by a positive value of
-	 * ecgroup[NUL]), (2) NUL's equivalence class is the last
-	 * equivalence class, and (3) the number of equivalence classes is
-	 * the same as the number of characters.  This latter case comes
-	 * about when useecs is false or when it's true but every character
-	 * still manages to land in its own class (unlikely, but it's
-	 * cheap to check for).  If all these things are true then the
-	 * character code needed to represent NUL's equivalence class for
-	 * indexing the tables is going to take one more bit than the
-	 * number of characters, and therefore we won't be assured of
-	 * being able to fit it into a YY_CHAR variable.  This rules out
-	 * storing the transitions in a compressed table, since the code
-	 * for interpreting them uses a YY_CHAR variable (perhaps it
-	 * should just use an integer, though; this is worth pondering ...
-	 * ###).
-	 *
-	 * Finally, for full tables, we want the number of entries in the
-	 * table to be a power of two so the array references go fast (it
-	 * will just take a shift to compute the major index).  If
-	 * encoding NUL's transitions in the table will spoil this, we
-	 * give it its own table (note that this will be the case if we're
-	 * not using equivalence classes).
-	 */
-
-	/* Note that the test for ecgroup[0] == numecs below accomplishes
-	 * both (1) and (2) above
-	 */
-	if ( ! fullspd && ecgroup[0] == numecs )
-		{
-		/* NUL is alone in its equivalence class, which is the
-		 * last one.
-		 */
-		int use_NUL_table = (numecs == csize);
-
-		if ( fulltbl && ! use_NUL_table )
-			{
-			/* We still may want to use the table if numecs
-			 * is a power of 2.
-			 */
-			int power_of_two;
-
-			for ( power_of_two = 1; power_of_two <= csize;
-			      power_of_two *= 2 )
-				if ( numecs == power_of_two )
-					{
-					use_NUL_table = true;
-					break;
-					}
-			}
-
-		if ( use_NUL_table )
-			nultrans = allocate_integer_array( current_max_dfas );
-
-		/* From now on, nultrans != nil indicates that we're
-		 * saving null transitions for later, separate encoding.
-		 */
-		}
-
-
-	if ( fullspd )
-		{
-		for ( i = 0; i <= numecs; ++i )
-			state[i] = 0;
-
-		place_state( state, 0, 0 );
-		dfaacc[0].dfaacc_state = 0;
-		}
-
-	else if ( fulltbl )
-		{
-		if ( nultrans )
-			/* We won't be including NUL's transitions in the
-			 * table, so build it for entries from 0 .. numecs - 1.
-			 */
-			num_full_table_rows = numecs;
-
-		else
-			/* Take into account the fact that we'll be including
-			 * the NUL entries in the transition table.  Build it
-			 * from 0 .. numecs.
-			 */
-			num_full_table_rows = numecs + 1;
-
-		/* Unless -Ca, declare it "short" because it's a real
-		 * long-shot that that won't be large enough.
-		 */
-		out_str_dec( "static yyconst %s yy_nxt[][%d] =\n    {\n",
-			/* '}' so vi doesn't get too confused */
-			long_align ? "long" : "short", num_full_table_rows );
-
-		outn( "    {" );
-
-		/* Generate 0 entries for state #0. */
-		for ( i = 0; i < num_full_table_rows; ++i )
-			mk2data( 0 );
-
-		dataflush();
-		outn( "    },\n" );
-		}
-
-	/* Create the first states. */
-
-	num_start_states = lastsc * 2;
-
-	for ( i = 1; i <= num_start_states; ++i )
-		{
-		numstates = 1;
-
-		/* For each start condition, make one state for the case when
-		 * we're at the beginning of the line (the '^' operator) and
-		 * one for the case when we're not.
-		 */
-		if ( i % 2 == 1 )
-			nset[numstates] = scset[(i / 2) + 1];
-		else
-			nset[numstates] =
-				mkbranch( scbol[i / 2], scset[i / 2] );
-
-		nset = epsclosure( nset, &numstates, accset, &nacc, &hashval );
-
-		if ( snstods( nset, numstates, accset, nacc, hashval, &ds ) )
-			{
-			numas += nacc;
-			totnst += numstates;
-			++todo_next;
-
-			if ( variable_trailing_context_rules && nacc > 0 )
-				check_trailing_context( nset, numstates,
-							accset, nacc );
-			}
-		}
-
-	if ( ! fullspd )
-		{
-		if ( ! snstods( nset, 0, accset, 0, 0, &end_of_buffer_state ) )
-			flexfatal(
-			_( "could not create unique end-of-buffer state" ) );
-
-		++numas;
-		++num_start_states;
-		++todo_next;
-		}
-
-	while ( todo_head < todo_next )
-		{
-		targptr = 0;
-		totaltrans = 0;
-
-		for ( i = 1; i <= numecs; ++i )
-			state[i] = 0;
-
-		ds = ++todo_head;
-
-		dset = dss[ds];
-		dsize = dfasiz[ds];
-
-		if ( trace )
-			fprintf( stderr, _( "state # %d:\n" ), ds );
-
-		sympartition( dset, dsize, symlist, duplist );
-
-		for ( sym = 1; sym <= numecs; ++sym )
-			{
-			if ( symlist[sym] )
-				{
-				symlist[sym] = 0;
-
-				if ( duplist[sym] == NIL )
-					{
-					/* Symbol has unique out-transitions. */
-					numstates = symfollowset( dset, dsize,
-								sym, nset );
-					nset = epsclosure( nset, &numstates,
-						accset, &nacc, &hashval );
-
-					if ( snstods( nset, numstates, accset,
-						nacc, hashval, &newds ) )
-						{
-						totnst = totnst + numstates;
-						++todo_next;
-						numas += nacc;
-
-						if (
-					variable_trailing_context_rules &&
-							nacc > 0 )
-							check_trailing_context(
-								nset, numstates,
-								accset, nacc );
-						}
-
-					state[sym] = newds;
-
-					if ( trace )
-						fprintf( stderr, "\t%d\t%d\n",
-							sym, newds );
-
-					targfreq[++targptr] = 1;
-					targstate[targptr] = newds;
-					++numuniq;
-					}
-
-				else
-					{
-					/* sym's equivalence class has the same
-					 * transitions as duplist(sym)'s
-					 * equivalence class.
-					 */
-					targ = state[duplist[sym]];
-					state[sym] = targ;
-
-					if ( trace )
-						fprintf( stderr, "\t%d\t%d\n",
-							sym, targ );
-
-					/* Update frequency count for
-					 * destination state.
-					 */
-
-					i = 0;
-					while ( targstate[++i] != targ )
-						;
-
-					++targfreq[i];
-					++numdup;
-					}
-
-				++totaltrans;
-				duplist[sym] = NIL;
-				}
-			}
-
-		if ( caseins && ! useecs )
-			{
-			int j;
-
-			for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
-				{
-				if ( state[i] == 0 && state[j] != 0 )
-					/* We're adding a transition. */
-					++totaltrans;
-
-				else if ( state[i] != 0 && state[j] == 0 )
-					/* We're taking away a transition. */
-					--totaltrans;
-
-				state[i] = state[j];
-				}
-			}
-
-		numsnpairs += totaltrans;
-
-		if ( ds > num_start_states )
-			check_for_backing_up( ds, state );
-
-		if ( nultrans )
-			{
-			nultrans[ds] = state[NUL_ec];
-			state[NUL_ec] = 0;	/* remove transition */
-			}
-
-		if ( fulltbl )
-			{
-			outn( "    {" );
-
-			/* Supply array's 0-element. */
-			if ( ds == end_of_buffer_state )
-				mk2data( -end_of_buffer_state );
-			else
-				mk2data( end_of_buffer_state );
-
-			for ( i = 1; i < num_full_table_rows; ++i )
-				/* Jams are marked by negative of state
-				 * number.
-				 */
-				mk2data( state[i] ? state[i] : -ds );
-
-			dataflush();
-			outn( "    },\n" );
-			}
-
-		else if ( fullspd )
-			place_state( state, ds, totaltrans );
-
-		else if ( ds == end_of_buffer_state )
-			/* Special case this state to make sure it does what
-			 * it's supposed to, i.e., jam on end-of-buffer.
-			 */
-			stack1( ds, 0, 0, JAMSTATE );
-
-		else /* normal, compressed state */
-			{
-			/* Determine which destination state is the most
-			 * common, and how many transitions to it there are.
-			 */
-
-			comfreq = 0;
-			comstate = 0;
-
-			for ( i = 1; i <= targptr; ++i )
-				if ( targfreq[i] > comfreq )
-					{
-					comfreq = targfreq[i];
-					comstate = targstate[i];
-					}
-
-			bldtbl( state, ds, totaltrans, comstate, comfreq );
-			}
-		}
-
-	if ( fulltbl )
-		dataend();
-
-	else if ( ! fullspd )
-		{
-		cmptmps();  /* create compressed template entries */
-
-		/* Create tables for all the states with only one
-		 * out-transition.
-		 */
-		while ( onesp > 0 )
-			{
-			mk1tbl( onestate[onesp], onesym[onesp], onenext[onesp],
-			onedef[onesp] );
-			--onesp;
-			}
-
-		mkdeftbl();
-		}
-
-	flex_free( (void *) accset );
-	flex_free( (void *) nset );
-	}
-
-
-/* snstods - converts a set of ndfa states into a dfa state
- *
- * synopsis
- *    is_new_state = snstods( int sns[numstates], int numstates,
- *				int accset[num_rules+1], int nacc,
- *				int hashval, int *newds_addr );
- *
- * On return, the dfa state number is in newds.
- */
-
-int snstods( sns, numstates, accset, nacc, hashval, newds_addr )
-int sns[], numstates, accset[], nacc, hashval, *newds_addr;
-	{
-	int didsort = 0;
-	int i, j;
-	int newds, *oldsns;
-
-	for ( i = 1; i <= lastdfa; ++i )
-		if ( hashval == dhash[i] )
-			{
-			if ( numstates == dfasiz[i] )
-				{
-				oldsns = dss[i];
-
-				if ( ! didsort )
-					{
-					/* We sort the states in sns so we
-					 * can compare it to oldsns quickly.
-					 * We use bubble because there probably
-					 * aren't very many states.
-					 */
-					bubble( sns, numstates );
-					didsort = 1;
-					}
-
-				for ( j = 1; j <= numstates; ++j )
-					if ( sns[j] != oldsns[j] )
-						break;
-
-				if ( j > numstates )
-					{
-					++dfaeql;
-					*newds_addr = i;
-					return 0;
-					}
-
-				++hshcol;
-				}
-
-			else
-				++hshsave;
-			}
-
-	/* Make a new dfa. */
-
-	if ( ++lastdfa >= current_max_dfas )
-		increase_max_dfas();
-
-	newds = lastdfa;
-
-	dss[newds] = allocate_integer_array( numstates + 1 );
-
-	/* If we haven't already sorted the states in sns, we do so now,
-	 * so that future comparisons with it can be made quickly.
-	 */
-
-	if ( ! didsort )
-		bubble( sns, numstates );
-
-	for ( i = 1; i <= numstates; ++i )
-		dss[newds][i] = sns[i];
-
-	dfasiz[newds] = numstates;
-	dhash[newds] = hashval;
-
-	if ( nacc == 0 )
-		{
-		if ( reject )
-			dfaacc[newds].dfaacc_set = (int *) 0;
-		else
-			dfaacc[newds].dfaacc_state = 0;
-
-		accsiz[newds] = 0;
-		}
-
-	else if ( reject )
-		{
-		/* We sort the accepting set in increasing order so the
-		 * disambiguating rule that the first rule listed is considered
-		 * match in the event of ties will work.  We use a bubble
-		 * sort since the list is probably quite small.
-		 */
-
-		bubble( accset, nacc );
-
-		dfaacc[newds].dfaacc_set = allocate_integer_array( nacc + 1 );
-
-		/* Save the accepting set for later */
-		for ( i = 1; i <= nacc; ++i )
-			{
-			dfaacc[newds].dfaacc_set[i] = accset[i];
-
-			if ( accset[i] <= num_rules )
-				/* Who knows, perhaps a REJECT can yield
-				 * this rule.
-				 */
-				rule_useful[accset[i]] = true;
-			}
-
-		accsiz[newds] = nacc;
-		}
-
-	else
-		{
-		/* Find lowest numbered rule so the disambiguating rule
-		 * will work.
-		 */
-		j = num_rules + 1;
-
-		for ( i = 1; i <= nacc; ++i )
-			if ( accset[i] < j )
-				j = accset[i];
-
-		dfaacc[newds].dfaacc_state = j;
-
-		if ( j <= num_rules )
-			rule_useful[j] = true;
-		}
-
-	*newds_addr = newds;
-
-	return 1;
-	}
-
-
-/* symfollowset - follow the symbol transitions one step
- *
- * synopsis
- *    numstates = symfollowset( int ds[current_max_dfa_size], int dsize,
- *				int transsym, int nset[current_max_dfa_size] );
- */
-
-int symfollowset( ds, dsize, transsym, nset )
-int ds[], dsize, transsym, nset[];
-	{
-	int ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
-
-	numstates = 0;
-
-	for ( i = 1; i <= dsize; ++i )
-		{ /* for each nfa state ns in the state set of ds */
-		ns = ds[i];
-		sym = transchar[ns];
-		tsp = trans1[ns];
-
-		if ( sym < 0 )
-			{ /* it's a character class */
-			sym = -sym;
-			ccllist = cclmap[sym];
-			lenccl = ccllen[sym];
-
-			if ( cclng[sym] )
-				{
-				for ( j = 0; j < lenccl; ++j )
-					{
-					/* Loop through negated character
-					 * class.
-					 */
-					ch = ccltbl[ccllist + j];
-
-					if ( ch == 0 )
-						ch = NUL_ec;
-
-					if ( ch > transsym )
-						/* Transsym isn't in negated
-						 * ccl.
-						 */
-						break;
-
-					else if ( ch == transsym )
-						/* next 2 */ goto bottom;
-					}
-
-				/* Didn't find transsym in ccl. */
-				nset[++numstates] = tsp;
-				}
-
-			else
-				for ( j = 0; j < lenccl; ++j )
-					{
-					ch = ccltbl[ccllist + j];
-
-					if ( ch == 0 )
-						ch = NUL_ec;
-
-					if ( ch > transsym )
-						break;
-					else if ( ch == transsym )
-						{
-						nset[++numstates] = tsp;
-						break;
-						}
-					}
-			}
-
-		else if ( sym >= 'A' && sym <= 'Z' && caseins )
-			flexfatal(
-			_( "consistency check failed in symfollowset" ) );
-
-		else if ( sym == SYM_EPSILON )
-			{ /* do nothing */
-			}
-
-		else if ( ABS( ecgroup[sym] ) == transsym )
-			nset[++numstates] = tsp;
-
-		bottom: ;
-		}
-
-	return numstates;
-	}
-
-
-/* sympartition - partition characters with same out-transitions
- *
- * synopsis
- *    sympartition( int ds[current_max_dfa_size], int numstates,
- *			int symlist[numecs], int duplist[numecs] );
- */
-
-void sympartition( ds, numstates, symlist, duplist )
-int ds[], numstates;
-int symlist[], duplist[];
-	{
-	int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
-
-	/* Partitioning is done by creating equivalence classes for those
-	 * characters which have out-transitions from the given state.  Thus
-	 * we are really creating equivalence classes of equivalence classes.
-	 */
-
-	for ( i = 1; i <= numecs; ++i )
-		{ /* initialize equivalence class list */
-		duplist[i] = i - 1;
-		dupfwd[i] = i + 1;
-		}
-
-	duplist[1] = NIL;
-	dupfwd[numecs] = NIL;
-
-	for ( i = 1; i <= numstates; ++i )
-		{
-		ns = ds[i];
-		tch = transchar[ns];
-
-		if ( tch != SYM_EPSILON )
-			{
-			if ( tch < -lastccl || tch >= csize )
-				{
-				flexfatal(
-		_( "bad transition character detected in sympartition()" ) );
-				}
-
-			if ( tch >= 0 )
-				{ /* character transition */
-				int ec = ecgroup[tch];
-
-				mkechar( ec, dupfwd, duplist );
-				symlist[ec] = 1;
-				}
-
-			else
-				{ /* character class */
-				tch = -tch;
-
-				lenccl = ccllen[tch];
-				cclp = cclmap[tch];
-				mkeccl( ccltbl + cclp, lenccl, dupfwd,
-					duplist, numecs, NUL_ec );
-
-				if ( cclng[tch] )
-					{
-					j = 0;
-
-					for ( k = 0; k < lenccl; ++k )
-						{
-						ich = ccltbl[cclp + k];
-
-						if ( ich == 0 )
-							ich = NUL_ec;
-
-						for ( ++j; j < ich; ++j )
-							symlist[j] = 1;
-						}
-
-					for ( ++j; j <= numecs; ++j )
-						symlist[j] = 1;
-					}
-
-				else
-					for ( k = 0; k < lenccl; ++k )
-						{
-						ich = ccltbl[cclp + k];
-
-						if ( ich == 0 )
-							ich = NUL_ec;
-
-						symlist[ich] = 1;
-						}
-				}
-			}
-		}
-	}
diff --git a/usr.bin/lex/ecs.c b/usr.bin/lex/ecs.c
deleted file mode 100644
index 4f7748d8f1d6..000000000000
--- a/usr.bin/lex/ecs.c
+++ /dev/null
@@ -1,227 +0,0 @@
-/* ecs - equivalence class routines */
-
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Vern Paxson.
- * 
- * The United States Government has rights in this work pursuant
- * to contract no. DE-AC03-76SF00098 between the United States
- * Department of Energy and the University of California.
- *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * 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.
- */
-
-/* $Header: /home/daffy/u0/vern/flex/RCS/ecs.c,v 2.9 93/12/07 10:18:20 vern Exp $ */
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include "flexdef.h"
-
-/* ccl2ecl - convert character classes to set of equivalence classes */
-
-void ccl2ecl()
-	{
-	int i, ich, newlen, cclp, ccls, cclmec;
-
-	for ( i = 1; i <= lastccl; ++i )
-		{
-		/* We loop through each character class, and for each character
-		 * in the class, add the character's equivalence class to the
-		 * new "character" class we are creating.  Thus when we are all
-		 * done, character classes will really consist of collections
-		 * of equivalence classes
-		 */
-
-		newlen = 0;
-		cclp = cclmap[i];
-
-		for ( ccls = 0; ccls < ccllen[i]; ++ccls )
-			{
-			ich = ccltbl[cclp + ccls];
-			cclmec = ecgroup[ich];
-
-			if ( cclmec > 0 )
-				{
-				ccltbl[cclp + newlen] = cclmec;
-				++newlen;
-				}
-			}
-
-		ccllen[i] = newlen;
-		}
-	}
-
-
-/* cre8ecs - associate equivalence class numbers with class members
- *
- * fwd is the forward linked-list of equivalence class members.  bck
- * is the backward linked-list, and num is the number of class members.
- *
- * Returned is the number of classes.
- */
-
-int cre8ecs( fwd, bck, num )
-int fwd[], bck[], num;
-	{
-	int i, j, numcl;
-
-	numcl = 0;
-
-	/* Create equivalence class numbers.  From now on, ABS( bck(x) )
-	 * is the equivalence class number for object x.  If bck(x)
-	 * is positive, then x is the representative of its equivalence
-	 * class.
-	 */
-	for ( i = 1; i <= num; ++i )
-		if ( bck[i] == NIL )
-			{
-			bck[i] = ++numcl;
-			for ( j = fwd[i]; j != NIL; j = fwd[j] )
-				bck[j] = -numcl;
-			}
-
-	return numcl;
-	}
-
-
-/* mkeccl - update equivalence classes based on character class xtions
- *
- * synopsis
- *    Char ccls[];
- *    int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
- *    void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
- *			int llsiz, int NUL_mapping );
- *
- * ccls contains the elements of the character class, lenccl is the
- * number of elements in the ccl, fwd is the forward link-list of equivalent
- * characters, bck is the backward link-list, and llsiz size of the link-list.
- *
- * NUL_mapping is the value which NUL (0) should be mapped to.
- */
-
-void mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping )
-Char ccls[];
-int lenccl, fwd[], bck[], llsiz, NUL_mapping;
-	{
-	int cclp, oldec, newec;
-	int cclm, i, j;
-	static unsigned char cclflags[CSIZE];	/* initialized to all '\0' */
-
-	/* Note that it doesn't matter whether or not the character class is
-	 * negated.  The same results will be obtained in either case.
-	 */
-
-	cclp = 0;
-
-	while ( cclp < lenccl )
-		{
-		cclm = ccls[cclp];
-
-		if ( NUL_mapping && cclm == 0 )
-			cclm = NUL_mapping;
-
-		oldec = bck[cclm];
-		newec = cclm;
-
-		j = cclp + 1;
-
-		for ( i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i] )
-			{ /* look for the symbol in the character class */
-			for ( ; j < lenccl; ++j )
-				{
-				int ccl_char;
-
-				if ( NUL_mapping && ccls[j] == 0 )
-					ccl_char = NUL_mapping;
-				else
-					ccl_char = ccls[j];
-
-				if ( ccl_char > i )
-					break;
-
-				if ( ccl_char == i && ! cclflags[j] )
-					{
-					/* We found an old companion of cclm
-					 * in the ccl.  Link it into the new
-					 * equivalence class and flag it as
-					 * having been processed.
-					 */
-
-					bck[i] = newec;
-					fwd[newec] = i;
-					newec = i;
-					/* Set flag so we don't reprocess. */
-					cclflags[j] = 1;
-
-					/* Get next equivalence class member. */
-					/* continue 2 */
-					goto next_pt;
-					}
-				}
-
-			/* Symbol isn't in character class.  Put it in the old
-			 * equivalence class.
-			 */
-
-			bck[i] = oldec;
-
-			if ( oldec != NIL )
-				fwd[oldec] = i;
-
-			oldec = i;
-
-			next_pt: ;
-			}
-
-		if ( bck[cclm] != NIL || oldec != bck[cclm] )
-			{
-			bck[cclm] = NIL;
-			fwd[oldec] = NIL;
-			}
-
-		fwd[newec] = NIL;
-
-		/* Find next ccl member to process. */
-
-		for ( ++cclp; cclflags[cclp] && cclp < lenccl; ++cclp )
-			{
-			/* Reset "doesn't need processing" flag. */
-			cclflags[cclp] = 0;
-			}
-		}
-	}
-
-
-/* mkechar - create equivalence class for single character */
-
-void mkechar( tch, fwd, bck )
-int tch, fwd[], bck[];
-	{
-	/* If until now the character has been a proper subset of
-	 * an equivalence class, break it away to create a new ec
-	 */
-
-	if ( fwd[tch] != NIL )
-		bck[fwd[tch]] = bck[tch];
-
-	if ( bck[tch] != NIL )
-		fwd[bck[tch]] = fwd[tch];
-
-	fwd[tch] = NIL;
-	bck[tch] = NIL;
-	}
diff --git a/usr.bin/lex/flex.skl b/usr.bin/lex/flex.skl
deleted file mode 100644
index ef5ee14354cf..000000000000
--- a/usr.bin/lex/flex.skl
+++ /dev/null
@@ -1,1574 +0,0 @@
-/* A lexical scanner generated by flex */
-
-/* Scanner skeleton version:
- * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
- * $FreeBSD$
- */
-
-#if defined(__FreeBSD__)
-#include <sys/cdefs.h>
-#else
-#define __unused
-#define __dead2
-#endif
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-
-%-
-#include <stdio.h>
-%*
-
-
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
-#endif
-#endif
-
-
-#ifdef __cplusplus
-
-#include <stdlib.h>
-%+
-#include <iosfwd>
-using namespace std;
-%*
-#include <unistd.h>
-
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-#if __STDC__
-
-#define YY_USE_PROTOS
-#define YY_USE_CONST
-
-#endif	/* __STDC__ */
-#endif	/* ! __cplusplus */
-
-#ifdef __TURBOC__
- #pragma warn -rch
- #pragma warn -use
-#include <io.h>
-#include <stdlib.h>
-#define YY_USE_CONST
-#define YY_USE_PROTOS
-#endif
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#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 yyrestart( yyin )
-
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#define YY_BUF_SIZE 16384
-
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-
-extern int yyleng;
-%-
-extern FILE *yyin, *yyout;
-%*
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
-/* The funky do-while in the following #define is used to turn the definition
- * into a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- * 	if ( condition_holds )
- *		yyless( 5 );
- *	else
- *		do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-		*yy_cp = yy_hold_char; \
-		YY_RESTORE_YY_MORE_OFFSET \
-		yy_c_buf_p = yy_cp = yy_bp + (n) - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-
-#define unput(c) yyunput( (c), yytext_ptr )
-
-/* The following is because we cannot portably get our hands on size_t
- * (without autoconf's help, which isn't available because we want
- * flex-generated scanners to compile on their own).
- */
-typedef unsigned int yy_size_t;
-
-
-struct yy_buffer_state
-	{
-%-
-	FILE *yy_input_file;
-%+
-	istream* 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;
-
-	/* 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 yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-	};
-
-%- Standard (non-C++) definition
-static YY_BUFFER_STATE yy_current_buffer = 0;
-%*
-
-/* 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".
- */
-#define YY_CURRENT_BUFFER yy_current_buffer
-
-
-%- Standard (non-C++) definition
-/* yy_hold_char holds the character lost when yytext is formed. */
-static char yy_hold_char;
-
-static int yy_n_chars;		/* number of characters read into yy_ch_buf */
-
-
-int yyleng;
-
-/* Points to current character in buffer. */
-static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;		/* whether we need to initialize */
-static int yy_start = 0;	/* start state number */
-
-/* Flag which is used to allow yywrap()'s to do buffer switches
- * instead of setting up a fresh yyin.  A bit of a hack ...
- */
-static int yy_did_buffer_switch_on_eof;
-
-void yyrestart YY_PROTO(( FILE *input_file ));
-
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
-
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
-%*
-
-static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) __unused;
-static void yy_flex_free YY_PROTO(( void * ));
-
-#define yy_new_buffer yy_create_buffer
-
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-	yy_current_buffer->yy_is_interactive = is_interactive; \
-	}
-
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-	yy_current_buffer->yy_at_bol = at_bol; \
-	}
-
-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
-
-%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
-
-%- Standard (non-C++) definition
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( yyconst char msg[] )) __dead2;
-%*
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	yytext_ptr = yy_bp; \
-%% code to fiddle yytext and yyleng for yymore() goes here
-	yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-%% code to copy yytext_ptr to yytext[] goes here, if %array
-	yy_c_buf_p = yy_cp;
-
-%% data tables for the DFA and the user's section 1 definitions go here
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap YY_PROTO(( void ));
-#else
-extern int yywrap YY_PROTO(( void ));
-#endif
-#endif
-
-%-
-#ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
-#endif
-%*
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen YY_PROTO(( yyconst char * ));
-#endif
-
-#ifndef YY_NO_INPUT
-%- Standard (non-C++) definition
-#ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
-#else
-static int input YY_PROTO(( void ));
-#endif
-%*
-#endif
-
-#if YY_STACK_USED
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-#ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
-#endif
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
-#endif
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( void ));
-#endif
-
-#else
-#define YY_NO_PUSH_STATE 1
-#define YY_NO_POP_STATE 1
-#define YY_NO_TOP_STATE 1
-#endif
-
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#define YY_READ_BUF_SIZE 8192
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-
-#ifndef ECHO
-%- Standard (non-C++) definition
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
-%+ C++ definition
-#define ECHO LexerOutput( yytext, yyleng )
-%*
-#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) \
-%% fread()/read() definition of YY_INPUT goes here unless we're doing C++
-%+ C++ definition
-	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
-%*
-#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 )
-%+
-#define YY_FATAL_ERROR(msg) LexerError( msg )
-%*
-#endif
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-%- Standard (non-C++) definition
-#define YY_DECL int yylex YY_PROTO(( void ))
-%+ C++ definition
-#define YY_DECL int yyFlexLexer::yylex()
-%*
-#endif
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * 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
-
-%% YY_RULE_SETUP definition goes here
-
-YY_DECL
-	{
-	yy_state_type yy_current_state;
-	char *yy_cp, *yy_bp;
-	int yy_act;
-
-%% user's declarations go here
-
-	if ( yy_init )
-		{
-		yy_init = 0;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! yy_start )
-			yy_start = 1;	/* first start state */
-
-		if ( ! yyin )
-%-
-			yyin = stdin;
-%+
-			yyin = &cin;
-%*
-
-		if ( ! yyout )
-%-
-			yyout = stdout;
-%+
-			yyout = &cout;
-%*
-
-		if ( ! yy_current_buffer )
-			yy_current_buffer =
-				yy_create_buffer( yyin, YY_BUF_SIZE );
-
-		yy_load_buffer_state();
-		}
-
-	while ( 1 )		/* loops until end-of-file is reached */
-		{
-%% yymore()-related code goes here
-		yy_cp = yy_c_buf_p;
-
-		/* Support of yytext. */
-		*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;
-
-%% code to set up and find next match goes here
-
-yy_find_action:
-%% code to find the action number goes here
-
-		YY_DO_BEFORE_ACTION;
-
-%% code for yylineno update goes here
-
-do_action:	/* This label is used only to access EOF actions. */
-
-%% debug code goes here
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-%% actions go here
-
-	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->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 yyin at a new source and called
-			 * yylex().  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->yy_n_chars;
-			yy_current_buffer->yy_input_file = yyin;
-			yy_current_buffer->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->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
-				{
-%% code to do back-up for compressed tables and set up yy_cp goes here
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer() )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				yy_did_buffer_switch_on_eof = 0;
-
-				if ( yywrap() )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, 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->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 yylex */
-
-%+
-yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
-	{
-	yyin = arg_yyin;
-	yyout = arg_yyout;
-	yy_c_buf_p = 0;
-	yy_init = 1;
-	yy_start = 0;
-	yy_flex_debug = 0;
-	yylineno = 1;	// this will only get updated if %option yylineno
-
-	yy_did_buffer_switch_on_eof = 0;
-
-	yy_looking_for_trail_begin = 0;
-	yy_more_flag = 0;
-	yy_more_len = 0;
-	yy_more_offset = yy_prev_more_offset = 0;
-
-	yy_start_stack_ptr = yy_start_stack_depth = 0;
-	yy_start_stack = 0;
-
-	yy_current_buffer = 0;
-
-#ifdef YY_USES_REJECT
-	yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
-#else
-	yy_state_buf = 0;
-#endif
-	}
-
-yyFlexLexer::~yyFlexLexer()
-	{
-	delete yy_state_buf;
-	yy_delete_buffer( yy_current_buffer );
-	}
-
-void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )
-	{
-	if ( new_in )
-		{
-		yy_delete_buffer( yy_current_buffer );
-		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
-		}
-
-	if ( new_out )
-		yyout = new_out;
-	}
-
-#ifdef YY_INTERACTIVE
-int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
-#else
-int yyFlexLexer::LexerInput( char* buf, int max_size )
-#endif
-	{
-	if ( yyin->eof() || yyin->fail() )
-		return 0;
-
-#ifdef YY_INTERACTIVE
-	yyin->get( buf[0] );
-
-	if ( yyin->eof() )
-		return 0;
-
-	if ( yyin->bad() )
-		return -1;
-
-	return 1;
-
-#else
-	(void) yyin->read( buf, max_size );
-
-	if ( yyin->bad() )
-		return -1;
-	else
-		return yyin->gcount();
-#endif
-	}
-
-void yyFlexLexer::LexerOutput( const char* buf, int size )
-	{
-	(void) yyout->write( buf, size );
-	}
-%*
-
-/* 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
- */
-
-%-
-#ifdef YY_USE_PROTOS
-static int yy_get_next_buffer(void)
-#else
-static int yy_get_next_buffer()
-#endif
-%+
-int yyFlexLexer::yy_get_next_buffer()
-%*
-	{
-	char *dest = yy_current_buffer->yy_ch_buf;
-	char *source = yytext_ptr;
-	int number_to_move, i;
-	int ret_val;
-
-	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( yy_current_buffer->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->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->yy_n_chars = yy_n_chars = 0;
-
-	else
-		{
-		int num_to_read =
-			yy_current_buffer->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-			YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
-
-			/* 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. */
-					yy_flex_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->yy_buf_size -
-						number_to_move - 1;
-#endif
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-			yy_n_chars, num_to_read );
-
-		yy_current_buffer->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;
-			yyrestart( yyin );
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			yy_current_buffer->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	yy_n_chars += number_to_move;
-	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
-	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
-
-	return ret_val;
-	}
-
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-%-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_get_previous_state(void)
-#else
-static yy_state_type yy_get_previous_state()
-#endif
-%+
-yy_state_type yyFlexLexer::yy_get_previous_state()
-%*
-	{
-	yy_state_type yy_current_state;
-	char *yy_cp;
-
-%% code to get the start state into yy_current_state goes here
-
-	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
-		{
-%% code to find the next state goes here
-		}
-
-	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 );
- */
-
-%-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
-#else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
-#endif
-%+
-yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
-%*
-	{
-	int yy_is_jam;
-%% code to find the next state, and perhaps do backing up, goes here
-
-	return yy_is_jam ? 0 : yy_current_state;
-	}
-
-
-%-
-#ifndef YY_NO_UNPUT
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, char *yy_bp )
-#else
-static void yyunput( c, yy_bp )
-int c;
-char *yy_bp;
-#endif
-%+
-void yyFlexLexer::yyunput( int c, char* yy_bp )
-%*
-	{
-	char *yy_cp = yy_c_buf_p;
-
-	/* undo effects of setting up yytext */
-	*yy_cp = yy_hold_char;
-
-	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
-		{ /* need to shift things up to make room */
-		/* +2 for EOB chars. */
-		int number_to_move = yy_n_chars + 2;
-		char *dest = &yy_current_buffer->yy_ch_buf[
-					yy_current_buffer->yy_buf_size + 2];
-		char *source =
-				&yy_current_buffer->yy_ch_buf[number_to_move];
-
-		while ( source > yy_current_buffer->yy_ch_buf )
-			*--dest = *--source;
-
-		yy_cp += (int) (dest - source);
-		yy_bp += (int) (dest - source);
-		yy_current_buffer->yy_n_chars =
-			yy_n_chars = yy_current_buffer->yy_buf_size;
-
-		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
-			YY_FATAL_ERROR( "flex scanner push-back overflow" );
-		}
-
-	*--yy_cp = (char) c;
-
-%% update yylineno here
-
-	yytext_ptr = yy_bp;
-	yy_hold_char = *yy_cp;
-	yy_c_buf_p = yy_cp;
-	}
-%-
-#endif	/* ifndef YY_NO_UNPUT */
-%*
-
-
-%-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput()
-#else
-#ifdef YY_USE_PROTOS
-static int input(void)
-#else
-static int input()
-#endif
-#endif
-%+
-int yyFlexLexer::yyinput()
-%*
-	{
-	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->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. */
-					yyrestart( yyin );
-
-					/* fall through */
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( yywrap() )
-						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 yytext */
-	yy_hold_char = *++yy_c_buf_p;
-
-%% update BOL and yylineno
-
-	return c;
-	}
-%-
-#endif	/* ifndef YY_NO_INPUT */
-%*
-
-
-%-
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
-#else
-void yyrestart( input_file )
-FILE *input_file;
-#endif
-%+
-void yyFlexLexer::yyrestart( istream* input_file )
-%*
-	{
-	if ( ! yy_current_buffer )
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
-
-	yy_init_buffer( yy_current_buffer, input_file );
-	yy_load_buffer_state();
-	}
-
-
-%-
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-%+
-void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-%*
-	{
-	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->yy_buf_pos = yy_c_buf_p;
-		yy_current_buffer->yy_n_chars = yy_n_chars;
-		}
-
-	yy_current_buffer = new_buffer;
-	yy_load_buffer_state();
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (yywrap()) processing, but the only time this flag
-	 * is looked at is after yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	yy_did_buffer_switch_on_eof = 1;
-	}
-
-
-%-
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
-#else
-void yy_load_buffer_state()
-#endif
-%+
-void yyFlexLexer::yy_load_buffer_state()
-%*
-	{
-	yy_n_chars = yy_current_buffer->yy_n_chars;
-	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-	yyin = yy_current_buffer->yy_input_file;
-	yy_hold_char = *yy_c_buf_p;
-	}
-
-
-%-
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-%+
-YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
-%*
-	{
-	YY_BUFFER_STATE b;
-
-	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_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 *) yy_flex_alloc( b->yy_buf_size + 2 );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	yy_init_buffer( b, file );
-
-	return b;
-	}
-
-
-%-
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-%+
-void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
-%*
-	{
-	if ( ! b )
-		return;
-
-	if ( b == yy_current_buffer )
-		yy_current_buffer = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		yy_flex_free( (void *) b->yy_ch_buf );
-
-	yy_flex_free( (void *) b );
-	}
-
-
-%-
-#ifndef YY_ALWAYS_INTERACTIVE
-#ifndef YY_NEVER_INTERACTIVE
-extern int isatty YY_PROTO(( int ));
-#endif
-#endif
-
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
-#else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
-#endif
-
-%+
-extern "C" int isatty YY_PROTO(( int ));
-void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
-%*
-
-	{
-	yy_flush_buffer( b );
-
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-%-
-#if YY_ALWAYS_INTERACTIVE
-	b->yy_is_interactive = 1;
-#else
-#if YY_NEVER_INTERACTIVE
-	b->yy_is_interactive = 0;
-#else
-	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-#endif
-#endif
-%+
-	b->yy_is_interactive = 0;
-%*
-	}
-
-
-%-
-#ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
-#else
-void yy_flush_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-
-%+
-void yyFlexLexer::yy_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 )
-		yy_load_buffer_state();
-	}
-%*
-
-
-#ifndef YY_NO_SCAN_BUFFER
-%-
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-#else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
-char *base;
-yy_size_t size;
-#endif
-	{
-	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) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_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;
-
-	yy_switch_to_buffer( b );
-
-	return b;
-	}
-%*
-#endif
-
-
-#ifndef YY_NO_SCAN_STRING
-%-
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
-#else
-YY_BUFFER_STATE yy_scan_string( yy_str )
-yyconst char *yy_str;
-#endif
-	{
-	int len;
-	for ( len = 0; yy_str[len]; ++len )
-		;
-
-	return yy_scan_bytes( yy_str, len );
-	}
-%*
-#endif
-
-
-#ifndef YY_NO_SCAN_BYTES
-%-
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
-#else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
-yyconst char *bytes;
-int len;
-#endif
-	{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	int i;
-
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = len + 2;
-	buf = (char *) yy_flex_alloc( n );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
-	for ( i = 0; i < len; ++i )
-		buf[i] = bytes[i];
-
-	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = yy_scan_buffer( buf, n );
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in yy_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;
-	}
-%*
-#endif
-
-
-#ifndef YY_NO_PUSH_STATE
-%-
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
-#else
-static void yy_push_state( new_state )
-int new_state;
-#endif
-%+
-void yyFlexLexer::yy_push_state( int new_state )
-%*
-	{
-	if ( yy_start_stack_ptr >= yy_start_stack_depth )
-		{
-		yy_size_t new_size;
-
-		yy_start_stack_depth += YY_START_STACK_INCR;
-		new_size = yy_start_stack_depth * sizeof( int );
-
-		if ( ! yy_start_stack )
-			yy_start_stack = (int *) yy_flex_alloc( new_size );
-
-		else
-			yy_start_stack = (int *) yy_flex_realloc(
-					(void *) yy_start_stack, new_size );
-
-		if ( ! yy_start_stack )
-			YY_FATAL_ERROR(
-			"out of memory expanding start-condition stack" );
-		}
-
-	yy_start_stack[yy_start_stack_ptr++] = YY_START;
-
-	BEGIN(new_state);
-	}
-#endif
-
-
-#ifndef YY_NO_POP_STATE
-%-
-#ifdef YY_USE_PROTOS
-static void yy_pop_state(void)
-#else
-static void yy_pop_state()
-#endif
-%+
-void yyFlexLexer::yy_pop_state()
-%*
-	{
-	if ( --yy_start_stack_ptr < 0 )
-		YY_FATAL_ERROR( "start-condition stack underflow" );
-
-	BEGIN(yy_start_stack[yy_start_stack_ptr]);
-	}
-#endif
-
-
-#ifndef YY_NO_TOP_STATE
-%-
-#ifdef YY_USE_PROTOS
-static int yy_top_state(void)
-#else
-static int yy_top_state()
-#endif
-%+
-int yyFlexLexer::yy_top_state()
-%*
-	{
-	return yy_start_stack[yy_start_stack_ptr - 1];
-	}
-#endif
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-%-
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( yyconst char msg[] )
-#else
-static void yy_fatal_error( msg )
-char msg[];
-#endif
-	{
-	(void) fprintf( stderr, "%s\n", msg );
-	exit( YY_EXIT_FAILURE );
-	}
-
-%+
-
-void yyFlexLexer::LexerError( yyconst char msg[] )
-	{
-	cerr << msg << '\n';
-	exit( YY_EXIT_FAILURE );
-	}
-%*
-
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-		yytext[yyleng] = yy_hold_char; \
-		yy_c_buf_p = yytext + n; \
-		yy_hold_char = *yy_c_buf_p; \
-		*yy_c_buf_p = '\0'; \
-		yyleng = n; \
-		} \
-	while ( 0 )
-
-
-/* Internal utility routines. */
-
-#ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
-#else
-static void yy_flex_strncpy( s1, s2, n )
-char *s1;
-yyconst char *s2;
-int n;
-#endif
-	{
-	int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-	}
-#endif
-
-#ifdef YY_NEED_STRLEN
-#ifdef YY_USE_PROTOS
-static int yy_flex_strlen( yyconst char *s )
-#else
-static int yy_flex_strlen( s )
-yyconst char *s;
-#endif
-	{
-	int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-	}
-#endif
-
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( yy_size_t size )
-#else
-static void *yy_flex_alloc( size )
-yy_size_t size;
-#endif
-	{
-	return (void *) malloc( size );
-	}
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_realloc( void *ptr, yy_size_t size )
-#else
-static void *yy_flex_realloc( ptr, size )
-void *ptr;
-yy_size_t size;
-#endif
-	{
-	/* 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 );
-	}
-
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
-#else
-static void yy_flex_free( ptr )
-void *ptr;
-#endif
-	{
-	free( ptr );
-	}
-
-#if YY_MAIN
-int main()
-	{
-	yylex();
-	return 0;
-	}
-#endif
diff --git a/usr.bin/lex/flexdef.h b/usr.bin/lex/flexdef.h
deleted file mode 100644
index 1c51ec90f058..000000000000
--- a/usr.bin/lex/flexdef.h
+++ /dev/null
@@ -1,1049 +0,0 @@
-/* flexdef - definitions file for flex */
-
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Vern Paxson.
- * 
- * The United States Government has rights in this work pursuant
- * to contract no. DE-AC03-76SF00098 between the United States
- * Department of Energy and the University of California.
- *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * 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.
- */
-
-/* @(#) $Header: /home/daffy/u0/vern/flex/RCS/flexdef.h,v 2.53 95/04/20 11:17:36 vern Exp $ (LBL) */
-/* $FreeBSD$ */
-
-#include <stdio.h>
-#include <ctype.h>
-
-#include "config.h"
-
-#ifdef __TURBOC__
-#define HAVE_STRING_H 1
-#define MS_DOS 1
-#ifndef __STDC__
-#define __STDC__ 1
-#endif
- #pragma warn -pro
- #pragma warn -rch
- #pragma warn -use
- #pragma warn -aus
- #pragma warn -par
- #pragma warn -pia
-#endif
-
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-#include <strings.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
-
-#ifdef STDC_HEADERS
-#include <stdlib.h>
-#endif
-
-/* As an aid for the internationalization patch to flex, which
- * is maintained outside this distribution for copyright reasons.
- */
-#define _(String) (String)
-
-/* Always be prepared to generate an 8-bit scanner. */
-#define CSIZE 256
-#define Char unsigned char
-
-/* Size of input alphabet - should be size of ASCII set. */
-#ifndef DEFAULT_CSIZE
-#define DEFAULT_CSIZE 128
-#endif
-
-#ifndef PROTO
-#if __STDC__
-#define PROTO(proto) proto
-#else
-#define PROTO(proto) ()
-#endif
-#endif
-
-#ifdef VMS
-#ifndef __VMS_POSIX
-#define unlink remove
-#define SHORT_FILE_NAMES
-#endif
-#endif
-
-#ifdef MS_DOS
-#define SHORT_FILE_NAMES
-#endif
-
-
-/* Maximum line length we'll have to deal with. */
-#define MAXLINE 2048
-
-#ifndef MIN
-#define MIN(x,y) ((x) < (y) ? (x) : (y))
-#endif
-#ifndef MAX
-#define MAX(x,y) ((x) > (y) ? (x) : (y))
-#endif
-#ifndef ABS
-#define ABS(x) ((x) < 0 ? -(x) : (x))
-#endif
-
-
-/* ANSI C does not guarantee that isascii() is defined */
-#ifndef isascii
-#define isascii(c) ((c) <= 0177)
-#endif
-
-
-#define true 1
-#define false 0
-#define unspecified -1
-
-
-/* Special chk[] values marking the slots taking by end-of-buffer and action
- * numbers.
- */
-#define EOB_POSITION -1
-#define ACTION_POSITION -2
-
-/* Number of data items per line for -f output. */
-#define NUMDATAITEMS 10
-
-/* Number of lines of data in -f output before inserting a blank line for
- * readability.
- */
-#define NUMDATALINES 10
-
-/* transition_struct_out() definitions. */
-#define TRANS_STRUCT_PRINT_LENGTH 14
-
-/* Returns true if an nfa state has an epsilon out-transition slot
- * that can be used.  This definition is currently not used.
- */
-#define FREE_EPSILON(state) \
-	(transchar[state] == SYM_EPSILON && \
-	 trans2[state] == NO_TRANSITION && \
-	 finalst[state] != state)
-
-/* Returns true if an nfa state has an epsilon out-transition character
- * and both slots are free
- */
-#define SUPER_FREE_EPSILON(state) \
-	(transchar[state] == SYM_EPSILON && \
-	 trans1[state] == NO_TRANSITION) \
-
-/* Maximum number of NFA states that can comprise a DFA state.  It's real
- * big because if there's a lot of rules, the initial state will have a
- * huge epsilon closure.
- */
-#define INITIAL_MAX_DFA_SIZE 750
-#define MAX_DFA_SIZE_INCREMENT 750
-
-
-/* A note on the following masks.  They are used to mark accepting numbers
- * as being special.  As such, they implicitly limit the number of accepting
- * numbers (i.e., rules) because if there are too many rules the rule numbers
- * will overload the mask bits.  Fortunately, this limit is \large/ (0x2000 ==
- * 8192) so unlikely to actually cause any problems.  A check is made in
- * new_rule() to ensure that this limit is not reached.
- */
-
-/* Mask to mark a trailing context accepting number. */
-#define YY_TRAILING_MASK 0x2000
-
-/* Mask to mark the accepting number of the "head" of a trailing context
- * rule.
- */
-#define YY_TRAILING_HEAD_MASK 0x4000
-
-/* Maximum number of rules, as outlined in the above note. */
-#define MAX_RULE (YY_TRAILING_MASK - 1)
-
-
-/* NIL must be 0.  If not, its special meaning when making equivalence classes
- * (it marks the representative of a given e.c.) will be unidentifiable.
- */
-#define NIL 0
-
-#define JAM -1	/* to mark a missing DFA transition */
-#define NO_TRANSITION NIL
-#define UNIQUE -1	/* marks a symbol as an e.c. representative */
-#define INFINITY -1	/* for x{5,} constructions */
-
-#define INITIAL_MAX_CCLS 100	/* max number of unique character classes */
-#define MAX_CCLS_INCREMENT 100
-
-/* Size of table holding members of character classes. */
-#define INITIAL_MAX_CCL_TBL_SIZE 500
-#define MAX_CCL_TBL_SIZE_INCREMENT 250
-
-#define INITIAL_MAX_RULES 100	/* default maximum number of rules */
-#define MAX_RULES_INCREMENT 100
-
-#define INITIAL_MNS 2000	/* default maximum number of nfa states */
-#define MNS_INCREMENT 1000	/* amount to bump above by if it's not enough */
-
-#define INITIAL_MAX_DFAS 1000	/* default maximum number of dfa states */
-#define MAX_DFAS_INCREMENT 1000
-
-#define JAMSTATE -32766	/* marks a reference to the state that always jams */
-
-/* Maximum number of NFA states. */
-#define MAXIMUM_MNS 31999
-
-/* Enough so that if it's subtracted from an NFA state number, the result
- * is guaranteed to be negative.
- */
-#define MARKER_DIFFERENCE (MAXIMUM_MNS+2)
-
-/* Maximum number of nxt/chk pairs for non-templates. */
-#define INITIAL_MAX_XPAIRS 2000
-#define MAX_XPAIRS_INCREMENT 2000
-
-/* Maximum number of nxt/chk pairs needed for templates. */
-#define INITIAL_MAX_TEMPLATE_XPAIRS 2500
-#define MAX_TEMPLATE_XPAIRS_INCREMENT 2500
-
-#define SYM_EPSILON (CSIZE + 1)	/* to mark transitions on the symbol epsilon */
-
-#define INITIAL_MAX_SCS 40	/* maximum number of start conditions */
-#define MAX_SCS_INCREMENT 40	/* amount to bump by if it's not enough */
-
-#define ONE_STACK_SIZE 500	/* stack of states with only one out-transition */
-#define SAME_TRANS -1	/* transition is the same as "default" entry for state */
-
-/* The following percentages are used to tune table compression:
-
- * The percentage the number of out-transitions a state must be of the
- * number of equivalence classes in order to be considered for table
- * compaction by using protos.
- */
-#define PROTO_SIZE_PERCENTAGE 15
-
-/* The percentage the number of homogeneous out-transitions of a state
- * must be of the number of total out-transitions of the state in order
- * that the state's transition table is first compared with a potential 
- * template of the most common out-transition instead of with the first
- * proto in the proto queue.
- */
-#define CHECK_COM_PERCENTAGE 50
-
-/* The percentage the number of differences between a state's transition
- * table and the proto it was first compared with must be of the total
- * number of out-transitions of the state in order to keep the first
- * proto as a good match and not search any further.
- */
-#define FIRST_MATCH_DIFF_PERCENTAGE 10
-
-/* The percentage the number of differences between a state's transition
- * table and the most similar proto must be of the state's total number
- * of out-transitions to use the proto as an acceptable close match.
- */
-#define ACCEPTABLE_DIFF_PERCENTAGE 50
-
-/* The percentage the number of homogeneous out-transitions of a state
- * must be of the number of total out-transitions of the state in order
- * to consider making a template from the state.
- */
-#define TEMPLATE_SAME_PERCENTAGE 60
-
-/* The percentage the number of differences between a state's transition
- * table and the most similar proto must be of the state's total number
- * of out-transitions to create a new proto from the state.
- */
-#define NEW_PROTO_DIFF_PERCENTAGE 20
-
-/* The percentage the total number of out-transitions of a state must be
- * of the number of equivalence classes in order to consider trying to
- * fit the transition table into "holes" inside the nxt/chk table.
- */
-#define INTERIOR_FIT_PERCENTAGE 15
-
-/* Size of region set aside to cache the complete transition table of
- * protos on the proto queue to enable quick comparisons.
- */
-#define PROT_SAVE_SIZE 2000
-
-#define MSP 50	/* maximum number of saved protos (protos on the proto queue) */
-
-/* Maximum number of out-transitions a state can have that we'll rummage
- * around through the interior of the internal fast table looking for a
- * spot for it.
- */
-#define MAX_XTIONS_FULL_INTERIOR_FIT 4
-
-/* Maximum number of rules which will be reported as being associated
- * with a DFA state.
- */
-#define MAX_ASSOC_RULES 100
-
-/* Number that, if used to subscript an array, has a good chance of producing
- * an error; should be small enough to fit into a short.
- */
-#define BAD_SUBSCRIPT -32767
-
-/* Absolute value of largest number that can be stored in a short, with a
- * bit of slop thrown in for general paranoia.
- */
-#define MAX_SHORT 32700
-
-
-/* Declarations for global variables. */
-
-/* Variables for symbol tables:
- * sctbl - start-condition symbol table
- * ndtbl - name-definition symbol table
- * ccltab - character class text symbol table
- */
-
-struct hash_entry
-	{
-	struct hash_entry *prev, *next;
-	char *name;
-	char *str_val;
-	int int_val;
-	} ;
-
-typedef struct hash_entry **hash_table;
-
-#define NAME_TABLE_HASH_SIZE 101
-#define START_COND_HASH_SIZE 101
-#define CCL_HASH_SIZE 101
-
-extern struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE]; 
-extern struct hash_entry *sctbl[START_COND_HASH_SIZE];
-extern struct hash_entry *ccltab[CCL_HASH_SIZE];
-
-
-/* Variables for flags:
- * printstats - if true (-v), dump statistics
- * syntaxerror - true if a syntax error has been found
- * eofseen - true if we've seen an eof in the input file
- * ddebug - if true (-d), make a "debug" scanner
- * trace - if true (-T), trace processing
- * nowarn - if true (-w), do not generate warnings
- * spprdflt - if true (-s), suppress the default rule
- * interactive - if true (-I), generate an interactive scanner
- * caseins - if true (-i), generate a case-insensitive scanner
- * lex_compat - if true (-l), maximize compatibility with AT&T lex
- * do_yylineno - if true, generate code to maintain yylineno
- * useecs - if true (-Ce flag), use equivalence classes
- * fulltbl - if true (-Cf flag), don't compress the DFA state table
- * usemecs - if true (-Cm flag), use meta-equivalence classes
- * fullspd - if true (-F flag), use Jacobson method of table representation
- * gen_line_dirs - if true (i.e., no -L flag), generate #line directives
- * performance_report - if > 0 (i.e., -p flag), generate a report relating
- *   to scanner performance; if > 1 (-p -p), report on minor performance
- *   problems, too
- * backing_up_report - if true (i.e., -b flag), generate "lex.backup" file
- *   listing backing-up states
- * C_plus_plus - if true (i.e., -+ flag), generate a C++ scanner class;
- *   otherwise, a standard C scanner
- * long_align - if true (-Ca flag), favor long-word alignment.
- * use_read - if true (-f, -F, or -Cr) then use read() for scanner input;
- *   otherwise, use fread().
- * yytext_is_array - if true (i.e., %array directive), then declare
- *   yytext as an array instead of a character pointer.  Nice and inefficient.
- * do_yywrap - do yywrap() processing on EOF.  If false, EOF treated as
- *   "no more files".
- * csize - size of character set for the scanner we're generating;
- *   128 for 7-bit chars and 256 for 8-bit
- * yymore_used - if true, yymore() is used in input rules
- * reject - if true, generate back-up tables for REJECT macro
- * real_reject - if true, scanner really uses REJECT (as opposed to just
- *   having "reject" set for variable trailing context)
- * continued_action - true if this rule's action is to "fall through" to
- *   the next rule's action (i.e., the '|' action)
- * in_rule - true if we're inside an individual rule, false if not.
- * yymore_really_used - whether to treat yymore() as really used, regardless
- *   of what we think based on references to it in the user's actions.
- * reject_really_used - same for REJECT
- */
-
-extern int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
-extern int interactive, caseins, lex_compat, do_yylineno;
-extern int useecs, fulltbl, usemecs, fullspd;
-extern int gen_line_dirs, performance_report, backing_up_report;
-extern int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap;
-extern int csize;
-extern int yymore_used, reject, real_reject, continued_action, in_rule;
-
-extern int yymore_really_used, reject_really_used;
-
-
-/* Variables used in the flex input routines:
- * datapos - characters on current output line
- * dataline - number of contiguous lines of data in current data
- * 	statement.  Used to generate readable -f output
- * linenum - current input line number
- * out_linenum - current output line number
- * skelfile - the skeleton file
- * skel - compiled-in skeleton array
- * skel_ind - index into "skel" array, if skelfile is nil
- * yyin - input file
- * backing_up_file - file to summarize backing-up states to
- * infilename - name of input file
- * outfilename - name of output file
- * did_outfilename - whether outfilename was explicitly set
- * prefix - the prefix used for externally visible names ("yy" by default)
- * yyclass - yyFlexLexer subclass to use for YY_DECL
- * do_stdinit - whether to initialize yyin/yyout to stdin/stdout
- * use_stdout - the -t flag
- * input_files - array holding names of input files
- * num_input_files - size of input_files array
- * program_name - name with which program was invoked 
- *
- * action_array - array to hold the rule actions
- * action_size - size of action_array
- * defs1_offset - index where the user's section 1 definitions start
- *	in action_array
- * prolog_offset - index where the prolog starts in action_array
- * action_offset - index where the non-prolog starts in action_array
- * action_index - index where the next action should go, with respect
- * 	to "action_array"
- */
-
-extern int datapos, dataline, linenum, out_linenum;
-extern FILE *skelfile, *yyin, *backing_up_file;
-extern const char *skel[];
-extern int skel_ind;
-extern char *infilename, *outfilename;
-extern int did_outfilename;
-extern char *prefix, *yyclass;
-extern int do_stdinit, use_stdout;
-extern char **input_files;
-extern int num_input_files;
-extern char *program_name;
-
-extern char *action_array;
-extern int action_size;
-extern int defs1_offset, prolog_offset, action_offset, action_index;
-
-
-/* Variables for stack of states having only one out-transition:
- * onestate - state number
- * onesym - transition symbol
- * onenext - target state
- * onedef - default base entry
- * onesp - stack pointer
- */
-
-extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
-extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
-
-
-/* Variables for nfa machine data:
- * current_mns - current maximum on number of NFA states
- * num_rules - number of the last accepting state; also is number of
- * 	rules created so far
- * num_eof_rules - number of <<EOF>> rules
- * default_rule - number of the default rule
- * current_max_rules - current maximum number of rules
- * lastnfa - last nfa state number created
- * firstst - physically the first state of a fragment
- * lastst - last physical state of fragment
- * finalst - last logical state of fragment
- * transchar - transition character
- * trans1 - transition state
- * trans2 - 2nd transition state for epsilons
- * accptnum - accepting number
- * assoc_rule - rule associated with this NFA state (or 0 if none)
- * state_type - a STATE_xxx type identifying whether the state is part
- * 	of a normal rule, the leading state in a trailing context
- * 	rule (i.e., the state which marks the transition from
- * 	recognizing the text-to-be-matched to the beginning of
- * 	the trailing context), or a subsequent state in a trailing
- * 	context rule
- * rule_type - a RULE_xxx type identifying whether this a ho-hum
- * 	normal rule or one which has variable head & trailing
- * 	context
- * rule_linenum - line number associated with rule
- * rule_useful - true if we've determined that the rule can be matched
- */
-
-extern int current_mns, current_max_rules;
-extern int num_rules, num_eof_rules, default_rule, lastnfa;
-extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
-extern int *accptnum, *assoc_rule, *state_type;
-extern int *rule_type, *rule_linenum, *rule_useful;
-
-/* Different types of states; values are useful as masks, as well, for
- * routines like check_trailing_context().
- */
-#define STATE_NORMAL 0x1
-#define STATE_TRAILING_CONTEXT 0x2
-
-/* Global holding current type of state we're making. */
-
-extern int current_state_type;
-
-/* Different types of rules. */
-#define RULE_NORMAL 0
-#define RULE_VARIABLE 1
-
-/* True if the input rules include a rule with both variable-length head
- * and trailing context, false otherwise.
- */
-extern int variable_trailing_context_rules;
-
-
-/* Variables for protos:
- * numtemps - number of templates created
- * numprots - number of protos created
- * protprev - backlink to a more-recently used proto
- * protnext - forward link to a less-recently used proto
- * prottbl - base/def table entry for proto
- * protcomst - common state of proto
- * firstprot - number of the most recently used proto
- * lastprot - number of the least recently used proto
- * protsave contains the entire state array for protos
- */
-
-extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
-extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
-
-
-/* Variables for managing equivalence classes:
- * numecs - number of equivalence classes
- * nextecm - forward link of Equivalence Class members
- * ecgroup - class number or backward link of EC members
- * nummecs - number of meta-equivalence classes (used to compress
- *   templates)
- * tecfwd - forward link of meta-equivalence classes members
- * tecbck - backward link of MEC's
- */
-
-/* Reserve enough room in the equivalence class arrays so that we
- * can use the CSIZE'th element to hold equivalence class information
- * for the NUL character.  Later we'll move this information into
- * the 0th element.
- */
-extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs;
-
-/* Meta-equivalence classes are indexed starting at 1, so it's possible
- * that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1
- * slots total (since the arrays are 0-based).  nextecm[] and ecgroup[]
- * don't require the extra position since they're indexed from 1 .. CSIZE - 1.
- */
-extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1];
-
-
-/* Variables for start conditions:
- * lastsc - last start condition created
- * current_max_scs - current limit on number of start conditions
- * scset - set of rules active in start condition
- * scbol - set of rules active only at the beginning of line in a s.c.
- * scxclu - true if start condition is exclusive
- * sceof - true if start condition has EOF rule
- * scname - start condition name
- */
-
-extern int lastsc, *scset, *scbol, *scxclu, *sceof;
-extern int current_max_scs;
-extern char **scname;
-
-
-/* Variables for dfa machine data:
- * current_max_dfa_size - current maximum number of NFA states in DFA
- * current_max_xpairs - current maximum number of non-template xtion pairs
- * current_max_template_xpairs - current maximum number of template pairs
- * current_max_dfas - current maximum number DFA states
- * lastdfa - last dfa state number created
- * nxt - state to enter upon reading character
- * chk - check value to see if "nxt" applies
- * tnxt - internal nxt table for templates
- * base - offset into "nxt" for given state
- * def - where to go if "chk" disallows "nxt" entry
- * nultrans - NUL transition for each state
- * NUL_ec - equivalence class of the NUL character
- * tblend - last "nxt/chk" table entry being used
- * firstfree - first empty entry in "nxt/chk" table
- * dss - nfa state set for each dfa
- * dfasiz - size of nfa state set for each dfa
- * dfaacc - accepting set for each dfa state (if using REJECT), or accepting
- *	number, if not
- * accsiz - size of accepting set for each dfa state
- * dhash - dfa state hash value
- * numas - number of DFA accepting states created; note that this
- *	is not necessarily the same value as num_rules, which is the analogous
- *	value for the NFA
- * numsnpairs - number of state/nextstate transition pairs
- * jambase - position in base/def where the default jam table starts
- * jamstate - state number corresponding to "jam" state
- * end_of_buffer_state - end-of-buffer dfa state number
- */
-
-extern int current_max_dfa_size, current_max_xpairs;
-extern int current_max_template_xpairs, current_max_dfas;
-extern int lastdfa, *nxt, *chk, *tnxt;
-extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
-extern union dfaacc_union
-	{
-	int *dfaacc_set;
-	int dfaacc_state;
-	} *dfaacc;
-extern int *accsiz, *dhash, numas;
-extern int numsnpairs, jambase, jamstate;
-extern int end_of_buffer_state;
-
-/* Variables for ccl information:
- * lastccl - ccl index of the last created ccl
- * current_maxccls - current limit on the maximum number of unique ccl's
- * cclmap - maps a ccl index to its set pointer
- * ccllen - gives the length of a ccl
- * cclng - true for a given ccl if the ccl is negated
- * cclreuse - counts how many times a ccl is re-used
- * current_max_ccl_tbl_size - current limit on number of characters needed
- *	to represent the unique ccl's
- * ccltbl - holds the characters in each ccl - indexed by cclmap
- */
-
-extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
-extern int current_maxccls, current_max_ccl_tbl_size;
-extern Char *ccltbl;
-
-
-/* Variables for miscellaneous information:
- * nmstr - last NAME scanned by the scanner
- * sectnum - section number currently being parsed
- * nummt - number of empty nxt/chk table entries
- * hshcol - number of hash collisions detected by snstods
- * dfaeql - number of times a newly created dfa was equal to an old one
- * numeps - number of epsilon NFA states created
- * eps2 - number of epsilon states which have 2 out-transitions
- * num_reallocs - number of times it was necessary to realloc() a group
- *	  of arrays
- * tmpuses - number of DFA states that chain to templates
- * totnst - total number of NFA states used to make DFA states
- * peakpairs - peak number of transition pairs we had to store internally
- * numuniq - number of unique transitions
- * numdup - number of duplicate transitions
- * hshsave - number of hash collisions saved by checking number of states
- * num_backing_up - number of DFA states requiring backing up
- * bol_needed - whether scanner needs beginning-of-line recognition
- */
-
-extern char nmstr[MAXLINE];
-extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
-extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
-extern int num_backing_up, bol_needed;
-
-void *allocate_array PROTO((int, size_t));
-void *reallocate_array PROTO((void*, int, size_t));
-
-void *flex_alloc PROTO((size_t));
-void *flex_realloc PROTO((void*, size_t));
-void flex_free PROTO((void*));
-
-#define allocate_integer_array(size) \
-	(int *) allocate_array( size, sizeof( int ) )
-
-#define reallocate_integer_array(array,size) \
-	(int *) reallocate_array( (void *) array, size, sizeof( int ) )
-
-#define allocate_int_ptr_array(size) \
-	(int **) allocate_array( size, sizeof( int * ) )
-
-#define allocate_char_ptr_array(size) \
-	(char **) allocate_array( size, sizeof( char * ) )
-
-#define allocate_dfaacc_union(size) \
-	(union dfaacc_union *) \
-		allocate_array( size, sizeof( union dfaacc_union ) )
-
-#define reallocate_int_ptr_array(array,size) \
-	(int **) reallocate_array( (void *) array, size, sizeof( int * ) )
-
-#define reallocate_char_ptr_array(array,size) \
-	(char **) reallocate_array( (void *) array, size, sizeof( char * ) )
-
-#define reallocate_dfaacc_union(array, size) \
-	(union dfaacc_union *) \
-	reallocate_array( (void *) array, size, sizeof( union dfaacc_union ) )
-
-#define allocate_character_array(size) \
-	(char *) allocate_array( size, sizeof( char ) )
-
-#define reallocate_character_array(array,size) \
-	(char *) reallocate_array( (void *) array, size, sizeof( char ) )
-
-#define allocate_Character_array(size) \
-	(Char *) allocate_array( size, sizeof( Char ) )
-
-#define reallocate_Character_array(array,size) \
-	(Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
-
-
-/* Used to communicate between scanner and parser.  The type should really
- * be YYSTYPE, but we can't easily get our hands on it.
- */
-extern int yylval;
-
-
-/* External functions that are cross-referenced among the flex source files. */
-
-
-/* from file ccl.c */
-
-extern void ccladd PROTO((int, int));	/* add a single character to a ccl */
-extern int cclinit PROTO((void));	/* make an empty ccl */
-extern void cclnegate PROTO((int));	/* negate a ccl */
-
-/* List the members of a set of characters in CCL form. */
-extern void list_character_set PROTO((FILE*, int[]));
-
-
-/* from file dfa.c */
-
-/* Check a DFA state for backing up. */
-extern void check_for_backing_up PROTO((int, int[]));
-
-/* Check to see if NFA state set constitutes "dangerous" trailing context. */
-extern void check_trailing_context PROTO((int*, int, int*, int));
-
-/* Construct the epsilon closure of a set of ndfa states. */
-extern int *epsclosure PROTO((int*, int*, int[], int*, int*));
-
-/* Increase the maximum number of dfas. */
-extern void increase_max_dfas PROTO((void));
-
-extern void ntod PROTO((void));	/* convert a ndfa to a dfa */
-
-/* Converts a set of ndfa states into a dfa state. */
-extern int snstods PROTO((int[], int, int[], int, int, int*));
-
-
-/* from file ecs.c */
-
-/* Convert character classes to set of equivalence classes. */
-extern void ccl2ecl PROTO((void));
-
-/* Associate equivalence class numbers with class members. */
-extern int cre8ecs PROTO((int[], int[], int));
-
-/* Update equivalence classes based on character class transitions. */
-extern void mkeccl PROTO((Char[], int, int[], int[], int, int));
-
-/* Create equivalence class for single character. */
-extern void mkechar PROTO((int, int[], int[]));
-
-
-/* from file gen.c */
-
-extern void do_indent PROTO((void));	/* indent to the current level */
-
-/* Generate the code to keep backing-up information. */
-extern void gen_backing_up PROTO((void));
-
-/* Generate the code to perform the backing up. */
-extern void gen_bu_action PROTO((void));
-
-/* Generate full speed compressed transition table. */
-extern void genctbl PROTO((void));
-
-/* Generate the code to find the action number. */
-extern void gen_find_action PROTO((void));
-
-extern void genftbl PROTO((void));	/* generate full transition table */
-
-/* Generate the code to find the next compressed-table state. */
-extern void gen_next_compressed_state PROTO((char*));
-
-/* Generate the code to find the next match. */
-extern void gen_next_match PROTO((void));
-
-/* Generate the code to find the next state. */
-extern void gen_next_state PROTO((int));
-
-/* Generate the code to make a NUL transition. */
-extern void gen_NUL_trans PROTO((void));
-
-/* Generate the code to find the start state. */
-extern void gen_start_state PROTO((void));
-
-/* Generate data statements for the transition tables. */
-extern void gentabs PROTO((void));
-
-/* Write out a formatted string at the current indentation level. */
-extern void indent_put2s PROTO((char[], char[]));
-
-/* Write out a string + newline at the current indentation level. */
-extern void indent_puts PROTO((char[]));
-
-extern void make_tables PROTO((void));	/* generate transition tables */
-
-
-/* from file main.c */
-
-extern void check_options PROTO((void));
-extern void flexend PROTO((int));
-extern void usage PROTO((void));
-
-
-/* from file misc.c */
-
-/* Add a #define to the action file. */
-extern void action_define PROTO(( char *defname, int value ));
-
-/* Add the given text to the stored actions. */
-extern void add_action PROTO(( char *new_text ));
-
-/* True if a string is all lower case. */
-extern int all_lower PROTO((char *));
-
-/* True if a string is all upper case. */
-extern int all_upper PROTO((char *));
-
-/* Bubble sort an integer array. */
-extern void bubble PROTO((int [], int));
-
-/* Check a character to make sure it's in the expected range. */
-extern void check_char PROTO((int c));
-
-/* Replace upper-case letter to lower-case. */
-extern Char clower PROTO((int));
-
-/* Returns a dynamically allocated copy of a string. */
-extern char *copy_string PROTO((const char *));
-
-/* Returns a dynamically allocated copy of a (potentially) unsigned string. */
-extern Char *copy_unsigned_string PROTO((Char *));
-
-/* Shell sort a character array. */
-extern void cshell PROTO((Char [], int, int));
-
-/* Finish up a block of data declarations. */
-extern void dataend PROTO((void));
-
-/* Flush generated data statements. */
-extern void dataflush PROTO((void));
-
-/* Report an error message and terminate. */
-extern void flexerror PROTO((const char[]));
-
-/* Report a fatal error message and terminate. */
-extern void flexfatal PROTO((const char[]));
-
-/* Convert a hexadecimal digit string to an integer value. */
-extern int htoi PROTO((Char[]));
-
-/* Report an error message formatted with one integer argument. */
-extern void lerrif PROTO((const char[], int));
-
-/* Report an error message formatted with one string argument. */
-extern void lerrsf PROTO((const char[], const char[]));
-
-/* Spit out a "#line" statement. */
-extern void line_directive_out PROTO((FILE*, int));
-
-/* Mark the current position in the action array as the end of the section 1
- * user defs.
- */
-extern void mark_defs1 PROTO((void));
-
-/* Mark the current position in the action array as the end of the prolog. */
-extern void mark_prolog PROTO((void));
-
-/* Generate a data statement for a two-dimensional array. */
-extern void mk2data PROTO((int));
-
-extern void mkdata PROTO((int));	/* generate a data statement */
-
-/* Return the integer represented by a string of digits. */
-extern int myctoi PROTO((char []));
-
-/* Return character corresponding to escape sequence. */
-extern Char myesc PROTO((Char[]));
-
-/* Convert an octal digit string to an integer value. */
-extern int otoi PROTO((Char [] ));
-
-/* Output a (possibly-formatted) string to the generated scanner. */
-extern void out PROTO((const char []));
-extern void out_dec PROTO((const char [], int));
-extern void out_dec2 PROTO((const char [], int, int));
-extern void out_hex PROTO((const char [], unsigned int));
-extern void out_line_count PROTO((const char []));
-extern void out_str PROTO((const char [], const char []));
-extern void out_str3
-	PROTO((const char [], const char [], const char [], const char []));
-extern void out_str_dec PROTO((const char [], const char [], int));
-extern void outc PROTO((int));
-extern void outn PROTO((const char []));
-
-/* Return a printable version of the given character, which might be
- * 8-bit.
- */
-extern char *readable_form PROTO((int));
-
-/* Write out one section of the skeleton file. */
-extern void skelout PROTO((void));
-
-/* Output a yy_trans_info structure. */
-extern void transition_struct_out PROTO((int, int));
-
-/* Only needed when using certain broken versions of bison to build parse.c. */
-extern void *yy_flex_xmalloc PROTO(( int ));
-
-/* Set a region of memory to 0. */
-extern void zero_out PROTO((char *, size_t));
-
-
-/* from file nfa.c */
-
-/* Add an accepting state to a machine. */
-extern void add_accept PROTO((int, int));
-
-/* Make a given number of copies of a singleton machine. */
-extern int copysingl PROTO((int, int));
-
-/* Debugging routine to write out an nfa. */
-extern void dumpnfa PROTO((int));
-
-/* Finish up the processing for a rule. */
-extern void finish_rule PROTO((int, int, int, int));
-
-/* Connect two machines together. */
-extern int link_machines PROTO((int, int));
-
-/* Mark each "beginning" state in a machine as being a "normal" (i.e.,
- * not trailing context associated) state.
- */
-extern void mark_beginning_as_normal PROTO((int));
-
-/* Make a machine that branches to two machines. */
-extern int mkbranch PROTO((int, int));
-
-extern int mkclos PROTO((int));	/* convert a machine into a closure */
-extern int mkopt PROTO((int));	/* make a machine optional */
-
-/* Make a machine that matches either one of two machines. */
-extern int mkor PROTO((int, int));
-
-/* Convert a machine into a positive closure. */
-extern int mkposcl PROTO((int));
-
-extern int mkrep PROTO((int, int, int));	/* make a replicated machine */
-
-/* Create a state with a transition on a given symbol. */
-extern int mkstate PROTO((int));
-
-extern void new_rule PROTO((void));	/* initialize for a new rule */
-
-
-/* from file parse.y */
-
-/* Build the "<<EOF>>" action for the active start conditions. */
-extern void build_eof_action PROTO((void));
-
-/* Write out a message formatted with one string, pinpointing its location. */
-extern void format_pinpoint_message PROTO((char[], char[]));
-
-/* Write out a message, pinpointing its location. */
-extern void pinpoint_message PROTO((char[]));
-
-/* Write out a warning, pinpointing it at the given line. */
-extern void line_warning PROTO(( char[], int ));
-
-/* Write out a message, pinpointing it at the given line. */
-extern void line_pinpoint PROTO(( char[], int ));
-
-/* Report a formatted syntax error. */
-extern void format_synerr PROTO((char [], char[]));
-extern void synerr PROTO((char []));	/* report a syntax error */
-extern void format_warn PROTO((char [], char[]));
-extern void warn PROTO((char []));	/* report a warning */
-extern void yyerror PROTO((char []));	/* report a parse error */
-extern int yyparse PROTO((void));	/* the YACC parser */
-
-
-/* from file scan.l */
-
-/* The Flex-generated scanner for flex. */
-extern int flexscan PROTO((void));
-
-/* Open the given file (if NULL, stdin) for scanning. */
-extern void set_input_file PROTO((char*));
-
-/* Wrapup a file in the lexical analyzer. */
-extern int yywrap PROTO((void));
-
-
-/* from file sym.c */
-
-/* Add symbol and definitions to symbol table. */
-extern int addsym PROTO((char[], char*, int, hash_table, int));
-
-/* Save the text of a character class. */
-extern void cclinstal PROTO ((Char [], int));
-
-/* Lookup the number associated with character class. */
-extern int ccllookup PROTO((Char []));
-
-/* Find symbol in symbol table. */
-extern struct hash_entry *findsym PROTO((char[], hash_table, int ));
-
-extern void ndinstal PROTO((char[], Char[]));	/* install a name definition */
-extern Char *ndlookup PROTO((char[]));	/* lookup a name definition */
-
-/* Increase maximum number of SC's. */
-extern void scextend PROTO((void));
-extern void scinstal PROTO((char[], int));	/* make a start condition */
-
-/* Lookup the number associated with a start condition. */
-extern int sclookup PROTO((char[]));
-
-
-/* from file tblcmp.c */
-
-/* Build table entries for dfa state. */
-extern void bldtbl PROTO((int[], int, int, int, int));
-
-extern void cmptmps PROTO((void));	/* compress template table entries */
-extern void expand_nxt_chk PROTO((void));	/* increase nxt/chk arrays */
-/* Finds a space in the table for a state to be placed. */
-extern int find_table_space PROTO((int*, int));
-extern void inittbl PROTO((void));	/* initialize transition tables */
-/* Make the default, "jam" table entries. */
-extern void mkdeftbl PROTO((void));
-
-/* Create table entries for a state (or state fragment) which has
- * only one out-transition.
- */
-extern void mk1tbl PROTO((int, int, int, int));
-
-/* Place a state into full speed transition table. */
-extern void place_state PROTO((int*, int, int));
-
-/* Save states with only one out-transition to be processed later. */
-extern void stack1 PROTO((int, int, int, int));
-
-
-/* from file yylex.c */
-
-extern int yylex PROTO((void));
diff --git a/usr.bin/lex/gen.c b/usr.bin/lex/gen.c
deleted file mode 100644
index b72688b63747..000000000000
--- a/usr.bin/lex/gen.c
+++ /dev/null
@@ -1,1629 +0,0 @@
-/* gen - actual generation (writing) of flex scanners */
-
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Vern Paxson.
- * 
- * The United States Government has rights in this work pursuant
- * to contract no. DE-AC03-76SF00098 between the United States
- * Department of Energy and the University of California.
- *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * 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.
- */
-
-/* $Header: /home/daffy/u0/vern/flex/RCS/gen.c,v 2.56 96/05/25 20:43:38 vern Exp $ */
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include "flexdef.h"
-
-
-/* declare functions that have forward references */
-
-void gen_next_state PROTO((int));
-void genecs PROTO((void));
-void indent_put2s PROTO((char [], char []));
-void indent_puts PROTO((char []));
-
-
-static int indent_level = 0; /* each level is 8 spaces */
-
-#define indent_up() (++indent_level)
-#define indent_down() (--indent_level)
-#define set_indent(indent_val) indent_level = indent_val
-
-/* Almost everything is done in terms of arrays starting at 1, so provide
- * a null entry for the zero element of all C arrays.  (The exception
- * to this is that the fast table representation generally uses the
- * 0 elements of its arrays, too.)
- */
-static char C_int_decl[] = "static yyconst int %s[%d] =\n    {   0,\n";
-static char C_short_decl[] = "static yyconst short int %s[%d] =\n    {   0,\n";
-static char C_long_decl[] = "static yyconst long int %s[%d] =\n    {   0,\n";
-static char C_state_decl[] =
-	"static yyconst yy_state_type %s[%d] =\n    {   0,\n";
-
-
-/* Indent to the current level. */
-
-void do_indent()
-	{
-	int i = indent_level * 8;
-
-	while ( i >= 8 )
-		{
-		outc( '\t' );
-		i -= 8;
-		}
-
-	while ( i > 0 )
-		{
-		outc( ' ' );
-		--i;
-		}
-	}
-
-
-/* Generate the code to keep backing-up information. */
-
-void gen_backing_up()
-	{
-	if ( reject || num_backing_up == 0 )
-		return;
-
-	if ( fullspd )
-		indent_puts( "if ( yy_current_state[-1].yy_nxt )" );
-	else
-		indent_puts( "if ( yy_accept[yy_current_state] )" );
-
-	indent_up();
-	indent_puts( "{" );
-	indent_puts( "yy_last_accepting_state = yy_current_state;" );
-	indent_puts( "yy_last_accepting_cpos = yy_cp;" );
-	indent_puts( "}" );
-	indent_down();
-	}
-
-
-/* Generate the code to perform the backing up. */
-
-void gen_bu_action()
-	{
-	if ( reject || num_backing_up == 0 )
-		return;
-
-	set_indent( 3 );
-
-	indent_puts( "case 0: /* must back up */" );
-	indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
-	indent_puts( "*yy_cp = yy_hold_char;" );
-
-	if ( fullspd || fulltbl )
-		indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
-	else
-		/* Backing-up info for compressed tables is taken \after/
-		 * yy_cp has been incremented for the next state.
-		 */
-		indent_puts( "yy_cp = yy_last_accepting_cpos;" );
-
-	indent_puts( "yy_current_state = yy_last_accepting_state;" );
-	indent_puts( "goto yy_find_action;" );
-	outc( '\n' );
-
-	set_indent( 0 );
-	}
-
-
-/* genctbl - generates full speed compressed transition table */
-
-void genctbl()
-	{
-	int i;
-	int end_of_buffer_action = num_rules + 1;
-
-	/* Table of verify for transition and offset to next state. */
-	out_dec( "static yyconst struct yy_trans_info yy_transition[%d] =\n",
-		tblend + numecs + 1 );
-	outn( "    {" );
-
-	/* We want the transition to be represented as the offset to the
-	 * next state, not the actual state number, which is what it currently
-	 * is.  The offset is base[nxt[i]] - (base of current state)].  That's
-	 * just the difference between the starting points of the two involved
-	 * states (to - from).
-	 *
-	 * First, though, we need to find some way to put in our end-of-buffer
-	 * flags and states.  We do this by making a state with absolutely no
-	 * transitions.  We put it at the end of the table.
-	 */
-
-	/* We need to have room in nxt/chk for two more slots: One for the
-	 * action and one for the end-of-buffer transition.  We now *assume*
-	 * that we're guaranteed the only character we'll try to index this
-	 * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
-	 * there's room for jam entries for other characters.
-	 */
-
-	while ( tblend + 2 >= current_max_xpairs )
-		expand_nxt_chk();
-
-	while ( lastdfa + 1 >= current_max_dfas )
-		increase_max_dfas();
-
-	base[lastdfa + 1] = tblend + 2;
-	nxt[tblend + 1] = end_of_buffer_action;
-	chk[tblend + 1] = numecs + 1;
-	chk[tblend + 2] = 1; /* anything but EOB */
-
-	/* So that "make test" won't show arb. differences. */
-	nxt[tblend + 2] = 0;
-
-	/* Make sure every state has an end-of-buffer transition and an
-	 * action #.
-	 */
-	for ( i = 0; i <= lastdfa; ++i )
-		{
-		int anum = dfaacc[i].dfaacc_state;
-		int offset = base[i];
-
-		chk[offset] = EOB_POSITION;
-		chk[offset - 1] = ACTION_POSITION;
-		nxt[offset - 1] = anum;	/* action number */
-		}
-
-	for ( i = 0; i <= tblend; ++i )
-		{
-		if ( chk[i] == EOB_POSITION )
-			transition_struct_out( 0, base[lastdfa + 1] - i );
-
-		else if ( chk[i] == ACTION_POSITION )
-			transition_struct_out( 0, nxt[i] );
-
-		else if ( chk[i] > numecs || chk[i] == 0 )
-			transition_struct_out( 0, 0 );	/* unused slot */
-
-		else	/* verify, transition */
-			transition_struct_out( chk[i],
-						base[nxt[i]] - (i - chk[i]) );
-		}
-
-
-	/* Here's the final, end-of-buffer state. */
-	transition_struct_out( chk[tblend + 1], nxt[tblend + 1] );
-	transition_struct_out( chk[tblend + 2], nxt[tblend + 2] );
-
-	outn( "    };\n" );
-
-	/* Table of pointers to start states. */
-	out_dec(
-	"static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n",
-		lastsc * 2 + 1 );
-	outn( "    {" );	/* } so vi doesn't get confused */
-
-	for ( i = 0; i <= lastsc * 2; ++i )
-		out_dec( "    &yy_transition[%d],\n", base[i] );
-
-	dataend();
-
-	if ( useecs )
-		genecs();
-	}
-
-
-/* Generate equivalence-class tables. */
-
-void genecs()
-	{
-	int i, j;
-	int numrows;
-
-	out_str_dec( C_int_decl, "yy_ec", csize );
-
-	for ( i = 1; i < csize; ++i )
-		{
-		if ( caseins && (i >= 'A') && (i <= 'Z') )
-			ecgroup[i] = ecgroup[clower( i )];
-
-		ecgroup[i] = ABS( ecgroup[i] );
-		mkdata( ecgroup[i] );
-		}
-
-	dataend();
-
-	if ( trace )
-		{
-		fputs( _( "\n\nEquivalence Classes:\n\n" ), stderr );
-
-		numrows = csize / 8;
-
-		for ( j = 0; j < numrows; ++j )
-			{
-			for ( i = j; i < csize; i = i + numrows )
-				{
-				fprintf( stderr, "%4s = %-2d",
-					readable_form( i ), ecgroup[i] );
-
-				putc( ' ', stderr );
-				}
-
-			putc( '\n', stderr );
-			}
-		}
-	}
-
-
-/* Generate the code to find the action number. */
-
-void gen_find_action()
-	{
-	if ( fullspd )
-		indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" );
-
-	else if ( fulltbl )
-		indent_puts( "yy_act = yy_accept[yy_current_state];" );
-
-	else if ( reject )
-		{
-		indent_puts( "yy_current_state = *--yy_state_ptr;" );
-		indent_puts( "yy_lp = yy_accept[yy_current_state];" );
-
-		outn(
-		"goto find_rule; /* avoid `defined but not used' warning */");
-		outn(
-		"find_rule: /* we branch to this label when backing up */" );
-
-		indent_puts(
-		"for ( ; ; ) /* until we find what rule we matched */" );
-
-		indent_up();
-
-		indent_puts( "{" );
-
-		indent_puts(
-		"if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" );
-		indent_up();
-		indent_puts( "{" );
-		indent_puts( "yy_act = yy_acclist[yy_lp];" );
-
-		if ( variable_trailing_context_rules )
-			{
-			indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" );
-			indent_puts( "     yy_looking_for_trail_begin )" );
-			indent_up();
-			indent_puts( "{" );
-
-			indent_puts(
-				"if ( yy_act == yy_looking_for_trail_begin )" );
-			indent_up();
-			indent_puts( "{" );
-			indent_puts( "yy_looking_for_trail_begin = 0;" );
-			indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" );
-			indent_puts( "break;" );
-			indent_puts( "}" );
-			indent_down();
-
-			indent_puts( "}" );
-			indent_down();
-
-			indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" );
-			indent_up();
-			indent_puts( "{" );
-			indent_puts(
-		"yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;" );
-			indent_puts(
-		"yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;" );
-
-			if ( real_reject )
-				{
-				/* Remember matched text in case we back up
-				 * due to REJECT.
-				 */
-				indent_puts( "yy_full_match = yy_cp;" );
-				indent_puts( "yy_full_state = yy_state_ptr;" );
-				indent_puts( "yy_full_lp = yy_lp;" );
-				}
-
-			indent_puts( "}" );
-			indent_down();
-
-			indent_puts( "else" );
-			indent_up();
-			indent_puts( "{" );
-			indent_puts( "yy_full_match = yy_cp;" );
-			indent_puts( "yy_full_state = yy_state_ptr;" );
-			indent_puts( "yy_full_lp = yy_lp;" );
-			indent_puts( "break;" );
-			indent_puts( "}" );
-			indent_down();
-
-			indent_puts( "++yy_lp;" );
-			indent_puts( "goto find_rule;" );
-			}
-
-		else
-			{
-			/* Remember matched text in case we back up due to
-			 * trailing context plus REJECT.
-			 */
-			indent_up();
-			indent_puts( "{" );
-			indent_puts( "yy_full_match = yy_cp;" );
-			indent_puts( "break;" );
-			indent_puts( "}" );
-			indent_down();
-			}
-
-		indent_puts( "}" );
-		indent_down();
-
-		indent_puts( "--yy_cp;" );
-
-		/* We could consolidate the following two lines with those at
-		 * the beginning, but at the cost of complaints that we're
-		 * branching inside a loop.
-		 */
-		indent_puts( "yy_current_state = *--yy_state_ptr;" );
-		indent_puts( "yy_lp = yy_accept[yy_current_state];" );
-
-		indent_puts( "}" );
-
-		indent_down();
-		}
-
-	else
-		{ /* compressed */
-		indent_puts( "yy_act = yy_accept[yy_current_state];" );
-
-		if ( interactive && ! reject )
-			{
-			/* Do the guaranteed-needed backing up to figure out
-			 * the match.
-			 */
-			indent_puts( "if ( yy_act == 0 )" );
-			indent_up();
-			indent_puts( "{ /* have to back up */" );
-			indent_puts( "yy_cp = yy_last_accepting_cpos;" );
-			indent_puts(
-				"yy_current_state = yy_last_accepting_state;" );
-			indent_puts( "yy_act = yy_accept[yy_current_state];" );
-			indent_puts( "}" );
-			indent_down();
-			}
-		}
-	}
-
-
-/* genftbl - generate full transition table */
-
-void genftbl()
-	{
-	int i;
-	int end_of_buffer_action = num_rules + 1;
-
-	out_str_dec( long_align ? C_long_decl : C_short_decl,
-		"yy_accept", lastdfa + 1 );
-
-	dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
-
-	for ( i = 1; i <= lastdfa; ++i )
-		{
-		int anum = dfaacc[i].dfaacc_state;
-
-		mkdata( anum );
-
-		if ( trace && anum )
-			fprintf( stderr, _( "state # %d accepts: [%d]\n" ),
-				i, anum );
-		}
-
-	dataend();
-
-	if ( useecs )
-		genecs();
-
-	/* Don't have to dump the actual full table entries - they were
-	 * created on-the-fly.
-	 */
-	}
-
-
-/* Generate the code to find the next compressed-table state. */
-
-void gen_next_compressed_state( char_map )
-char *char_map;
-	{
-	indent_put2s( "YY_CHAR yy_c = %s;", char_map );
-
-	/* Save the backing-up info \before/ computing the next state
-	 * because we always compute one more state than needed - we
-	 * always proceed until we reach a jam state
-	 */
-	gen_backing_up();
-
-	indent_puts(
-"while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" );
-	indent_up();
-	indent_puts( "{" );
-	indent_puts( "yy_current_state = (int) yy_def[yy_current_state];" );
-
-	if ( usemecs )
-		{
-		/* We've arrange it so that templates are never chained
-		 * to one another.  This means we can afford to make a
-		 * very simple test to see if we need to convert to
-		 * yy_c's meta-equivalence class without worrying
-		 * about erroneously looking up the meta-equivalence
-		 * class twice
-		 */
-		do_indent();
-
-		/* lastdfa + 2 is the beginning of the templates */
-		out_dec( "if ( yy_current_state >= %d )\n", lastdfa + 2 );
-
-		indent_up();
-		indent_puts( "yy_c = yy_meta[(unsigned int) yy_c];" );
-		indent_down();
-		}
-
-	indent_puts( "}" );
-	indent_down();
-
-	indent_puts(
-"yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];" );
-	}
-
-
-/* Generate the code to find the next match. */
-
-void gen_next_match()
-	{
-	/* NOTE - changes in here should be reflected in gen_next_state() and
-	 * gen_NUL_trans().
-	 */
-	char *char_map = useecs ?
-				"yy_ec[YY_SC_TO_UI(*yy_cp)]" :
-				"YY_SC_TO_UI(*yy_cp)";
-
-	char *char_map_2 = useecs ?
-				"yy_ec[YY_SC_TO_UI(*++yy_cp)]" :
-				"YY_SC_TO_UI(*++yy_cp)";
-
-	if ( fulltbl )
-		{
-		indent_put2s(
-	"while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )",
-				char_map );
-
-		indent_up();
-
-		if ( num_backing_up > 0 )
-			{
-			indent_puts( "{" );	/* } for vi */
-			gen_backing_up();
-			outc( '\n' );
-			}
-
-		indent_puts( "++yy_cp;" );
-
-		if ( num_backing_up > 0 )
-			/* { for vi */
-			indent_puts( "}" );
-
-		indent_down();
-
-		outc( '\n' );
-		indent_puts( "yy_current_state = -yy_current_state;" );
-		}
-
-	else if ( fullspd )
-		{
-		indent_puts( "{" );	/* } for vi */
-		indent_puts(
-		"yyconst struct yy_trans_info *yy_trans_info;\n" );
-		indent_puts( "YY_CHAR yy_c;\n" );
-		indent_put2s( "for ( yy_c = %s;", char_map );
-		indent_puts(
-	"      (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->" );
-		indent_puts( "yy_verify == yy_c;" );
-		indent_put2s( "      yy_c = %s )", char_map_2 );
-
-		indent_up();
-
-		if ( num_backing_up > 0 )
-			indent_puts( "{" );	/* } for vi */
-
-		indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
-
-		if ( num_backing_up > 0 )
-			{
-			outc( '\n' );
-			gen_backing_up();	/* { for vi */
-			indent_puts( "}" );
-			}
-
-		indent_down();	/* { for vi */
-		indent_puts( "}" );
-		}
-
-	else
-		{ /* compressed */
-		indent_puts( "do" );
-
-		indent_up();
-		indent_puts( "{" );	/* } for vi */
-
-		gen_next_state( false );
-
-		indent_puts( "++yy_cp;" );
-
-		/* { for vi */
-		indent_puts( "}" );
-		indent_down();
-
-		do_indent();
-
-		if ( interactive )
-			out_dec( "while ( yy_base[yy_current_state] != %d );\n",
-				jambase );
-		else
-			out_dec( "while ( yy_current_state != %d );\n",
-				jamstate );
-
-		if ( ! reject && ! interactive )
-			{
-			/* Do the guaranteed-needed backing up to figure out
-			 * the match.
-			 */
-			indent_puts( "yy_cp = yy_last_accepting_cpos;" );
-			indent_puts(
-				"yy_current_state = yy_last_accepting_state;" );
-			}
-		}
-	}
-
-
-/* Generate the code to find the next state. */
-
-void gen_next_state( worry_about_NULs )
-int worry_about_NULs;
-	{ /* NOTE - changes in here should be reflected in gen_next_match() */
-	char char_map[256];
-
-	if ( worry_about_NULs && ! nultrans )
-		{
-		if ( useecs )
-			(void) sprintf( char_map,
-				"(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)",
-					NUL_ec );
-		else
-			(void) sprintf( char_map,
-				"(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", NUL_ec );
-		}
-
-	else
-		strcpy( char_map, useecs ?
-			"yy_ec[YY_SC_TO_UI(*yy_cp)]" : "YY_SC_TO_UI(*yy_cp)" );
-
-	if ( worry_about_NULs && nultrans )
-		{
-		if ( ! fulltbl && ! fullspd )
-			/* Compressed tables back up *before* they match. */
-			gen_backing_up();
-
-		indent_puts( "if ( *yy_cp )" );
-		indent_up();
-		indent_puts( "{" );	/* } for vi */
-		}
-
-	if ( fulltbl )
-		indent_put2s(
-			"yy_current_state = yy_nxt[yy_current_state][%s];", 
-				char_map );
-
-	else if ( fullspd )
-		indent_put2s(
-			"yy_current_state += yy_current_state[%s].yy_nxt;",
-				char_map );
-
-	else
-		gen_next_compressed_state( char_map );
-
-	if ( worry_about_NULs && nultrans )
-		{
-		/* { for vi */
-		indent_puts( "}" );
-		indent_down();
-		indent_puts( "else" );
-		indent_up();
-		indent_puts(
-			"yy_current_state = yy_NUL_trans[yy_current_state];" );
-		indent_down();
-		}
-
-	if ( fullspd || fulltbl )
-		gen_backing_up();
-
-	if ( reject )
-		indent_puts( "*yy_state_ptr++ = yy_current_state;" );
-	}
-
-
-/* Generate the code to make a NUL transition. */
-
-void gen_NUL_trans()
-	{ /* NOTE - changes in here should be reflected in gen_next_match() */
-	/* Only generate a definition for "yy_cp" if we'll generate code
-	 * that uses it.  Otherwise lint and the like complain.
-	 */
-	int need_backing_up = (num_backing_up > 0 && ! reject);
-
-	if ( need_backing_up && (! nultrans || fullspd || fulltbl) )
-		/* We're going to need yy_cp lying around for the call
-		 * below to gen_backing_up().
-		 */
-		indent_puts( "char *yy_cp = yy_c_buf_p;" );
-
-	outc( '\n' );
-
-	if ( nultrans )
-		{
-		indent_puts(
-			"yy_current_state = yy_NUL_trans[yy_current_state];" );
-		indent_puts( "yy_is_jam = (yy_current_state == 0);" );
-		}
-
-	else if ( fulltbl )
-		{
-		do_indent();
-		out_dec( "yy_current_state = yy_nxt[yy_current_state][%d];\n",
-			NUL_ec );
-		indent_puts( "yy_is_jam = (yy_current_state <= 0);" );
-		}
-
-	else if ( fullspd )
-		{
-		do_indent();
-		out_dec( "int yy_c = %d;\n", NUL_ec );
-
-		indent_puts(
-		"yyconst struct yy_trans_info *yy_trans_info;\n" );
-		indent_puts(
-		"yy_trans_info = &yy_current_state[(unsigned int) yy_c];" );
-		indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
-
-		indent_puts(
-			"yy_is_jam = (yy_trans_info->yy_verify != yy_c);" );
-		}
-
-	else
-		{
-		char NUL_ec_str[20];
-
-		(void) sprintf( NUL_ec_str, "%d", NUL_ec );
-		gen_next_compressed_state( NUL_ec_str );
-
-		do_indent();
-		out_dec( "yy_is_jam = (yy_current_state == %d);\n", jamstate );
-
-		if ( reject )
-			{
-			/* Only stack this state if it's a transition we
-			 * actually make.  If we stack it on a jam, then
-			 * the state stack and yy_c_buf_p get out of sync.
-			 */
-			indent_puts( "if ( ! yy_is_jam )" );
-			indent_up();
-			indent_puts( "*yy_state_ptr++ = yy_current_state;" );
-			indent_down();
-			}
-		}
-
-	/* If we've entered an accepting state, back up; note that
-	 * compressed tables have *already* done such backing up, so
-	 * we needn't bother with it again.
-	 */
-	if ( need_backing_up && (fullspd || fulltbl) )
-		{
-		outc( '\n' );
-		indent_puts( "if ( ! yy_is_jam )" );
-		indent_up();
-		indent_puts( "{" );
-		gen_backing_up();
-		indent_puts( "}" );
-		indent_down();
-		}
-	}
-
-
-/* Generate the code to find the start state. */
-
-void gen_start_state()
-	{
-	if ( fullspd )
-		{
-		if ( bol_needed )
-			{
-			indent_puts(
-	"yy_current_state = yy_start_state_list[yy_start + YY_AT_BOL()];" );
-			}
-		else
-			indent_puts(
-			"yy_current_state = yy_start_state_list[yy_start];" );
-		}
-
-	else
-		{
-		indent_puts( "yy_current_state = yy_start;" );
-
-		if ( bol_needed )
-			indent_puts( "yy_current_state += YY_AT_BOL();" );
-
-		if ( reject )
-			{
-			/* Set up for storing up states. */
-			indent_puts( "yy_state_ptr = yy_state_buf;" );
-			indent_puts( "*yy_state_ptr++ = yy_current_state;" );
-			}
-		}
-	}
-
-
-/* gentabs - generate data statements for the transition tables */
-
-void gentabs()
-	{
-	int i, j, k, *accset, nacc, *acc_array, total_states;
-	int end_of_buffer_action = num_rules + 1;
-
-	acc_array = allocate_integer_array( current_max_dfas );
-	nummt = 0;
-
-	/* The compressed table format jams by entering the "jam state",
-	 * losing information about the previous state in the process.
-	 * In order to recover the previous state, we effectively need
-	 * to keep backing-up information.
-	 */
-	++num_backing_up;
-
-	if ( reject )
-		{
-		/* Write out accepting list and pointer list.
-		 *
-		 * First we generate the "yy_acclist" array.  In the process,
-		 * we compute the indices that will go into the "yy_accept"
-		 * array, and save the indices in the dfaacc array.
-		 */
-		int EOB_accepting_list[2];
-
-		/* Set up accepting structures for the End Of Buffer state. */
-		EOB_accepting_list[0] = 0;
-		EOB_accepting_list[1] = end_of_buffer_action;
-		accsiz[end_of_buffer_state] = 1;
-		dfaacc[end_of_buffer_state].dfaacc_set = EOB_accepting_list;
-
-		out_str_dec( long_align ? C_long_decl : C_short_decl,
-			"yy_acclist", MAX( numas, 1 ) + 1 );
-
-		j = 1;	/* index into "yy_acclist" array */
-
-		for ( i = 1; i <= lastdfa; ++i )
-			{
-			acc_array[i] = j;
-
-			if ( accsiz[i] != 0 )
-				{
-				accset = dfaacc[i].dfaacc_set;
-				nacc = accsiz[i];
-
-				if ( trace )
-					fprintf( stderr,
-						_( "state # %d accepts: " ),
-						i );
-
-				for ( k = 1; k <= nacc; ++k )
-					{
-					int accnum = accset[k];
-
-					++j;
-
-					if ( variable_trailing_context_rules &&
-					  ! (accnum & YY_TRAILING_HEAD_MASK) &&
-					   accnum > 0 && accnum <= num_rules &&
-					  rule_type[accnum] == RULE_VARIABLE )
-						{
-						/* Special hack to flag
-						 * accepting number as part
-						 * of trailing context rule.
-						 */
-						accnum |= YY_TRAILING_MASK;
-						}
-
-					mkdata( accnum );
-
-					if ( trace )
-						{
-						fprintf( stderr, "[%d]",
-							accset[k] );
-
-						if ( k < nacc )
-							fputs( ", ", stderr );
-						else
-							putc( '\n', stderr );
-						}
-					}
-				}
-			}
-
-		/* add accepting number for the "jam" state */
-		acc_array[i] = j;
-
-		dataend();
-		}
-
-	else
-		{
-		dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
-
-		for ( i = 1; i <= lastdfa; ++i )
-			acc_array[i] = dfaacc[i].dfaacc_state;
-
-		/* add accepting number for jam state */
-		acc_array[i] = 0;
-		}
-
-	/* Spit out "yy_accept" array.  If we're doing "reject", it'll be
-	 * pointers into the "yy_acclist" array.  Otherwise it's actual
-	 * accepting numbers.  In either case, we just dump the numbers.
-	 */
-
-	/* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
-	 * beginning at 0 and for "jam" state.
-	 */
-	k = lastdfa + 2;
-
-	if ( reject )
-		/* We put a "cap" on the table associating lists of accepting
-		 * numbers with state numbers.  This is needed because we tell
-		 * where the end of an accepting list is by looking at where
-		 * the list for the next state starts.
-		 */
-		++k;
-
-	out_str_dec( long_align ? C_long_decl : C_short_decl, "yy_accept", k );
-
-	for ( i = 1; i <= lastdfa; ++i )
-		{
-		mkdata( acc_array[i] );
-
-		if ( ! reject && trace && acc_array[i] )
-			fprintf( stderr, _( "state # %d accepts: [%d]\n" ),
-				i, acc_array[i] );
-		}
-
-	/* Add entry for "jam" state. */
-	mkdata( acc_array[i] );
-
-	if ( reject )
-		/* Add "cap" for the list. */
-		mkdata( acc_array[i] );
-
-	dataend();
-
-	if ( useecs )
-		genecs();
-
-	if ( usemecs )
-		{
-		/* Write out meta-equivalence classes (used to index
-		 * templates with).
-		 */
-
-		if ( trace )
-			fputs( _( "\n\nMeta-Equivalence Classes:\n" ),
-			      stderr );
-
-		out_str_dec( C_int_decl, "yy_meta", numecs + 1 );
-
-		for ( i = 1; i <= numecs; ++i )
-			{
-			if ( trace )
-				fprintf( stderr, "%d = %d\n",
-					i, ABS( tecbck[i] ) );
-
-			mkdata( ABS( tecbck[i] ) );
-			}
-
-		dataend();
-		}
-
-	total_states = lastdfa + numtemps;
-
-	out_str_dec( (tblend >= MAX_SHORT || long_align) ?
-			C_long_decl : C_short_decl,
-		"yy_base", total_states + 1 );
-
-	for ( i = 1; i <= lastdfa; ++i )
-		{
-		int d = def[i];
-
-		if ( base[i] == JAMSTATE )
-			base[i] = jambase;
-
-		if ( d == JAMSTATE )
-			def[i] = jamstate;
-
-		else if ( d < 0 )
-			{
-			/* Template reference. */
-			++tmpuses;
-			def[i] = lastdfa - d + 1;
-			}
-
-		mkdata( base[i] );
-		}
-
-	/* Generate jam state's base index. */
-	mkdata( base[i] );
-
-	for ( ++i /* skip jam state */; i <= total_states; ++i )
-		{
-		mkdata( base[i] );
-		def[i] = jamstate;
-		}
-
-	dataend();
-
-	out_str_dec( (total_states >= MAX_SHORT || long_align) ?
-			C_long_decl : C_short_decl,
-		"yy_def", total_states + 1 );
-
-	for ( i = 1; i <= total_states; ++i )
-		mkdata( def[i] );
-
-	dataend();
-
-	out_str_dec( (total_states >= MAX_SHORT || long_align) ?
-			C_long_decl : C_short_decl,
-		"yy_nxt", tblend + 1 );
-
-	for ( i = 1; i <= tblend; ++i )
-		{
-		/* Note, the order of the following test is important.
-		 * If chk[i] is 0, then nxt[i] is undefined.
-		 */
-		if ( chk[i] == 0 || nxt[i] == 0 )
-			nxt[i] = jamstate;	/* new state is the JAM state */
-
-		mkdata( nxt[i] );
-		}
-
-	dataend();
-
-	out_str_dec( (total_states >= MAX_SHORT || long_align) ?
-			C_long_decl : C_short_decl,
-		"yy_chk", tblend + 1 );
-
-	for ( i = 1; i <= tblend; ++i )
-		{
-		if ( chk[i] == 0 )
-			++nummt;
-
-		mkdata( chk[i] );
-		}
-
-	dataend();
-	}
-
-
-/* Write out a formatted string (with a secondary string argument) at the
- * current indentation level, adding a final newline.
- */
-
-void indent_put2s( fmt, arg )
-char fmt[], arg[];
-	{
-	do_indent();
-	out_str( fmt, arg );
-	outn( "" );
-	}
-
-
-/* Write out a string at the current indentation level, adding a final
- * newline.
- */
-
-void indent_puts( str )
-char str[];
-	{
-	do_indent();
-	outn( str );
-	}
-
-
-/* make_tables - generate transition tables and finishes generating output file
- */
-
-void make_tables()
-	{
-	int i;
-	int did_eof_rule = false;
-
-	skelout();
-
-	/* First, take care of YY_DO_BEFORE_ACTION depending on yymore
-	 * being used.
-	 */
-	set_indent( 1 );
-
-	if ( yymore_used && ! yytext_is_array )
-		{
-		indent_puts( "yytext_ptr -= yy_more_len; \\" );
-		indent_puts( "yyleng = (int) (yy_cp - yytext_ptr); \\" );
-		}
-
-	else
-		indent_puts( "yyleng = (int) (yy_cp - yy_bp); \\" );
-
-	/* Now also deal with copying yytext_ptr to yytext if needed. */
-	skelout();
-	if ( yytext_is_array )
-		{
-		if ( yymore_used )
-			indent_puts(
-				"if ( yyleng + yy_more_offset >= YYLMAX ) \\" );
-		else
-			indent_puts( "if ( yyleng >= YYLMAX ) \\" );
-
-		indent_up();
-		indent_puts(
-		"YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" );
-		indent_down();
-
-		if ( yymore_used )
-			{
-			indent_puts(
-"yy_flex_strncpy( &yytext[yy_more_offset], yytext_ptr, yyleng + 1 ); \\" );
-			indent_puts( "yyleng += yy_more_offset; \\" );
-			indent_puts(
-				"yy_prev_more_offset = yy_more_offset; \\" );
-			indent_puts( "yy_more_offset = 0; \\" );
-			}
-		else
-			{
-			indent_puts(
-		"yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\" );
-			}
-		}
-
-	set_indent( 0 );
-
-	skelout();
-
-
-	out_dec( "#define YY_NUM_RULES %d\n", num_rules );
-	out_dec( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
-
-	if ( fullspd )
-		{
-		/* Need to define the transet type as a size large
-		 * enough to hold the biggest offset.
-		 */
-		int total_table_size = tblend + numecs + 1;
-		char *trans_offset_type =
-			(total_table_size >= MAX_SHORT || long_align) ?
-				"long" : "short";
-
-		set_indent( 0 );
-		indent_puts( "struct yy_trans_info" );
-		indent_up();
-		indent_puts( "{" ); 	/* } for vi */
-
-		if ( long_align )
-			indent_puts( "long yy_verify;" );
-		else
-			indent_puts( "short yy_verify;" );
-
-		/* In cases where its sister yy_verify *is* a "yes, there is
-		 * a transition", yy_nxt is the offset (in records) to the
-		 * next state.  In most cases where there is no transition,
-		 * the value of yy_nxt is irrelevant.  If yy_nxt is the -1th
-		 * record of a state, though, then yy_nxt is the action number
-		 * for that state.
-		 */
-
-		indent_put2s( "%s yy_nxt;", trans_offset_type );
-		indent_puts( "};" );
-		indent_down();
-		}
-
-	if ( fullspd )
-		genctbl();
-	else if ( fulltbl )
-		genftbl();
-	else
-		gentabs();
-
-	/* Definitions for backing up.  We don't need them if REJECT
-	 * is being used because then we use an alternative backin-up
-	 * technique instead.
-	 */
-	if ( num_backing_up > 0 && ! reject )
-		{
-		if ( ! C_plus_plus )
-			{
-			indent_puts(
-			"static yy_state_type yy_last_accepting_state;" );
-			indent_puts(
-				"static char *yy_last_accepting_cpos;\n" );
-			}
-		}
-
-	if ( nultrans )
-		{
-		out_str_dec( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
-
-		for ( i = 1; i <= lastdfa; ++i )
-			{
-			if ( fullspd )
-				out_dec( "    &yy_transition[%d],\n", base[i] );
-			else
-				mkdata( nultrans[i] );
-			}
-
-		dataend();
-		}
-
-	if ( ddebug )
-		{ /* Spit out table mapping rules to line numbers. */
-		if ( ! C_plus_plus )
-			{
-			indent_puts( "extern int yy_flex_debug;" );
-			indent_puts( "int yy_flex_debug = 1;\n" );
-			}
-
-		out_str_dec( long_align ? C_long_decl : C_short_decl,
-			"yy_rule_linenum", num_rules );
-		for ( i = 1; i < num_rules; ++i )
-			mkdata( rule_linenum[i] );
-		dataend();
-		}
-
-	if ( reject )
-		{
-		/* Declare state buffer variables. */
-		if ( ! C_plus_plus )
-			{
-			outn(
-	"static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
-			outn( "static char *yy_full_match;" );
-			outn( "static int yy_lp;" );
-			}
-
-		if ( variable_trailing_context_rules )
-			{
-			if ( ! C_plus_plus )
-				{
-				outn(
-				"static int yy_looking_for_trail_begin = 0;" );
-				outn( "static int yy_full_lp;" );
-				outn( "static int *yy_full_state;" );
-				}
-
-			out_hex( "#define YY_TRAILING_MASK 0x%x\n",
-				(unsigned int) YY_TRAILING_MASK );
-			out_hex( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
-				(unsigned int) YY_TRAILING_HEAD_MASK );
-			}
-
-		outn( "#define REJECT \\" );
-		outn( "{ \\" );		/* } for vi */
-		outn(
-	"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
-		outn(
-	"yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
-
-		if ( variable_trailing_context_rules )
-			{
-			outn(
-		"yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
-			outn(
-		"yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
-			outn(
-	"yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
-			}
-
-		outn( "++yy_lp; \\" );
-		outn( "goto find_rule; \\" );
-		/* { for vi */
-		outn( "}" );
-		}
-
-	else
-		{
-		outn(
-		"/* The intent behind this definition is that it'll catch" );
-		outn( " * any uses of REJECT which flex missed." );
-		outn( " */" );
-		outn( "#define REJECT reject_used_but_not_detected" );
-		}
-
-	if ( yymore_used )
-		{
-		if ( ! C_plus_plus )
-			{
-			if ( yytext_is_array )
-				{
-				indent_puts( "static int yy_more_offset = 0;" );
-				indent_puts(
-					"static int yy_prev_more_offset = 0;" );
-				}
-			else
-				{
-				indent_puts( "static int yy_more_flag = 0;" );
-				indent_puts( "static int yy_more_len = 0;" );
-				}
-			}
-
-		if ( yytext_is_array )
-			{
-			indent_puts(
-	"#define yymore() (yy_more_offset = yy_flex_strlen( yytext ))" );
-			indent_puts( "#define YY_NEED_STRLEN" );
-			indent_puts( "#define YY_MORE_ADJ 0" );
-			indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET \\" );
-			indent_up();
-			indent_puts( "{ \\" );
-			indent_puts( "yy_more_offset = yy_prev_more_offset; \\" );
-			indent_puts( "yyleng -= yy_more_offset; \\" );
-			indent_puts( "}" );
-			indent_down();
-			}
-		else
-			{
-			indent_puts( "#define yymore() (yy_more_flag = 1)" );
-			indent_puts( "#define YY_MORE_ADJ yy_more_len" );
-			indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
-			}
-		}
-
-	else
-		{
-		indent_puts( "#define yymore() yymore_used_but_not_detected" );
-		indent_puts( "#define YY_MORE_ADJ 0" );
-		indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
-		}
-
-	if ( ! C_plus_plus )
-		{
-		if ( yytext_is_array )
-			{
-			outn( "#ifndef YYLMAX" );
-			outn( "#define YYLMAX 8192" );
-			outn( "#endif\n" );
-			outn( "char yytext[YYLMAX];" );
-			outn( "char *yytext_ptr;" );
-			}
-
-		else
-			outn( "char *yytext;" );
-		}
-
-	out( &action_array[defs1_offset] );
-
-	line_directive_out( stdout, 0 );
-
-	skelout();
-
-	if ( ! C_plus_plus )
-		{
-		if ( use_read )
-			{
-			outn(
-"\tif ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\" );
-			outn(
-		"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
-			}
-
-		else
-			{
-			outn(
-			"\tif ( yy_current_buffer->yy_is_interactive ) \\" );
-			outn( "\t\t{ \\" );
-			outn( "\t\tint c = '*', n; \\" );
-			outn( "\t\tfor ( n = 0; n < max_size && \\" );
-	outn( "\t\t\t     (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\" );
-			outn( "\t\t\tbuf[n] = (char) c; \\" );
-			outn( "\t\tif ( c == '\\n' ) \\" );
-			outn( "\t\t\tbuf[n++] = (char) c; \\" );
-			outn( "\t\tif ( c == EOF && ferror( yyin ) ) \\" );
-			outn(
-	"\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\" );
-			outn( "\t\tresult = n; \\" );
-			outn( "\t\t} \\" );
-			outn(
-	"\telse if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \\" );
-			outn( "\t\t  && ferror( yyin ) ) \\" );
-			outn(
-		"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
-			}
-		}
-
-	skelout();
-
-	indent_puts( "#define YY_RULE_SETUP \\" );
-	indent_up();
-	if ( bol_needed )
-		{
-		indent_puts( "if ( yyleng > 0 ) \\" );
-		indent_up();
-		indent_puts( "yy_current_buffer->yy_at_bol = \\" );
-		indent_puts( "\t\t(yytext[yyleng - 1] == '\\n'); \\" );
-		indent_down();
-		}
-	indent_puts( "YY_USER_ACTION" );
-	indent_down();
-
-	skelout();
-
-	/* Copy prolog to output file. */
-	out( &action_array[prolog_offset] );
-
-	line_directive_out( stdout, 0 );
-
-	skelout();
-
-	set_indent( 2 );
-
-	if ( yymore_used && ! yytext_is_array )
-		{
-		indent_puts( "yy_more_len = 0;" );
-		indent_puts( "if ( yy_more_flag )" );
-		indent_up();
-		indent_puts( "{" );
-		indent_puts( "yy_more_len = yy_c_buf_p - yytext_ptr;" );
-		indent_puts( "yy_more_flag = 0;" );
-		indent_puts( "}" );
-		indent_down();
-		}
-
-	skelout();
-
-	gen_start_state();
-
-	/* Note, don't use any indentation. */
-	outn( "yy_match:" );
-	gen_next_match();
-
-	skelout();
-	set_indent( 2 );
-	gen_find_action();
-
-	skelout();
-	if ( do_yylineno )
-		{
-		indent_puts( "if ( yy_act != YY_END_OF_BUFFER )" );
-		indent_up();
-		indent_puts( "{" );
-		indent_puts( "int yyl;" );
-		indent_puts( "for ( yyl = 0; yyl < yyleng; ++yyl )" );
-		indent_up();
-		indent_puts( "if ( yytext[yyl] == '\\n' )" );
-		indent_up();
-		indent_puts( "++yylineno;" );
-		indent_down();
-		indent_down();
-		indent_puts( "}" );
-		indent_down();
-		}
-
-	skelout();
-	if ( ddebug )
-		{
-		indent_puts( "if ( yy_flex_debug )" );
-		indent_up();
-
-		indent_puts( "{" );
-		indent_puts( "if ( yy_act == 0 )" );
-		indent_up();
-		indent_puts( C_plus_plus ?
-			"cerr << \"--scanner backing up\\n\";" :
-			"fprintf( stderr, \"--scanner backing up\\n\" );" );
-		indent_down();
-
-		do_indent();
-		out_dec( "else if ( yy_act < %d )\n", num_rules );
-		indent_up();
-
-		if ( C_plus_plus )
-			{
-			indent_puts(
-	"cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<" );
-			indent_puts(
-			"         \"(\\\"\" << yytext << \"\\\")\\n\";" );
-			}
-		else
-			{
-			indent_puts(
-	"fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
-
-			indent_puts(
-				"         yy_rule_linenum[yy_act], yytext );" );
-			}
-
-		indent_down();
-
-		do_indent();
-		out_dec( "else if ( yy_act == %d )\n", num_rules );
-		indent_up();
-
-		if ( C_plus_plus )
-			{
-			indent_puts(
-"cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";" );
-			}
-		else
-			{
-			indent_puts(
-	"fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
-			indent_puts( "         yytext );" );
-			}
-
-		indent_down();
-
-		do_indent();
-		out_dec( "else if ( yy_act == %d )\n", num_rules + 1 );
-		indent_up();
-
-		indent_puts( C_plus_plus ?
-			"cerr << \"--(end of buffer or a NUL)\\n\";" :
-		"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
-
-		indent_down();
-
-		do_indent();
-		outn( "else" );
-		indent_up();
-
-		if ( C_plus_plus )
-			{
-			indent_puts(
-	"cerr << \"--EOF (start condition \" << YY_START << \")\\n\";" );
-			}
-		else
-			{
-			indent_puts(
-	"fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );" );
-			}
-
-		indent_down();
-
-		indent_puts( "}" );
-		indent_down();
-		}
-
-	/* Copy actions to output file. */
-	skelout();
-	indent_up();
-	gen_bu_action();
-	out( &action_array[action_offset] );
-
-	line_directive_out( stdout, 0 );
-
-	/* generate cases for any missing EOF rules */
-	for ( i = 1; i <= lastsc; ++i )
-		if ( ! sceof[i] )
-			{
-			do_indent();
-			out_str( "case YY_STATE_EOF(%s):\n", scname[i] );
-			did_eof_rule = true;
-			}
-
-	if ( did_eof_rule )
-		{
-		indent_up();
-		indent_puts( "yyterminate();" );
-		indent_down();
-		}
-
-
-	/* Generate code for handling NUL's, if needed. */
-
-	/* First, deal with backing up and setting up yy_cp if the scanner
-	 * finds that it should JAM on the NUL.
-	 */
-	skelout();
-	set_indent( 4 );
-
-	if ( fullspd || fulltbl )
-		indent_puts( "yy_cp = yy_c_buf_p;" );
-
-	else
-		{ /* compressed table */
-		if ( ! reject && ! interactive )
-			{
-			/* Do the guaranteed-needed backing up to figure
-			 * out the match.
-			 */
-			indent_puts( "yy_cp = yy_last_accepting_cpos;" );
-			indent_puts(
-				"yy_current_state = yy_last_accepting_state;" );
-			}
-
-		else
-			/* Still need to initialize yy_cp, though
-			 * yy_current_state was set up by
-			 * yy_get_previous_state().
-			 */
-			indent_puts( "yy_cp = yy_c_buf_p;" );
-		}
-
-
-	/* Generate code for yy_get_previous_state(). */
-	set_indent( 1 );
-	skelout();
-
-	gen_start_state();
-
-	set_indent( 2 );
-	skelout();
-	gen_next_state( true );
-
-	set_indent( 1 );
-	skelout();
-	gen_NUL_trans();
-
-	skelout();
-	if ( do_yylineno )
-		{ /* update yylineno inside of unput() */
-		indent_puts( "if ( c == '\\n' )" );
-		indent_up();
-		indent_puts( "--yylineno;" );
-		indent_down();
-		}
-
-	skelout();
-	/* Update BOL and yylineno inside of input(). */
-	if ( bol_needed )
-		{
-		indent_puts( "yy_current_buffer->yy_at_bol = (c == '\\n');" );
-		if ( do_yylineno )
-			{
-			indent_puts( "if ( yy_current_buffer->yy_at_bol )" );
-			indent_up();
-			indent_puts( "++yylineno;" );
-			indent_down();
-			}
-		}
-
-	else if ( do_yylineno )
-		{
-		indent_puts( "if ( c == '\\n' )" );
-		indent_up();
-		indent_puts( "++yylineno;" );
-		indent_down();
-		}
-
-	skelout();
-
-	/* Copy remainder of input to output. */
-
-	line_directive_out( stdout, 1 );
-
-	if ( sectnum == 3 )
-		(void) flexscan(); /* copy remainder of input to output */
-	}
diff --git a/usr.bin/lex/initparse.c b/usr.bin/lex/initparse.c
new file mode 100644
index 000000000000..e9c287880b04
--- /dev/null
+++ b/usr.bin/lex/initparse.c
@@ -0,0 +1,1849 @@
+/* $FreeBSD$ */
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 35 "parse.y"
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
+
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  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. */
+
+#include "flexdef.h"
+#include "tables.h"
+
+int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen;
+int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
+
+int *scon_stk;
+int scon_stk_ptr;
+
+static int madeany = false;  /* whether we've made the '.' character class */
+static int ccldot, cclany;
+int previous_continued_action;	/* whether the previous rule's action was '|' */
+
+#define format_warn3(fmt, a1, a2) \
+	do{ \
+        char fw3_msg[MAXLINE];\
+        snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
+        warn( fw3_msg );\
+	}while(0)
+
+/* Expand a POSIX character class expression. */
+#define CCL_EXPR(func) \
+	do{ \
+	int c; \
+	for ( c = 0; c < csize; ++c ) \
+		if ( isascii(c) && func(c) ) \
+			ccladd( currccl, c ); \
+	}while(0)
+
+/* negated class */
+#define CCL_NEG_EXPR(func) \
+	do{ \
+	int c; \
+	for ( c = 0; c < csize; ++c ) \
+		if ( !func(c) ) \
+			ccladd( currccl, c ); \
+	}while(0)
+
+/* While POSIX defines isblank(), it's not ANSI C. */
+#define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
+
+/* On some over-ambitious machines, such as DEC Alpha's, the default
+ * token type is "long" instead of "int"; this leads to problems with
+ * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
+ * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
+ * following should ensure that the default token type is "int".
+ */
+#define YYSTYPE int
+
+#line 99 "parse.c"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define CHAR 257
+#define NUMBER 258
+#define SECTEND 259
+#define SCDECL 260
+#define XSCDECL 261
+#define NAME 262
+#define PREVCCL 263
+#define EOF_OP 264
+#define OPTION_OP 265
+#define OPT_OUTFILE 266
+#define OPT_PREFIX 267
+#define OPT_YYCLASS 268
+#define OPT_HEADER 269
+#define OPT_EXTRA_TYPE 270
+#define OPT_TABLES 271
+#define CCE_ALNUM 272
+#define CCE_ALPHA 273
+#define CCE_BLANK 274
+#define CCE_CNTRL 275
+#define CCE_DIGIT 276
+#define CCE_GRAPH 277
+#define CCE_LOWER 278
+#define CCE_PRINT 279
+#define CCE_PUNCT 280
+#define CCE_SPACE 281
+#define CCE_UPPER 282
+#define CCE_XDIGIT 283
+#define CCE_NEG_ALNUM 284
+#define CCE_NEG_ALPHA 285
+#define CCE_NEG_BLANK 286
+#define CCE_NEG_CNTRL 287
+#define CCE_NEG_DIGIT 288
+#define CCE_NEG_GRAPH 289
+#define CCE_NEG_LOWER 290
+#define CCE_NEG_PRINT 291
+#define CCE_NEG_PUNCT 292
+#define CCE_NEG_SPACE 293
+#define CCE_NEG_UPPER 294
+#define CCE_NEG_XDIGIT 295
+#define CCL_OP_DIFF 296
+#define CCL_OP_UNION 297
+#define BEGIN_REPEAT_POSIX 298
+#define END_REPEAT_POSIX 299
+#define BEGIN_REPEAT_FLEX 300
+#define END_REPEAT_FLEX 301
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
+    7,    7,    8,    9,    9,   10,   10,   10,   10,   10,
+   10,    4,    4,    4,    5,   12,   12,   12,   12,   14,
+   11,   11,   11,   15,   15,   15,   16,   13,   13,   13,
+   13,   18,   18,   17,   19,   19,   19,   19,   19,   20,
+   20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+   20,   21,   21,   21,   23,   23,   24,   24,   24,   24,
+   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+   25,   25,   25,   25,   22,   22,
+};
+static const short yylen[] = {                            2,
+    5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
+    1,    1,    2,    2,    0,    3,    3,    3,    3,    3,
+    3,    5,    5,    0,    0,    2,    1,    1,    1,    0,
+    4,    3,    0,    3,    1,    1,    1,    2,    3,    2,
+    1,    3,    1,    2,    2,    1,    6,    5,    4,    2,
+    2,    2,    6,    5,    4,    1,    1,    1,    3,    3,
+    1,    3,    3,    1,    3,    4,    4,    2,    2,    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,    2,    0,
+};
+static const short yydefred[] = {                         2,
+    0,    0,    6,    0,    7,    8,    9,   15,   24,    0,
+    4,    0,    0,   12,   11,    0,    0,    0,    0,    0,
+    0,    0,   14,    0,    1,    0,   10,    0,    0,    0,
+    0,    0,    0,    0,    0,   24,    0,   16,   18,   19,
+   20,   17,   21,   32,   36,   37,    0,   35,    0,   29,
+   61,   58,   28,    0,   56,   96,    0,    0,    0,   27,
+    0,    0,    0,    0,    0,   64,   31,    0,   23,   26,
+    0,    0,   70,    0,   22,    0,   40,    0,   44,    0,
+    0,    0,   50,   51,   52,    0,    0,   34,   95,   59,
+   60,    0,    0,   71,   72,   73,   74,   75,   76,   77,
+   78,   79,   80,   82,   81,   83,   84,   85,   86,   87,
+   88,   93,   89,   90,   91,   94,   92,   65,   69,   39,
+    0,    0,    0,   62,   63,   66,    0,   49,    0,   55,
+    0,   67,    0,   48,    0,   54,   47,   53,
+};
+static const short yydgoto[] = {                          1,
+    2,    4,    9,   13,   25,   10,   16,   11,   12,   23,
+   26,   59,   60,   35,   47,   48,   61,   62,   63,   64,
+   65,   71,   66,   74,  119,
+};
+static const short yysindex[] = {                         0,
+    0, -222,    0, -155,    0,    0,    0,    0,    0, -215,
+    0, -123,    6,    0,    0, -193,   10,   21,   26,   31,
+   35,   37,    0,   59,    0,  -44,    0, -147, -145, -140,
+ -133, -132, -129,   75, -214,    0,  -19,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   23,    0,  -48,    0,
+    0,    0,    0,  -17,    0,    0,  -17,   27,  128,    0,
+  -17,   -1,  -30,  -41, -189,    0,    0, -121,    0,    0,
+  -31,  -34,    0,  -87,    0,  -25,    0,  -17,    0, -109,
+  -41, -108,    0,    0,    0,   60,   60,    0,    0,    0,
+    0,   46,  107,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+  -30,  -36,  -39,    0,    0,    0, -104,    0, -219,    0,
+ -238,    0, -144,    0, -143,    0,    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0, -141,    0,    0,    0,    0,    0,    0,    0,    0,
+    0, -134,    9,    0,    0, -125,    0,    0,    0,    0,
+    0,    0,    0, -178,    0,   22,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  -21,    0,
+    0,    0,    0,    0,    0,    0,    0,   85,    0,    0,
+    0,  144,   47,    4,  -10,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  146,    0,    0,    0,    0,
+   18,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,  124,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   50,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,
+};
+static const short yygindex[] = {                         0,
+    0,    0,    0,  121,  133,    0,    0,    0,    0,    0,
+    0,    0,  106,    0,    0,   93,    0,   32,   84,  -45,
+    0,    0,   25,   90,    0,
+};
+#define YYTABLESIZE 419
+static const short yytable[] = {                         57,
+   83,   84,   90,   56,  131,  118,   91,  129,   25,   57,
+  120,   24,   33,   46,   56,   55,   56,   81,   33,  135,
+   57,   85,   57,   57,   33,   57,   55,   45,   55,   57,
+   57,   57,   57,    3,   77,   57,   57,   46,  133,   46,
+   14,   45,   33,   46,   46,   79,   15,   46,   33,   46,
+   46,   45,   57,   45,   33,   25,   43,   45,   45,   42,
+   58,   25,  136,   45,   45,   24,   68,   25,   27,   33,
+   28,   58,   33,   58,   54,   81,   69,   30,   36,  134,
+   57,   29,   43,   30,   67,   42,   30,   43,   72,   78,
+   42,   31,   76,   43,   46,   32,   42,   33,   78,   33,
+   34,   33,   33,    5,    6,    7,   86,   87,   45,    8,
+  124,  125,   25,   57,   38,   25,   39,    5,    5,    5,
+   73,   40,   78,    5,   13,   13,   13,   46,   41,   42,
+   13,   33,   43,    3,    3,    3,   44,   75,  126,    3,
+   46,   45,   17,   18,   19,   20,   21,   22,  122,  123,
+   58,  127,  132,   41,  137,   38,   49,  138,   37,   70,
+   88,  121,   92,    0,    0,    0,    0,    0,    0,   93,
+   43,    0,    0,   42,    0,    0,    0,   70,    0,    0,
+    0,    0,    0,    0,   94,   95,   96,   97,   98,   99,
+  100,  101,  102,  103,  104,  105,  106,  107,  108,  109,
+  110,  111,  112,  113,  114,  115,  116,  117,    0,    0,
+    0,    0,    0,    0,    0,    0,   68,    0,    0,    0,
+    0,    0,    0,    0,    0,   89,   51,    0,    0,    0,
+    0,    0,   52,    0,   33,   33,   50,   51,    0,   51,
+    0,   33,   33,   52,   53,   52,   57,    0,    0,    0,
+    0,    0,   57,    0,    0,    0,    0,    0,   82,    0,
+   46,  130,  128,    0,   33,   33,   46,   80,    0,    0,
+    0,   33,   33,    0,   45,    0,    0,   25,   25,    0,
+   45,    0,    0,    0,   25,   25,    0,   57,    0,   57,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   46,   93,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   45,    0,   94,   95,   96,
+   97,   98,   99,  100,  101,  102,  103,  104,  105,  106,
+  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,
+  117,   70,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   70,   70,   70,   70,
+   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
+   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
+   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   68,   68,   68,   68,   68,
+   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+   68,   68,   68,   68,   68,   68,   68,   68,   68,
+};
+static const short yycheck[] = {                         10,
+   42,   43,   34,   34,   44,   93,   41,   44,    0,   40,
+   36,   60,   34,   10,   34,   46,   34,   63,   40,  258,
+   40,   63,   40,   34,   46,   36,   46,   10,   46,   40,
+   41,   42,   43,  256,   36,   46,   47,   34,  258,   36,
+  256,  256,   34,   40,   41,   47,  262,  262,   40,   46,
+   47,   34,   63,   36,   46,   34,   10,   40,   41,   10,
+   91,   40,  301,   46,   47,   60,   44,   46,  262,   91,
+   61,   91,   94,   91,   94,  121,  125,  256,  123,  299,
+   91,   61,   36,  262,   62,   36,   61,   41,   57,  124,
+   41,   61,   61,   47,   91,   61,   47,   61,  124,   91,
+   42,  123,   94,  259,  260,  261,  296,  297,   91,  265,
+   86,   87,   91,  124,  262,   94,  262,  259,  260,  261,
+   94,  262,  124,  265,  259,  260,  261,  124,  262,  262,
+  265,  123,  262,  259,  260,  261,   62,   10,   93,  265,
+  262,  124,  266,  267,  268,  269,  270,  271,  258,  258,
+   91,   45,  257,   10,  299,   10,   36,  301,   26,   54,
+   68,   78,   73,   -1,   -1,   -1,   -1,   -1,   -1,  257,
+  124,   -1,   -1,  124,   -1,   -1,   -1,   93,   -1,   -1,
+   -1,   -1,   -1,   -1,  272,  273,  274,  275,  276,  277,
+  278,  279,  280,  281,  282,  283,  284,  285,  286,  287,
+  288,  289,  290,  291,  292,  293,  294,  295,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   93,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  257,  257,   -1,   -1,   -1,
+   -1,   -1,  263,   -1,  256,  257,  256,  257,   -1,  257,
+   -1,  263,  264,  263,  264,  263,  257,   -1,   -1,   -1,
+   -1,   -1,  263,   -1,   -1,   -1,   -1,   -1,  300,   -1,
+  257,  301,  299,   -1,  256,  257,  263,  298,   -1,   -1,
+   -1,  263,  264,   -1,  257,   -1,   -1,  256,  257,   -1,
+  263,   -1,   -1,   -1,  263,  264,   -1,  298,   -1,  300,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  298,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  298,   -1,  272,  273,  274,
+  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
+  285,  286,  287,  288,  289,  290,  291,  292,  293,  294,
+  295,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  272,  273,  274,  275,
+  276,  277,  278,  279,  280,  281,  282,  283,  284,  285,
+  286,  287,  288,  289,  290,  291,  292,  293,  294,  295,
+  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  272,  273,  274,  275,  276,
+  277,  278,  279,  280,  281,  282,  283,  284,  285,  286,
+  287,  288,  289,  290,  291,  292,  293,  294,  295,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 301
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
+0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
+"SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
+"OPT_PREFIX","OPT_YYCLASS","OPT_HEADER","OPT_EXTRA_TYPE","OPT_TABLES",
+"CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL","CCE_DIGIT","CCE_GRAPH",
+"CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE","CCE_UPPER","CCE_XDIGIT",
+"CCE_NEG_ALNUM","CCE_NEG_ALPHA","CCE_NEG_BLANK","CCE_NEG_CNTRL","CCE_NEG_DIGIT",
+"CCE_NEG_GRAPH","CCE_NEG_LOWER","CCE_NEG_PRINT","CCE_NEG_PUNCT","CCE_NEG_SPACE",
+"CCE_NEG_UPPER","CCE_NEG_XDIGIT","CCL_OP_DIFF","CCL_OP_UNION",
+"BEGIN_REPEAT_POSIX","END_REPEAT_POSIX","BEGIN_REPEAT_FLEX","END_REPEAT_FLEX",
+};
+static const char *yyrule[] = {
+"$accept : goal",
+"goal : initlex sect1 sect1end sect2 initforrule",
+"initlex :",
+"sect1 : sect1 startconddecl namelist1",
+"sect1 : sect1 options",
+"sect1 :",
+"sect1 : error",
+"sect1end : SECTEND",
+"startconddecl : SCDECL",
+"startconddecl : XSCDECL",
+"namelist1 : namelist1 NAME",
+"namelist1 : NAME",
+"namelist1 : error",
+"options : OPTION_OP optionlist",
+"optionlist : optionlist option",
+"optionlist :",
+"option : OPT_OUTFILE '=' NAME",
+"option : OPT_EXTRA_TYPE '=' NAME",
+"option : OPT_PREFIX '=' NAME",
+"option : OPT_YYCLASS '=' NAME",
+"option : OPT_HEADER '=' NAME",
+"option : OPT_TABLES '=' NAME",
+"sect2 : sect2 scon initforrule flexrule '\\n'",
+"sect2 : sect2 scon '{' sect2 '}'",
+"sect2 :",
+"initforrule :",
+"flexrule : '^' rule",
+"flexrule : rule",
+"flexrule : EOF_OP",
+"flexrule : error",
+"scon_stk_ptr :",
+"scon : '<' scon_stk_ptr namelist2 '>'",
+"scon : '<' '*' '>'",
+"scon :",
+"namelist2 : namelist2 ',' sconname",
+"namelist2 : sconname",
+"namelist2 : error",
+"sconname : NAME",
+"rule : re2 re",
+"rule : re2 re '$'",
+"rule : re '$'",
+"rule : re",
+"re : re '|' series",
+"re : series",
+"re2 : re '/'",
+"series : series singleton",
+"series : singleton",
+"series : series BEGIN_REPEAT_POSIX NUMBER ',' NUMBER END_REPEAT_POSIX",
+"series : series BEGIN_REPEAT_POSIX NUMBER ',' END_REPEAT_POSIX",
+"series : series BEGIN_REPEAT_POSIX NUMBER END_REPEAT_POSIX",
+"singleton : singleton '*'",
+"singleton : singleton '+'",
+"singleton : singleton '?'",
+"singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' NUMBER END_REPEAT_FLEX",
+"singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' END_REPEAT_FLEX",
+"singleton : singleton BEGIN_REPEAT_FLEX NUMBER END_REPEAT_FLEX",
+"singleton : '.'",
+"singleton : fullccl",
+"singleton : PREVCCL",
+"singleton : '\"' string '\"'",
+"singleton : '(' re ')'",
+"singleton : CHAR",
+"fullccl : fullccl CCL_OP_DIFF braceccl",
+"fullccl : fullccl CCL_OP_UNION braceccl",
+"fullccl : braceccl",
+"braceccl : '[' ccl ']'",
+"braceccl : '[' '^' ccl ']'",
+"ccl : ccl CHAR '-' CHAR",
+"ccl : ccl CHAR",
+"ccl : ccl ccl_expr",
+"ccl :",
+"ccl_expr : CCE_ALNUM",
+"ccl_expr : CCE_ALPHA",
+"ccl_expr : CCE_BLANK",
+"ccl_expr : CCE_CNTRL",
+"ccl_expr : CCE_DIGIT",
+"ccl_expr : CCE_GRAPH",
+"ccl_expr : CCE_LOWER",
+"ccl_expr : CCE_PRINT",
+"ccl_expr : CCE_PUNCT",
+"ccl_expr : CCE_SPACE",
+"ccl_expr : CCE_XDIGIT",
+"ccl_expr : CCE_UPPER",
+"ccl_expr : CCE_NEG_ALNUM",
+"ccl_expr : CCE_NEG_ALPHA",
+"ccl_expr : CCE_NEG_BLANK",
+"ccl_expr : CCE_NEG_CNTRL",
+"ccl_expr : CCE_NEG_DIGIT",
+"ccl_expr : CCE_NEG_GRAPH",
+"ccl_expr : CCE_NEG_PRINT",
+"ccl_expr : CCE_NEG_PUNCT",
+"ccl_expr : CCE_NEG_SPACE",
+"ccl_expr : CCE_NEG_XDIGIT",
+"ccl_expr : CCE_NEG_LOWER",
+"ccl_expr : CCE_NEG_UPPER",
+"string : string CHAR",
+"string :",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#ifdef YYSTACKSIZE
+#undef YYMAXDEPTH
+#define YYMAXDEPTH  YYSTACKSIZE
+#else
+#ifdef YYMAXDEPTH
+#define YYSTACKSIZE YYMAXDEPTH
+#else
+#define YYSTACKSIZE 500
+#define YYMAXDEPTH  500
+#endif
+#endif
+
+#define YYINITSTACKSIZE 500
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 948 "parse.y"
+
+
+/* build_eof_action - build the "<<EOF>>" action for the active start
+ *                    conditions
+ */
+
+void build_eof_action()
+	{
+	int i;
+	char action_text[MAXLINE];
+
+	for ( i = 1; i <= scon_stk_ptr; ++i )
+		{
+		if ( sceof[scon_stk[i]] )
+			format_pinpoint_message(
+				"multiple <<EOF>> rules for start condition %s",
+				scname[scon_stk[i]] );
+
+		else
+			{
+			sceof[scon_stk[i]] = true;
+
+			if (previous_continued_action /* && previous action was regular */)
+				add_action("YY_RULE_SETUP\n");
+
+			snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n",
+				scname[scon_stk[i]] );
+			add_action( action_text );
+			}
+		}
+
+	line_directive_out( (FILE *) 0, 1 );
+
+	/* This isn't a normal rule after all - don't count it as
+	 * such, so we don't have any holes in the rule numbering
+	 * (which make generating "rule can never match" warnings
+	 * more difficult.
+	 */
+	--num_rules;
+	++num_eof_rules;
+	}
+
+
+/* format_synerr - write out formatted syntax error */
+
+void format_synerr( msg, arg )
+const char *msg, arg[];
+	{
+	char errmsg[MAXLINE];
+
+	(void) snprintf( errmsg, sizeof(errmsg), msg, arg );
+	synerr( errmsg );
+	}
+
+
+/* synerr - report a syntax error */
+
+void synerr( str )
+const char *str;
+	{
+	syntaxerror = true;
+	pinpoint_message( str );
+	}
+
+
+/* format_warn - write out formatted warning */
+
+void format_warn( msg, arg )
+const char *msg, arg[];
+	{
+	char warn_msg[MAXLINE];
+
+	snprintf( warn_msg, sizeof(warn_msg), msg, arg );
+	warn( warn_msg );
+	}
+
+
+/* warn - report a warning, unless -w was given */
+
+void warn( str )
+const char *str;
+	{
+	line_warning( str, linenum );
+	}
+
+/* format_pinpoint_message - write out a message formatted with one string,
+ *			     pinpointing its location
+ */
+
+void format_pinpoint_message( msg, arg )
+const char *msg, arg[];
+	{
+	char errmsg[MAXLINE];
+
+	snprintf( errmsg, sizeof(errmsg), msg, arg );
+	pinpoint_message( errmsg );
+	}
+
+
+/* pinpoint_message - write out a message, pinpointing its location */
+
+void pinpoint_message( str )
+const char *str;
+	{
+	line_pinpoint( str, linenum );
+	}
+
+
+/* line_warning - report a warning at a given line, unless -w was given */
+
+void line_warning( str, line )
+const char *str;
+int line;
+	{
+	char warning[MAXLINE];
+
+	if ( ! nowarn )
+		{
+		snprintf( warning, sizeof(warning), "warning, %s", str );
+		line_pinpoint( warning, line );
+		}
+	}
+
+
+/* line_pinpoint - write out a message, pinpointing it at the given line */
+
+void line_pinpoint( str, line )
+const char *str;
+int line;
+	{
+	fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
+	}
+
+
+/* yyerror - eat up an error message from the parser;
+ *	     currently, messages are ignore
+ */
+
+void yyerror( msg )
+const char *msg;
+	{
+	}
+#line 656 "parse.c"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = data->s_mark - data->s_base;
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = 0;
+            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+            if (!yys) yys = "illegal-symbol";
+            printf("%sdebug: state %d, reading %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+    }
+    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
+    {
+#if YYDEBUG
+        if (yydebug)
+            printf("%sdebug: state %d, shifting to state %d\n",
+                    YYPREFIX, yystate, yytable[yyn]);
+#endif
+        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        if (yyerrflag > 0)  --yyerrflag;
+        goto yyloop;
+    }
+    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
+    {
+        yyn = yytable[yyn];
+        goto yyreduce;
+    }
+    if (yyerrflag) goto yyinrecovery;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = 0;
+            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+            if (!yys) yys = "illegal-symbol";
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        goto yyloop;
+    }
+
+yyreduce:
+#if YYDEBUG
+    if (yydebug)
+        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
+                YYPREFIX, yystate, yyn, yyrule[yyn]);
+#endif
+    yym = yylen[yyn];
+    if (yym)
+        yyval = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 1:
+#line 119 "parse.y"
+	{ /* add default rule */
+			int def_rule;
+
+			pat = cclinit();
+			cclnegate( pat );
+
+			def_rule = mkstate( -pat );
+
+			/* Remember the number of the default rule so we
+			 * don't generate "can't match" warnings for it.
+			 */
+			default_rule = num_rules;
+
+			finish_rule( def_rule, false, 0, 0, 0);
+
+			for ( i = 1; i <= lastsc; ++i )
+				scset[i] = mkbranch( scset[i], def_rule );
+
+			if ( spprdflt )
+				add_action(
+				"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
+			else
+				add_action( "ECHO" );
+
+			add_action( ";\n\tYY_BREAK\n" );
+			}
+break;
+case 2:
+#line 148 "parse.y"
+	{ /* initialize for processing rules */
+
+			/* Create default DFA start condition. */
+			scinstal( "INITIAL", false );
+			}
+break;
+case 6:
+#line 159 "parse.y"
+	{ synerr( _("unknown error processing section 1") ); }
+break;
+case 7:
+#line 163 "parse.y"
+	{
+			check_options();
+			scon_stk = allocate_integer_array( lastsc + 1 );
+			scon_stk_ptr = 0;
+			}
+break;
+case 8:
+#line 171 "parse.y"
+	{ xcluflg = false; }
+break;
+case 9:
+#line 174 "parse.y"
+	{ xcluflg = true; }
+break;
+case 10:
+#line 178 "parse.y"
+	{ scinstal( nmstr, xcluflg ); }
+break;
+case 11:
+#line 181 "parse.y"
+	{ scinstal( nmstr, xcluflg ); }
+break;
+case 12:
+#line 184 "parse.y"
+	{ synerr( _("bad start condition list") ); }
+break;
+case 16:
+#line 195 "parse.y"
+	{
+			outfilename = copy_string( nmstr );
+			did_outfilename = 1;
+			}
+break;
+case 17:
+#line 200 "parse.y"
+	{ extra_type = copy_string( nmstr ); }
+break;
+case 18:
+#line 202 "parse.y"
+	{ prefix = copy_string( nmstr ); }
+break;
+case 19:
+#line 204 "parse.y"
+	{ yyclass = copy_string( nmstr ); }
+break;
+case 20:
+#line 206 "parse.y"
+	{ headerfilename = copy_string( nmstr ); }
+break;
+case 21:
+#line 208 "parse.y"
+	{ tablesext = true; tablesfilename = copy_string( nmstr ); }
+break;
+case 22:
+#line 212 "parse.y"
+	{ scon_stk_ptr = yystack.l_mark[-3]; }
+break;
+case 23:
+#line 214 "parse.y"
+	{ scon_stk_ptr = yystack.l_mark[-3]; }
+break;
+case 25:
+#line 219 "parse.y"
+	{
+			/* Initialize for a parse of one rule. */
+			trlcontxt = variable_trail_rule = varlength = false;
+			trailcnt = headcnt = rulelen = 0;
+			current_state_type = STATE_NORMAL;
+			previous_continued_action = continued_action;
+			in_rule = true;
+
+			new_rule();
+			}
+break;
+case 26:
+#line 232 "parse.y"
+	{
+			pat = yystack.l_mark[0];
+			finish_rule( pat, variable_trail_rule,
+				headcnt, trailcnt , previous_continued_action);
+
+			if ( scon_stk_ptr > 0 )
+				{
+				for ( i = 1; i <= scon_stk_ptr; ++i )
+					scbol[scon_stk[i]] =
+						mkbranch( scbol[scon_stk[i]],
+								pat );
+				}
+
+			else
+				{
+				/* Add to all non-exclusive start conditions,
+				 * including the default (0) start condition.
+				 */
+
+				for ( i = 1; i <= lastsc; ++i )
+					if ( ! scxclu[i] )
+						scbol[i] = mkbranch( scbol[i],
+									pat );
+				}
+
+			if ( ! bol_needed )
+				{
+				bol_needed = true;
+
+				if ( performance_report > 1 )
+					pinpoint_message(
+			"'^' operator results in sub-optimal performance" );
+				}
+			}
+break;
+case 27:
+#line 268 "parse.y"
+	{
+			pat = yystack.l_mark[0];
+			finish_rule( pat, variable_trail_rule,
+				headcnt, trailcnt , previous_continued_action);
+
+			if ( scon_stk_ptr > 0 )
+				{
+				for ( i = 1; i <= scon_stk_ptr; ++i )
+					scset[scon_stk[i]] =
+						mkbranch( scset[scon_stk[i]],
+								pat );
+				}
+
+			else
+				{
+				for ( i = 1; i <= lastsc; ++i )
+					if ( ! scxclu[i] )
+						scset[i] =
+							mkbranch( scset[i],
+								pat );
+				}
+			}
+break;
+case 28:
+#line 292 "parse.y"
+	{
+			if ( scon_stk_ptr > 0 )
+				build_eof_action();
+	
+			else
+				{
+				/* This EOF applies to all start conditions
+				 * which don't already have EOF actions.
+				 */
+				for ( i = 1; i <= lastsc; ++i )
+					if ( ! sceof[i] )
+						scon_stk[++scon_stk_ptr] = i;
+
+				if ( scon_stk_ptr == 0 )
+					warn(
+			"all start conditions already have <<EOF>> rules" );
+
+				else
+					build_eof_action();
+				}
+			}
+break;
+case 29:
+#line 315 "parse.y"
+	{ synerr( _("unrecognized rule") ); }
+break;
+case 30:
+#line 319 "parse.y"
+	{ yyval = scon_stk_ptr; }
+break;
+case 31:
+#line 323 "parse.y"
+	{ yyval = yystack.l_mark[-2]; }
+break;
+case 32:
+#line 326 "parse.y"
+	{
+			yyval = scon_stk_ptr;
+
+			for ( i = 1; i <= lastsc; ++i )
+				{
+				int j;
+
+				for ( j = 1; j <= scon_stk_ptr; ++j )
+					if ( scon_stk[j] == i )
+						break;
+
+				if ( j > scon_stk_ptr )
+					scon_stk[++scon_stk_ptr] = i;
+				}
+			}
+break;
+case 33:
+#line 343 "parse.y"
+	{ yyval = scon_stk_ptr; }
+break;
+case 36:
+#line 351 "parse.y"
+	{ synerr( _("bad start condition list") ); }
+break;
+case 37:
+#line 355 "parse.y"
+	{
+			if ( (scnum = sclookup( nmstr )) == 0 )
+				format_pinpoint_message(
+					"undeclared start condition %s",
+					nmstr );
+			else
+				{
+				for ( i = 1; i <= scon_stk_ptr; ++i )
+					if ( scon_stk[i] == scnum )
+						{
+						format_warn(
+							"<%s> specified twice",
+							scname[scnum] );
+						break;
+						}
+
+				if ( i > scon_stk_ptr )
+					scon_stk[++scon_stk_ptr] = scnum;
+				}
+			}
+break;
+case 38:
+#line 378 "parse.y"
+	{
+			if ( transchar[lastst[yystack.l_mark[0]]] != SYM_EPSILON )
+				/* Provide final transition \now/ so it
+				 * will be marked as a trailing context
+				 * state.
+				 */
+				yystack.l_mark[0] = link_machines( yystack.l_mark[0],
+						mkstate( SYM_EPSILON ) );
+
+			mark_beginning_as_normal( yystack.l_mark[0] );
+			current_state_type = STATE_NORMAL;
+
+			if ( previous_continued_action )
+				{
+				/* We need to treat this as variable trailing
+				 * context so that the backup does not happen
+				 * in the action but before the action switch
+				 * statement.  If the backup happens in the
+				 * action, then the rules "falling into" this
+				 * one's action will *also* do the backup,
+				 * erroneously.
+				 */
+				if ( ! varlength || headcnt != 0 )
+					warn(
+		"trailing context made variable due to preceding '|' action" );
+
+				/* Mark as variable. */
+				varlength = true;
+				headcnt = 0;
+
+				}
+
+			if ( lex_compat || (varlength && headcnt == 0) )
+				{ /* variable trailing context rule */
+				/* Mark the first part of the rule as the
+				 * accepting "head" part of a trailing
+				 * context rule.
+				 *
+				 * By the way, we didn't do this at the
+				 * beginning of this production because back
+				 * then current_state_type was set up for a
+				 * trail rule, and add_accept() can create
+				 * a new state ...
+				 */
+				add_accept( yystack.l_mark[-1],
+					num_rules | YY_TRAILING_HEAD_MASK );
+				variable_trail_rule = true;
+				}
+			
+			else
+				trailcnt = rulelen;
+
+			yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
+			}
+break;
+case 39:
+#line 434 "parse.y"
+	{ synerr( _("trailing context used twice") ); }
+break;
+case 40:
+#line 437 "parse.y"
+	{
+			headcnt = 0;
+			trailcnt = 1;
+			rulelen = 1;
+			varlength = false;
+
+			current_state_type = STATE_TRAILING_CONTEXT;
+
+			if ( trlcontxt )
+				{
+				synerr( _("trailing context used twice") );
+				yyval = mkstate( SYM_EPSILON );
+				}
+
+			else if ( previous_continued_action )
+				{
+				/* See the comment in the rule for "re2 re"
+				 * above.
+				 */
+				warn(
+		"trailing context made variable due to preceding '|' action" );
+
+				varlength = true;
+				}
+
+			if ( lex_compat || varlength )
+				{
+				/* Again, see the comment in the rule for
+				 * "re2 re" above.
+				 */
+				add_accept( yystack.l_mark[-1],
+					num_rules | YY_TRAILING_HEAD_MASK );
+				variable_trail_rule = true;
+				}
+
+			trlcontxt = true;
+
+			eps = mkstate( SYM_EPSILON );
+			yyval = link_machines( yystack.l_mark[-1],
+				link_machines( eps, mkstate( '\n' ) ) );
+			}
+break;
+case 41:
+#line 480 "parse.y"
+	{
+			yyval = yystack.l_mark[0];
+
+			if ( trlcontxt )
+				{
+				if ( lex_compat || (varlength && headcnt == 0) )
+					/* Both head and trail are
+					 * variable-length.
+					 */
+					variable_trail_rule = true;
+				else
+					trailcnt = rulelen;
+				}
+			}
+break;
+case 42:
+#line 498 "parse.y"
+	{
+			varlength = true;
+			yyval = mkor( yystack.l_mark[-2], yystack.l_mark[0] );
+			}
+break;
+case 43:
+#line 504 "parse.y"
+	{ yyval = yystack.l_mark[0]; }
+break;
+case 44:
+#line 509 "parse.y"
+	{
+			/* This rule is written separately so the
+			 * reduction will occur before the trailing
+			 * series is parsed.
+			 */
+
+			if ( trlcontxt )
+				synerr( _("trailing context used twice") );
+			else
+				trlcontxt = true;
+
+			if ( varlength )
+				/* We hope the trailing context is
+				 * fixed-length.
+				 */
+				varlength = false;
+			else
+				headcnt = rulelen;
+
+			rulelen = 0;
+
+			current_state_type = STATE_TRAILING_CONTEXT;
+			yyval = yystack.l_mark[-1];
+			}
+break;
+case 45:
+#line 536 "parse.y"
+	{
+			/* This is where concatenation of adjacent patterns
+			 * gets done.
+			 */
+			yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
+			}
+break;
+case 46:
+#line 544 "parse.y"
+	{ yyval = yystack.l_mark[0]; }
+break;
+case 47:
+#line 547 "parse.y"
+	{
+			varlength = true;
+
+			if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
+				{
+				synerr( _("bad iteration values") );
+				yyval = yystack.l_mark[-5];
+				}
+			else
+				{
+				if ( yystack.l_mark[-3] == 0 )
+					{
+					if ( yystack.l_mark[-1] <= 0 )
+						{
+						synerr(
+						_("bad iteration values") );
+						yyval = yystack.l_mark[-5];
+						}
+					else
+						yyval = mkopt(
+							mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
+					}
+				else
+					yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
+				}
+			}
+break;
+case 48:
+#line 575 "parse.y"
+	{
+			varlength = true;
+
+			if ( yystack.l_mark[-2] <= 0 )
+				{
+				synerr( _("iteration value must be positive") );
+				yyval = yystack.l_mark[-4];
+				}
+
+			else
+				yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
+			}
+break;
+case 49:
+#line 589 "parse.y"
+	{
+			/* The series could be something like "(foo)",
+			 * in which case we have no idea what its length
+			 * is, so we punt here.
+			 */
+			varlength = true;
+
+			if ( yystack.l_mark[-1] <= 0 )
+				{
+				  synerr( _("iteration value must be positive")
+					  );
+				yyval = yystack.l_mark[-3];
+				}
+
+			else
+				yyval = link_machines( yystack.l_mark[-3],
+						copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
+			}
+break;
+case 50:
+#line 611 "parse.y"
+	{
+			varlength = true;
+
+			yyval = mkclos( yystack.l_mark[-1] );
+			}
+break;
+case 51:
+#line 618 "parse.y"
+	{
+			varlength = true;
+			yyval = mkposcl( yystack.l_mark[-1] );
+			}
+break;
+case 52:
+#line 624 "parse.y"
+	{
+			varlength = true;
+			yyval = mkopt( yystack.l_mark[-1] );
+			}
+break;
+case 53:
+#line 630 "parse.y"
+	{
+			varlength = true;
+
+			if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
+				{
+				synerr( _("bad iteration values") );
+				yyval = yystack.l_mark[-5];
+				}
+			else
+				{
+				if ( yystack.l_mark[-3] == 0 )
+					{
+					if ( yystack.l_mark[-1] <= 0 )
+						{
+						synerr(
+						_("bad iteration values") );
+						yyval = yystack.l_mark[-5];
+						}
+					else
+						yyval = mkopt(
+							mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
+					}
+				else
+					yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
+				}
+			}
+break;
+case 54:
+#line 658 "parse.y"
+	{
+			varlength = true;
+
+			if ( yystack.l_mark[-2] <= 0 )
+				{
+				synerr( _("iteration value must be positive") );
+				yyval = yystack.l_mark[-4];
+				}
+
+			else
+				yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
+			}
+break;
+case 55:
+#line 672 "parse.y"
+	{
+			/* The singleton could be something like "(foo)",
+			 * in which case we have no idea what its length
+			 * is, so we punt here.
+			 */
+			varlength = true;
+
+			if ( yystack.l_mark[-1] <= 0 )
+				{
+				synerr( _("iteration value must be positive") );
+				yyval = yystack.l_mark[-3];
+				}
+
+			else
+				yyval = link_machines( yystack.l_mark[-3],
+						copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
+			}
+break;
+case 56:
+#line 691 "parse.y"
+	{
+			if ( ! madeany )
+				{
+				/* Create the '.' character class. */
+                    ccldot = cclinit();
+                    ccladd( ccldot, '\n' );
+                    cclnegate( ccldot );
+
+                    if ( useecs )
+                        mkeccl( ccltbl + cclmap[ccldot],
+                            ccllen[ccldot], nextecm,
+                            ecgroup, csize, csize );
+
+				/* Create the (?s:'.') character class. */
+                    cclany = cclinit();
+                    cclnegate( cclany );
+
+                    if ( useecs )
+                        mkeccl( ccltbl + cclmap[cclany],
+                            ccllen[cclany], nextecm,
+                            ecgroup, csize, csize );
+
+				madeany = true;
+				}
+
+			++rulelen;
+
+            if (sf_dot_all())
+                yyval = mkstate( -cclany );
+            else
+                yyval = mkstate( -ccldot );
+			}
+break;
+case 57:
+#line 725 "parse.y"
+	{
+				/* Sort characters for fast searching.
+				 */
+				qsort( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]], sizeof (*ccltbl), cclcmp );
+
+			if ( useecs )
+				mkeccl( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]],
+					nextecm, ecgroup, csize, csize );
+
+			++rulelen;
+
+			if (ccl_has_nl[yystack.l_mark[0]])
+				rule_has_nl[num_rules] = true;
+
+			yyval = mkstate( -yystack.l_mark[0] );
+			}
+break;
+case 58:
+#line 743 "parse.y"
+	{
+			++rulelen;
+
+			if (ccl_has_nl[yystack.l_mark[0]])
+				rule_has_nl[num_rules] = true;
+
+			yyval = mkstate( -yystack.l_mark[0] );
+			}
+break;
+case 59:
+#line 753 "parse.y"
+	{ yyval = yystack.l_mark[-1]; }
+break;
+case 60:
+#line 756 "parse.y"
+	{ yyval = yystack.l_mark[-1]; }
+break;
+case 61:
+#line 759 "parse.y"
+	{
+			++rulelen;
+
+			if (yystack.l_mark[0] == nlch)
+				rule_has_nl[num_rules] = true;
+
+            if (sf_case_ins() && has_case(yystack.l_mark[0]))
+                /* create an alternation, as in (a|A) */
+                yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
+            else
+                yyval = mkstate( yystack.l_mark[0] );
+			}
+break;
+case 62:
+#line 773 "parse.y"
+	{ yyval = ccl_set_diff  (yystack.l_mark[-2], yystack.l_mark[0]); }
+break;
+case 63:
+#line 774 "parse.y"
+	{ yyval = ccl_set_union (yystack.l_mark[-2], yystack.l_mark[0]); }
+break;
+case 65:
+#line 780 "parse.y"
+	{ yyval = yystack.l_mark[-1]; }
+break;
+case 66:
+#line 783 "parse.y"
+	{
+			cclnegate( yystack.l_mark[-1] );
+			yyval = yystack.l_mark[-1];
+			}
+break;
+case 67:
+#line 790 "parse.y"
+	{
+
+			if (sf_case_ins())
+			  {
+
+			    /* If one end of the range has case and the other
+			     * does not, or the cases are different, then we're not
+			     * sure what range the user is trying to express.
+			     * Examples: [@-z] or [S-t]
+			     */
+			    if (has_case (yystack.l_mark[-2]) != has_case (yystack.l_mark[0])
+				     || (has_case (yystack.l_mark[-2]) && (b_islower (yystack.l_mark[-2]) != b_islower (yystack.l_mark[0])))
+				     || (has_case (yystack.l_mark[-2]) && (b_isupper (yystack.l_mark[-2]) != b_isupper (yystack.l_mark[0]))))
+			      format_warn3 (
+			      _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
+					    yystack.l_mark[-2], yystack.l_mark[0]);
+
+			    /* If the range spans uppercase characters but not
+			     * lowercase (or vice-versa), then should we automatically
+			     * include lowercase characters in the range?
+			     * Example: [@-_] spans [a-z] but not [A-Z]
+			     */
+			    else if (!has_case (yystack.l_mark[-2]) && !has_case (yystack.l_mark[0]) && !range_covers_case (yystack.l_mark[-2], yystack.l_mark[0]))
+			      format_warn3 (
+			      _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
+					    yystack.l_mark[-2], yystack.l_mark[0]);
+			  }
+
+			if ( yystack.l_mark[-2] > yystack.l_mark[0] )
+				synerr( _("negative range in character class") );
+
+			else
+				{
+				for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
+					ccladd( yystack.l_mark[-3], i );
+
+				/* Keep track if this ccl is staying in
+				 * alphabetical order.
+				 */
+				cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
+				lastchar = yystack.l_mark[0];
+
+                /* Do it again for upper/lowercase */
+                if (sf_case_ins() && has_case(yystack.l_mark[-2]) && has_case(yystack.l_mark[0])){
+                    yystack.l_mark[-2] = reverse_case (yystack.l_mark[-2]);
+                    yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
+                    
+                    for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
+                        ccladd( yystack.l_mark[-3], i );
+
+                    cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
+                    lastchar = yystack.l_mark[0];
+                }
+
+				}
+
+			yyval = yystack.l_mark[-3];
+			}
+break;
+case 68:
+#line 850 "parse.y"
+	{
+			ccladd( yystack.l_mark[-1], yystack.l_mark[0] );
+			cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
+			lastchar = yystack.l_mark[0];
+
+            /* Do it again for upper/lowercase */
+            if (sf_case_ins() && has_case(yystack.l_mark[0])){
+                yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
+                ccladd (yystack.l_mark[-1], yystack.l_mark[0]);
+
+                cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
+                lastchar = yystack.l_mark[0];
+            }
+
+			yyval = yystack.l_mark[-1];
+			}
+break;
+case 69:
+#line 868 "parse.y"
+	{
+			/* Too hard to properly maintain cclsorted. */
+			cclsorted = false;
+			yyval = yystack.l_mark[-1];
+			}
+break;
+case 70:
+#line 875 "parse.y"
+	{
+			cclsorted = true;
+			lastchar = 0;
+			currccl = yyval = cclinit();
+			}
+break;
+case 71:
+#line 883 "parse.y"
+	{ CCL_EXPR(isalnum); }
+break;
+case 72:
+#line 884 "parse.y"
+	{ CCL_EXPR(isalpha); }
+break;
+case 73:
+#line 885 "parse.y"
+	{ CCL_EXPR(IS_BLANK); }
+break;
+case 74:
+#line 886 "parse.y"
+	{ CCL_EXPR(iscntrl); }
+break;
+case 75:
+#line 887 "parse.y"
+	{ CCL_EXPR(isdigit); }
+break;
+case 76:
+#line 888 "parse.y"
+	{ CCL_EXPR(isgraph); }
+break;
+case 77:
+#line 889 "parse.y"
+	{ 
+                          CCL_EXPR(islower);
+                          if (sf_case_ins())
+                              CCL_EXPR(isupper);
+                        }
+break;
+case 78:
+#line 894 "parse.y"
+	{ CCL_EXPR(isprint); }
+break;
+case 79:
+#line 895 "parse.y"
+	{ CCL_EXPR(ispunct); }
+break;
+case 80:
+#line 896 "parse.y"
+	{ CCL_EXPR(isspace); }
+break;
+case 81:
+#line 897 "parse.y"
+	{ CCL_EXPR(isxdigit); }
+break;
+case 82:
+#line 898 "parse.y"
+	{
+                    CCL_EXPR(isupper);
+                    if (sf_case_ins())
+                        CCL_EXPR(islower);
+				}
+break;
+case 83:
+#line 904 "parse.y"
+	{ CCL_NEG_EXPR(isalnum); }
+break;
+case 84:
+#line 905 "parse.y"
+	{ CCL_NEG_EXPR(isalpha); }
+break;
+case 85:
+#line 906 "parse.y"
+	{ CCL_NEG_EXPR(IS_BLANK); }
+break;
+case 86:
+#line 907 "parse.y"
+	{ CCL_NEG_EXPR(iscntrl); }
+break;
+case 87:
+#line 908 "parse.y"
+	{ CCL_NEG_EXPR(isdigit); }
+break;
+case 88:
+#line 909 "parse.y"
+	{ CCL_NEG_EXPR(isgraph); }
+break;
+case 89:
+#line 910 "parse.y"
+	{ CCL_NEG_EXPR(isprint); }
+break;
+case 90:
+#line 911 "parse.y"
+	{ CCL_NEG_EXPR(ispunct); }
+break;
+case 91:
+#line 912 "parse.y"
+	{ CCL_NEG_EXPR(isspace); }
+break;
+case 92:
+#line 913 "parse.y"
+	{ CCL_NEG_EXPR(isxdigit); }
+break;
+case 93:
+#line 914 "parse.y"
+	{ 
+				if ( sf_case_ins() )
+					warn(_("[:^lower:] is ambiguous in case insensitive scanner"));
+				else
+					CCL_NEG_EXPR(islower);
+				}
+break;
+case 94:
+#line 920 "parse.y"
+	{
+				if ( sf_case_ins() )
+					warn(_("[:^upper:] ambiguous in case insensitive scanner"));
+				else
+					CCL_NEG_EXPR(isupper);
+				}
+break;
+case 95:
+#line 929 "parse.y"
+	{
+			if ( yystack.l_mark[0] == nlch )
+				rule_has_nl[num_rules] = true;
+
+			++rulelen;
+
+            if (sf_case_ins() && has_case(yystack.l_mark[0]))
+                yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
+            else
+                yyval = mkstate (yystack.l_mark[0]);
+
+			yyval = link_machines( yystack.l_mark[-1], yyval);
+			}
+break;
+case 96:
+#line 944 "parse.y"
+	{ yyval = mkstate( SYM_EPSILON ); }
+break;
+#line 1787 "parse.c"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= yym;
+    yym = yylhs[yyn];
+    if (yystate == 0 && yym == 0)
+    {
+#if YYDEBUG
+        if (yydebug)
+            printf("%sdebug: after reduction, shifting from state 0 to\
+ state %d\n", YYPREFIX, YYFINAL);
+#endif
+        yystate = YYFINAL;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = 0;
+                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+                if (!yys) yys = "illegal-symbol";
+                printf("%sdebug: state %d, reading %d (%s)\n",
+                        YYPREFIX, YYFINAL, yychar, yys);
+            }
+#endif
+        }
+        if (yychar == 0) goto yyaccept;
+        goto yyloop;
+    }
+    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
+        yystate = yytable[yyn];
+    else
+        yystate = yydgoto[yym];
+#if YYDEBUG
+    if (yydebug)
+        printf("%sdebug: after reduction, shifting from state %d \
+to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/lex/initparse.h b/usr.bin/lex/initparse.h
new file mode 100644
index 000000000000..6ede604579b5
--- /dev/null
+++ b/usr.bin/lex/initparse.h
@@ -0,0 +1,46 @@
+/* $FreeBSD$ */
+#define CHAR 257
+#define NUMBER 258
+#define SECTEND 259
+#define SCDECL 260
+#define XSCDECL 261
+#define NAME 262
+#define PREVCCL 263
+#define EOF_OP 264
+#define OPTION_OP 265
+#define OPT_OUTFILE 266
+#define OPT_PREFIX 267
+#define OPT_YYCLASS 268
+#define OPT_HEADER 269
+#define OPT_EXTRA_TYPE 270
+#define OPT_TABLES 271
+#define CCE_ALNUM 272
+#define CCE_ALPHA 273
+#define CCE_BLANK 274
+#define CCE_CNTRL 275
+#define CCE_DIGIT 276
+#define CCE_GRAPH 277
+#define CCE_LOWER 278
+#define CCE_PRINT 279
+#define CCE_PUNCT 280
+#define CCE_SPACE 281
+#define CCE_UPPER 282
+#define CCE_XDIGIT 283
+#define CCE_NEG_ALNUM 284
+#define CCE_NEG_ALPHA 285
+#define CCE_NEG_BLANK 286
+#define CCE_NEG_CNTRL 287
+#define CCE_NEG_DIGIT 288
+#define CCE_NEG_GRAPH 289
+#define CCE_NEG_LOWER 290
+#define CCE_NEG_PRINT 291
+#define CCE_NEG_PUNCT 292
+#define CCE_NEG_SPACE 293
+#define CCE_NEG_UPPER 294
+#define CCE_NEG_XDIGIT 295
+#define CCL_OP_DIFF 296
+#define CCL_OP_UNION 297
+#define BEGIN_REPEAT_POSIX 298
+#define END_REPEAT_POSIX 299
+#define BEGIN_REPEAT_FLEX 300
+#define END_REPEAT_FLEX 301
diff --git a/usr.bin/lex/initscan.c b/usr.bin/lex/initscan.c
index 7620c528588a..d7391ba2f2ea 100644
--- a/usr.bin/lex/initscan.c
+++ b/usr.bin/lex/initscan.c
@@ -1,76 +1,125 @@
-#line 2 "scan.c"
+/* $FreeBSD$ */
+
+#line 3 "<stdout>"
+
+#define  YY_INT_ALIGNED short int
+
 /* A lexical scanner generated by flex */
 
-/* Scanner skeleton version:
- * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
- * $FreeBSD$
- */
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 37
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
 
 #if defined(__FreeBSD__)
+#ifndef __STDC_LIMIT_MACROS
+#define	__STDC_LIMIT_MACROS
+#endif
 #include <sys/cdefs.h>
+#include <stdint.h>
 #else
-#define __unused
-#define __dead2
+#define	__dead2
 #endif
 
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-
+/* begin standard C headers. */
 #include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
 
+/* end standard C headers. */
 
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
-#endif
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined(__FreeBSD__) || \
+    (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
 
-#ifdef __cplusplus
+#endif /* ! C99 */
 
-#include <stdlib.h>
-#include <unistd.h>
+#endif /* ! FLEXINT_H */
 
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
+#ifdef __cplusplus
 
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
 #else	/* ! __cplusplus */
 
-#if __STDC__
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
 
-#define YY_USE_PROTOS
 #define YY_USE_CONST
 
-#endif	/* __STDC__ */
+#endif	/* defined (__STDC__) */
 #endif	/* ! __cplusplus */
 
-#ifdef __TURBOC__
- #pragma warn -rch
- #pragma warn -use
-#include <io.h>
-#include <stdlib.h>
-#define YY_USE_CONST
-#define YY_USE_PROTOS
-#endif
-
 #ifdef YY_USE_CONST
 #define yyconst const
 #else
 #define yyconst
 #endif
 
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#endif
-
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
@@ -85,71 +134,70 @@
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
-#define BEGIN yy_start = 1 + 2 *
+#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 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 yyrestart( yyin )
+#define YY_NEW_FILE yyrestart(yyin  )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
 #define YY_BUF_SIZE 16384
+#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
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+extern yy_size_t yyleng;
 
-extern int yyleng;
 extern FILE *yyin, *yyout;
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-/* The funky do-while in the following #define is used to turn the definition
- * int a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- * 	if ( condition_holds )
- *		yyless( 5 );
- *	else
- *		do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
+    #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 yytext. */ \
-		*yy_cp = yy_hold_char; \
+        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 + n - YY_MORE_ADJ; \
+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 		} \
 	while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr )
-
-/* The following is because we cannot portably get our hands on size_t
- * (without autoconf's help, which isn't available because we want
- * flex-generated scanners to compile on their own).
- */
-typedef unsigned int yy_size_t;
-
+#define unput(c) yyunput( c, (yytext_ptr)  )
 
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
 	{
 	FILE *yy_input_file;
@@ -165,7 +213,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	int yy_n_chars;
+	yy_size_t 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
@@ -186,12 +234,16 @@ struct yy_buffer_state
 	 */
 	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
@@ -205,28 +257,39 @@ struct yy_buffer_state
 	 * just pointing yyin at a new input file.
 	 */
 #define YY_BUFFER_EOF_PENDING 2
+
 	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
-static YY_BUFFER_STATE yy_current_buffer = 0;
+/* 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_current_buffer
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
+#define yy_current_buffer YY_CURRENT_BUFFER
 
+/* 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 yytext is formed. */
 static char yy_hold_char;
-
-static int yy_n_chars;		/* number of characters read into yy_ch_buf */
-
-
-int yyleng;
+static yy_size_t yy_n_chars;		/* number of characters read into yy_ch_buf */
+yy_size_t yyleng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;		/* whether we need to initialize */
+static int yy_init = 0;		/* whether we need to initialize */
 static int yy_start = 0;	/* start state number */
 
 /* Flag which is used to allow yywrap()'s to do buffer switches
@@ -234,169 +297,373 @@ static int yy_start = 0;	/* start state number */
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( FILE *input_file ));
+void yyrestart (FILE *input_file  );
+void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
+void yy_delete_buffer (YY_BUFFER_STATE b  );
+void yy_flush_buffer (YY_BUFFER_STATE b  );
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state (void );
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+static void yyensure_buffer_stack (void );
+static void yy_load_buffer_state (void );
+static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 
-static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) __unused;
-static void yy_flex_free YY_PROTO(( void * ));
+YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
+
+void *yyalloc (yy_size_t  );
+void *yyrealloc (void *,yy_size_t  );
+void yyfree (void *  );
 
 #define yy_new_buffer yy_create_buffer
 
 #define yy_set_interactive(is_interactive) \
 	{ \
-	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-	yy_current_buffer->yy_is_interactive = is_interactive; \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 	}
 
 #define yy_set_bol(at_bol) \
 	{ \
-	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-	yy_current_buffer->yy_at_bol = at_bol; \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 	}
 
-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
 
 typedef unsigned char YY_CHAR;
+
 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+
 typedef int yy_state_type;
+
+extern int yylineno;
+
+int yylineno = 1;
+
 extern char *yytext;
 #define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( yyconst char msg[] )) __dead2;
+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[]  ) __dead2;
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
 #define YY_DO_BEFORE_ACTION \
-	yytext_ptr = yy_bp; \
-	yyleng = (int) (yy_cp - yy_bp); \
-	yy_hold_char = *yy_cp; \
+	(yytext_ptr) = yy_bp; \
+	(yytext_ptr) -= (yy_more_len); \
+	yyleng = (size_t) (yy_cp - (yytext_ptr)); \
+	(yy_hold_char) = *yy_cp; \
 	*yy_cp = '\0'; \
-	yy_c_buf_p = yy_cp;
+	(yy_c_buf_p) = yy_cp;
 
-#define YY_NUM_RULES 165
-#define YY_END_OF_BUFFER 166
-static yyconst short int yy_accept[769] =
+#define YY_NUM_RULES 251
+#define YY_END_OF_BUFFER 252
+/* 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_acclist[1223] =
     {   0,
-        0,    0,    0,    0,   87,   87,  163,  163,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,  166,  164,
-        7,   18,  164,   16,    1,   17,  164,  164,  164,  164,
-       15,  108,  100,  101,  108,   93,  108,  107,  108,  108,
-      108,  107,   99,   89,  108,  108,   91,   92,   87,   88,
-       87,   86,   85,   86,   86,  163,  163,   28,   29,   28,
-       28,   28,   28,   28,   28,   31,   30,   32,   31,  113,
-      109,  110,  112,  114,  141,  142,  141,  139,  138,  140,
-
-      115,  117,  115,  116,  115,  120,  120,  120,  120,  122,
-      124,  122,  122,  122,  122,  123,  151,  155,  151,  154,
-      156,  156,  152,  152,  152,  149,  150,  164,   82,  164,
-       21,   22,   21,   20,  157,  159,  157,  160,  161,  147,
-      147,  148,  147,  147,  147,  147,  147,  147,  147,   81,
-       34,   33,   81,   81,   81,   81,   35,   81,   81,   81,
-       81,   81,   81,   81,   81,   81,   81,   81,   81,   81,
-       81,   81,   81,   81,   81,   81,   26,   23,   26,   24,
-        7,   18,    0,   16,    1,   17,    0,    0,    0,   14,
-        8,    0,    0,    0,    0,    4,    5,    0,    2,   15,
-
-      100,  101,    0,    0,    0,   95,    0,    0,  105,  105,
-        0,  162,  162,  162,   94,    0,   99,   89,    0,    0,
-        0,   91,   92,  104,   90,    0,   87,   88,   86,   85,
-       85,   83,   84,  163,  163,   28,   29,   28,   28,   28,
-       28,   31,   30,   32,  111,  112,  142,  138,  117,    0,
-      118,  119,  124,  121,  151,  155,    0,  153,    0,  144,
-      152,  152,  152,    0,   82,    0,   21,   22,   21,   19,
-      157,  159,  158,  147,  147,  147,  148,  143,  147,  147,
-      147,   34,   33,    0,   80,    0,    0,   81,   81,   81,
-       81,   81,   81,   81,   81,   81,   81,   81,   81,   81,
-
-       81,   81,   81,   36,   81,   81,   81,   81,   81,   81,
-       81,   81,   81,   81,    0,   25,   24,    0,   14,    8,
-        0,   12,    0,    0,    0,    0,    0,    4,    5,    0,
-        6,    0,   96,    0,   97,    0,    0,  105,  105,    0,
-      105,  105,  105,  162,  162,    0,  106,   90,   98,    0,
-      104,    0,   83,   84,   28,   28,   28,   27,   28,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,  152,  152,  143,  143,  147,  147,    0,    0,   81,
-       81,   81,   81,   81,   44,   81,   81,   81,   49,   81,
-       81,   81,   81,   81,   81,   81,   81,   81,   81,   81,
-
-       81,   81,   81,   81,   81,   81,   81,   81,    0,   81,
-       81,   81,   81,    0,    0,    0,   12,    0,    0,    0,
-        0,    0,    0,    4,    5,    0,  105,  105,  105,  105,
-      105,  105,  162,    0,    0,   28,   28,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-      152,  152,  147,  147,   37,   38,   81,   81,   81,   81,
-       81,   81,   81,   81,   50,   51,   81,   81,   81,   55,
-       81,   81,   81,   81,   81,   81,   60,   81,   81,   81,
-       81,   81,   81,   67,    0,    0,    0,   81,   81,   81,
-       81,    0,   13,    0,    0,    0,    0,    0,    0,  105,
-
-      105,  105,  105,  105,  105,    0,    0,   28,   28,  137,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,  152,  152,  147,  147,   39,   81,   41,   81,
-       43,   81,   81,   81,   47,   81,   52,   81,   81,   81,
-       81,   81,   81,   81,   81,   81,   62,   81,   81,   65,
-       81,    0,    0,    0,    0,   81,   81,   81,   81,    3,
-        0,    0,    0,    0,  105,  105,  105,    0,    0,   28,
-       28,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,  145,  146,  145,  146,   81,   42,   81,
-       81,   81,   81,   81,   81,   81,   81,   81,   81,   81,
-
-       81,   78,   61,   81,   64,   81,    0,    0,    0,    0,
-       81,   81,   69,   70,    0,   10,    0,   11,    0,  103,
-        0,  102,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,   81,   81,   81,   45,   81,   48,
-       81,   81,   81,   81,   77,   81,   59,   63,   66,    0,
-        0,    0,    0,   79,   81,    0,  102,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,   81,
-       81,   81,   46,   81,   81,   56,   81,   81,    0,    0,
-        0,    0,   68,    0,    9,    0,  125,  126,  127,  128,
-      129,  130,  131,  132,  133,  134,  135,    0,   81,   81,
-
-       81,   81,   81,   81,   81,    0,    0,    0,    0,    0,
-      136,   81,   81,   81,   81,   54,   81,   81,    0,    0,
-        0,    0,    0,    0,   81,   81,   81,   53,   81,   58,
-        0,    0,    0,    0,    0,    0,   81,   81,   81,   81,
-       72,    0,    0,    0,    0,   73,   81,   81,   81,   81,
-       71,    0,   75,    0,   81,   81,   81,   74,   76,   81,
-       81,   81,   81,   81,   81,   57,   40,    0
+      248,  248,  252,  250,  251,    9,  250,  251,   20,  250,
+      251,  250,  251,   18,  250,  251,    1,    9,  250,  251,
+       19,   20,  250,  251,  250,  251,  250,  251,  250,  251,
+      250,  251,   17,   18,  250,  251,  164,  250,  251,  149,
+      164,  250,  251,  150,  250,  251,  164,  250,  251,  142,
+      164,  250,  251,  164,  250,  251,  161,  163,  164,  250,
+      251,  162,  163,  164,  250,  251,  163,  164,  250,  251,
+      163,  164,  250,  251,  164,  250,  251,  164,  250,  251,
+      164,  250,  251,  163,  164,  250,  251,  148,  149,  164,
+      250,  251,  138,  150,  250,  251,  164,  250,  251,  164,
+
+      250,  251,  140,  164,  250,  251,  141,  164,  250,  251,
+      136,  250,  251,  137,  250,  251,  136,  250,  251,  135,
+      136,  250,  251,  134,  136,  250,  251,  135,  136,  250,
+      251,  248,  249,  250,  251,  248,  249,  250,  251,  249,
+      250,  251,  249,  250,  251,   41,  250,  251,   42,  250,
+      251,   41,  250,  251,   41,  250,  251,   41,  250,  251,
+       41,  250,  251,   41,  250,  251,   41,  250,  251,   50,
+      250,  251,   49,  250,  251,   51,  250,  251,  250,  251,
+      170,  250,  251,  170,  250,  251,  165,  250,  251,  170,
+      250,  251,  166,  170,  250,  251,  167,  170,  250,  251,
+
+      169,  170,  250,  251,  171,  250,  251,  219,  250,  251,
+      220,  250,  251,  219,  250,  251,  217,  219,  250,  251,
+      216,  219,  250,  251,  218,  219,  250,  251,  172,  250,
+      251,  174,  250,  251,  172,  250,  251,  173,  250,  251,
+      172,  250,  251,  186,  250,  251,  186,  250,  251,  186,
+      250,  251,  186,  250,  251,  188,  190,  250,  251,  190,
+      250,  251,  188,  190,  250,  251,  188,  190,  250,  251,
+      188,  190,  250,  251,  188,  190,  250,  251,  189,  190,
+      250,  251,  233,  239,  250,  251,  238,  250,  251,  233,
+      239,  250,  251,  237,  239,  250,  251,  239,  250,  251,
+
+      239,  250,  251,  235,  239,  250,  251,  235,  239,  250,
+      251,  235,  239,  250,  251,  234,  239,  250,  251,  234,
+      239,  250,  251,  229,  239,  250,  251,  230,  239,  250,
+      251,  250,  251,  131,  250,  251,  250,  251,   25,  250,
+      251,   26,  250,  251,   25,  250,  251,   22,  250,  251,
+       25,  250,  251,   25,  250,  251,  240,  244,  250,  251,
+      242,  250,  251,  240,  244,  250,  251,  243,  244,  250,
+      251,  244,  250,  251,  227,  250,  251,  227,  250,  251,
+      228,  250,  251,  227,  250,  251,  227,  250,  251,  227,
+      250,  251,  227,  250,  251,  227,  250,  251,  227,  250,
+
+      251,  227,  250,  251,  130,  250,  251,   53,  130,  250,
+      251,   52,  250,  251,  130,  250,  251,  130,  250,  251,
+      130,  250,  251,  130,  250,  251,   54,  130,  250,  251,
+      130,  250,  251,  130,  250,  251,  130,  250,  251,  130,
+      250,  251,  130,  250,  251,  130,  250,  251,  130,  250,
+      251,  130,  250,  251,  130,  250,  251,  130,  250,  251,
+      130,  250,  251,  130,  250,  251,  130,  250,  251,  130,
+      250,  251,  130,  250,  251,  130,  250,  251,  130,  250,
+      251,  130,  250,  251,  130,  250,  251,  130,  250,  251,
+      130,  250,  251,   37,  250,  251,   34,  250,  251,   37,
+
+      250,  251,   35,   37,  250,  251,   48,  250,  251,   45,
+      250,  251,  250,  251,   48,  250,  251,   48,  250,  251,
+       44,  250,  251,   43,  250,  251,  176,  250,  251,  175,
+      250,  251,  177,  250,  251,  178,  250,  251,  179,  250,
+      251,  180,  250,  251,  181,  250,  251,  182,  250,  251,
+      183,  250,  251,   32,  250,  251,   33,  250,  251,   32,
+      250,  251,   31,  250,  251,   29,  250,  251,   30,  250,
+      251,   29,  250,  251,   28,  250,  251,    9,   20,   18,
+        1,    9,   19,   20,   16,   10,   16,    4,   16,    5,
+        2,   17,   18,  149,  150,  144,  160,  158,  154,  154,
+
+      245,  245,  245,  143,  148,  149,  138,  150,  140,  141,
+      153,  139,  137,  135,  134,  134,  132,  135,  133,  135,
+      248,  248,  246,  247,   42,   39,   40,   50,   49,   51,
+      165,  165,  168,  169,  220,  216,  174,  184,  185,  190,
+      187,  233,  238,  236,  222,  235,  235,  235,  231,  232,
+      131,   26,   21,   23,   24,  240,  242,  241,  228,  221,
+      225,  226,   53,   52,  129,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,   55,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,  130,   36,   35,   45,
+
+       46,   47,   32,   33,   30,   27,   16,   10,   16,   14,
+        4,   16,    5,    6,  145,  146,  159,  154,  154,  154,
+      154,  154,  245,  245,  156,  155,  157,  139,  145,  147,
+      153,  132,  135,  133,  135,   38,  235,  235,  221,  130,
+      130,  130,  130,  130,  130,  130,   67,  130,  130,  130,
+      130,   72,  130,  130,  130,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,  130,   14,   15,    4,
+        8,   16,    5,  154,  154,  154,  154,  154,  154,  154,
+
+      245,  157,  235,  235,   56,   57,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,  130,   73,  130,   74,
+      130,  130,  130,  130,  130,   79,  130,  130,  130,  130,
+      130,  130,  130,  130,   84,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,   93,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,   15,    8,   16,    8,
+       16,    8,   16,  154,  154,  154,  154,  154,  154,  154,
+      215,  235,  235,   58,  130,  130,  130,   60,  130,  130,
+       64,  130,  130,  130,  130,  130,   70,  130,  130,  130,
+      130,   75,  130,  130,  130,  130,  130,  130,  130,  130,
+
+      130,  130,  130,  130,   87,  130,  130,  130,  130,  130,
+       91,  130,  130,  130,  130,  130,  130,  130,  130,  130,
+      130,  130,    3,    8,   16,    7,    8,   16,  154,  154,
+      154,  223,  224,  223,  235,  224,  235,  130,  130,  130,
+       63,  130,  130,  130,  130,  130,  130,  130,  130,  126,
+      130,  130,  130,  130,  130,  130,  130,  130,  130,  124,
+      130,  130,   86,  130,  130,   89,  130,  130,   90,  130,
+      130,  130,  130,  105,  130,  130,   95,  130,  130,   96,
+      130,   12,   13,  152,  151,  152,  130,  130,  130,  130,
+      130,  130,  130,   68,  130,  130,   71,  130,  130,  130,
+
+      130,  130,  130,  130,  123,  130,  130,   83,  130,  130,
+      130,   88,  130,  130,   92,  130,  103,  130,  125,  130,
+      130,  130,  151,  130,  130,  130,  130,  130,  130,  130,
+       69,  130,  130,  130,  130,  130,   80,  130,  130,  130,
+      130,  130,  130,  130,  114,   94,  130,  130,  115,   11,
+      191,  215,  192,  215,  193,  215,  194,  215,  195,  215,
+      196,  215,  197,  215,  198,  215,  199,  215,  200,  215,
+      201,  215,  130,  130,  130,  130,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  130,   85,  130,  130,  130,
+      116,  104,  130,  117,  202,  215,  203,  215,  204,  215,
+
+      205,  215,  206,  215,  207,  215,  208,  215,  209,  215,
+      210,  215,  211,  215,  212,  215,  213,  215,  130,  130,
+      130,  130,  130,  130,  130,  122,  130,  130,  130,   77,
+      130,  130,  130,  130,  130,  130,  110,  120,  118,  111,
+      121,  119,  214,  215,  130,  130,  130,  130,  130,  130,
+      130,  126,  130,   76,  130,  130,   82,  130,  130,  127,
+      130,  130,  106,  108,  107,  109,  130,  130,  130,   65,
+      130,  130,  130,  130,  130,   78,  130,  130,  112,  113,
+       98,   99,  130,  130,  130,  130,  130,  130,  130,  128,
+      130,   97,  101,  130,  130,  130,  130,  130,   68,  130,
+
+      130,  100,  102,  130,  130,   62,  130,   66,  130,  130,
+      130,  130,   61,  130,   69,  130,  130,  130,   81,  130,
+       59,  130
     } ;
 
-static yyconst int yy_ec[256] =
+static yyconst flex_int16_t yy_accept[1108] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    2,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    4,
+        6,    9,   12,   14,   17,   21,   25,   27,   29,   31,
+       33,   37,   40,   44,   47,   50,   54,   57,   62,   67,
+       71,   75,   78,   81,   84,   88,   93,   97,  100,  103,
+      107,  111,  114,  117,  120,  124,  128,  132,  136,  140,
+      143,  146,  149,  152,  155,  158,  161,  164,  167,  170,
+
+      173,  176,  179,  181,  184,  187,  190,  193,  197,  201,
+      205,  208,  211,  214,  217,  221,  225,  229,  232,  235,
+      238,  241,  244,  247,  250,  253,  256,  260,  263,  267,
+      271,  275,  279,  283,  287,  290,  294,  298,  301,  304,
+      308,  312,  316,  320,  324,  328,  332,  334,  337,  339,
+      342,  345,  348,  351,  354,  357,  361,  364,  368,  372,
+      375,  378,  381,  384,  387,  390,  393,  396,  399,  402,
+      405,  408,  412,  415,  418,  421,  424,  427,  431,  434,
+      437,  440,  443,  446,  449,  452,  455,  458,  461,  464,
+      467,  470,  473,  476,  479,  482,  485,  488,  491,  494,
+
+      497,  500,  503,  507,  510,  513,  515,  518,  521,  524,
+      527,  530,  533,  536,  539,  542,  545,  548,  551,  554,
+      557,  560,  563,  566,  569,  572,  575,  578,  579,  580,
+      580,  581,  583,  585,  585,  585,  585,  586,  588,  588,
+      588,  588,  588,  589,  590,  591,  591,  592,  594,  595,
+      596,  596,  596,  596,  597,  597,  598,  599,  599,  600,
+      601,  601,  602,  603,  604,  604,  604,  605,  605,  607,
+      609,  609,  609,  609,  610,  611,  612,  613,  613,  614,
+      615,  616,  617,  619,  621,  622,  623,  624,  625,  626,
+      626,  626,  627,  628,  628,  629,  630,  631,  631,  632,
+
+      632,  633,  634,  635,  636,  637,  638,  638,  639,  640,
+      641,  642,  643,  644,  644,  645,  645,  646,  647,  648,
+      649,  650,  651,  651,  652,  652,  653,  654,  655,  656,
+      657,  658,  659,  659,  659,  660,  661,  662,  663,  664,
+      665,  665,  666,  666,  666,  667,  668,  669,  670,  671,
+      672,  673,  674,  675,  676,  677,  678,  679,  680,  681,
+      682,  683,  684,  685,  686,  687,  688,  689,  690,  691,
+      692,  693,  694,  695,  696,  697,  698,  698,  699,  700,
+      701,  702,  703,  704,  705,  706,  707,  707,  708,  710,
+      710,  711,  711,  711,  711,  711,  711,  712,  713,  714,
+
+      714,  715,  715,  716,  716,  717,  717,  718,  718,  719,
+      720,  720,  721,  722,  723,  724,  725,  726,  727,  727,
+      728,  730,  731,  731,  732,  732,  734,  736,  736,  736,
+      736,  737,  737,  737,  737,  737,  737,  737,  737,  737,
+      737,  737,  737,  737,  737,  738,  739,  740,  740,  740,
+      741,  742,  743,  744,  745,  746,  747,  749,  750,  751,
+      752,  754,  755,  756,  757,  758,  759,  760,  761,  762,
+      763,  764,  765,  766,  767,  768,  769,  770,  771,  772,
+      773,  774,  775,  776,  777,  778,  779,  780,  781,  782,
+      783,  784,  785,  786,  787,  788,  788,  788,  788,  788,
+
+      790,  790,  790,  790,  790,  790,  790,  791,  793,  794,
+      794,  795,  796,  797,  798,  799,  800,  801,  802,  803,
+      803,  803,  803,  803,  803,  803,  803,  803,  803,  803,
+      803,  803,  803,  803,  803,  803,  803,  803,  803,  803,
+      803,  803,  803,  803,  803,  803,  804,  805,  806,  807,
+      808,  809,  810,  811,  812,  813,  814,  815,  816,  817,
+      818,  820,  822,  823,  824,  825,  826,  828,  829,  830,
+      831,  832,  833,  834,  835,  837,  838,  839,  840,  841,
+      842,  843,  844,  845,  846,  848,  849,  850,  851,  852,
+      853,  854,  855,  856,  857,  857,  857,  857,  857,  858,
+
+      858,  858,  858,  858,  858,  860,  862,  864,  864,  865,
+      866,  867,  868,  869,  870,  871,  871,  871,  871,  871,
+      872,  872,  872,  872,  872,  872,  872,  872,  872,  872,
+      872,  872,  872,  872,  872,  872,  872,  872,  872,  872,
+      872,  872,  872,  872,  873,  874,  876,  877,  878,  880,
+      881,  883,  884,  885,  886,  887,  889,  890,  891,  892,
+      894,  895,  896,  897,  898,  899,  900,  901,  902,  903,
+      904,  905,  907,  908,  909,  910,  911,  913,  914,  915,
+      916,  917,  918,  919,  920,  921,  922,  923,  923,  923,
+      923,  923,  924,  924,  924,  924,  926,  927,  929,  929,
+
+      930,  931,  932,  932,  932,  933,  934,  934,  934,  934,
+      934,  934,  934,  934,  934,  934,  934,  934,  934,  934,
+      934,  934,  934,  934,  934,  934,  934,  934,  934,  934,
+      934,  936,  938,  939,  940,  941,  943,  944,  945,  946,
+      947,  948,  949,  950,  952,  953,  954,  955,  956,  957,
+      958,  959,  960,  962,  963,  965,  966,  968,  969,  971,
+      972,  973,  974,  976,  976,  977,  979,  980,  980,  982,
+      982,  982,  982,  982,  982,  983,  983,  984,  984,  985,
+      985,  987,  987,  987,  987,  987,  987,  987,  987,  987,
+      987,  987,  987,  987,  987,  987,  987,  987,  987,  987,
+
+      987,  987,  987,  987,  987,  987,  988,  989,  990,  991,
+      992,  993,  994,  996,  997,  999, 1000, 1001, 1002, 1003,
+     1004, 1005, 1007, 1008, 1010, 1011, 1012, 1014, 1015, 1017,
+     1019, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1022, 1023,
+     1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023,
+     1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
+     1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
+     1024, 1024, 1024, 1024, 1024, 1025, 1026, 1027, 1028, 1029,
+     1030, 1031, 1033, 1034, 1035, 1036, 1037, 1039, 1040, 1041,
+     1042, 1043, 1044, 1045, 1045, 1045, 1046, 1046, 1046, 1046,
+
+     1046, 1046, 1046, 1048, 1049, 1049, 1049, 1050, 1050, 1050,
+     1050, 1050, 1050, 1050, 1050, 1050, 1050, 1051, 1051, 1053,
+     1055, 1057, 1059, 1061, 1063, 1065, 1067, 1069, 1071, 1073,
+     1073, 1073, 1073, 1073, 1073, 1073, 1073, 1073, 1073, 1073,
+     1073, 1073, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080,
+     1081, 1082, 1083, 1084, 1085, 1086, 1087, 1089, 1090, 1091,
+     1091, 1091, 1091, 1091, 1091, 1091, 1092, 1092, 1094, 1094,
+     1094, 1094, 1094, 1094, 1095, 1095, 1095, 1095, 1095, 1095,
+     1097, 1099, 1101, 1103, 1105, 1107, 1109, 1111, 1113, 1115,
+     1117, 1119, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126,
+
+     1128, 1129, 1130, 1132, 1133, 1134, 1135, 1136, 1137, 1137,
+     1137, 1138, 1138, 1139, 1140, 1141, 1141, 1141, 1141, 1142,
+     1143, 1143, 1143, 1143, 1143, 1143, 1143, 1145, 1146, 1147,
+     1148, 1149, 1150, 1151, 1152, 1154, 1156, 1157, 1159, 1160,
+     1162, 1163, 1164, 1165, 1165, 1166, 1167, 1167, 1167, 1167,
+     1167, 1167, 1167, 1167, 1168, 1169, 1170, 1172, 1173, 1174,
+     1175, 1176, 1178, 1179, 1180, 1181, 1182, 1182, 1182, 1182,
+     1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1192,
+     1193, 1193, 1194, 1194, 1195, 1196, 1197, 1198, 1199, 1201,
+     1202, 1203, 1204, 1205, 1206, 1208, 1210, 1211, 1212, 1213,
+
+     1215, 1217, 1218, 1219, 1221, 1223, 1223
+    } ;
+
+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,
+        4,    4,    5,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    1,    5,    6,    7,    8,    1,    9,   10,
-       10,   11,   12,   13,   14,   10,   15,   16,   16,   16,
-       16,   16,   16,   16,   17,   18,   19,   20,    1,   21,
-       22,   23,   10,    1,   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,   47,
-       26,   27,   28,   29,   30,    1,   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,   47,   56,   57,   58,    1,    1,    1,    1,    1,
+        1,    2,    1,    6,    7,    8,    9,    1,   10,   11,
+       12,   13,   14,   15,   16,   17,   18,   19,   19,   19,
+       19,   19,   19,   19,   20,   21,   22,   23,    1,   24,
+       25,   26,   27,    1,   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,   44,
+       53,   54,   55,   56,   57,    1,   58,   59,   60,   61,
+
+       62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
+       72,   73,   44,   74,   75,   76,   77,   78,   79,   80,
+       81,   44,   82,   83,   84,    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,
@@ -413,876 +680,1250 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[59] =
+static yyconst flex_int32_t yy_meta[85] =
     {   0,
-        1,    1,    2,    1,    3,    1,    1,    1,    4,    1,
-        5,    6,    1,    7,    4,    8,    8,    8,    8,    1,
-        1,    1,    1,    9,   10,    1,   11,   12,    1,   13,
-       14,   14,   14,   14,   14,   14,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,    4,    1,   16
+        1,    1,    2,    1,    3,    4,    1,    1,    1,    5,
+        1,    6,    1,    7,    1,    8,    1,    5,    9,    9,
+        9,    9,   10,    1,    1,    1,    1,   11,   11,   11,
+       11,   11,   11,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   13,   14,   15,    1,   16,   11,   11,   11,
+       11,   11,   11,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,    5,    1,   17
     } ;
 
-static yyconst short int yy_base[858] =
+static yyconst flex_int16_t yy_base[1201] =
     {   0,
-        0,   58,  115,  172,  120,  129, 2712, 2711,  230, 2705,
-      136,  141,  288,    0, 2683, 2682,  144,  151,  185,  191,
-      178,  188,  344,  347,  375,    0,  125,  131,  147,  216,
-      431,  434,  461,    0,  519,    0,  205,  349, 2710, 2716,
-      353, 2716, 2706,    0,  360, 2716, 2705,  144,  570, 2696,
-        0, 2716,  577, 2716, 2703, 2716,  438, 2716, 2684,  126,
-      149,  427,  591, 2716, 2701,  141, 2682, 2716,    0, 2716,
-     2699,    0, 2699, 2697,  155, 2696, 2716,    0, 2716, 2695,
-     2716,    0, 2662, 2641, 2637,    0, 2692, 2716, 2690, 2716,
-     2716, 2663,    0, 2716, 2716, 2716, 2688, 2716,  431, 2716,
-
-     2716, 2716, 2687, 2716,  567, 2716, 2669,  571,  164, 2716,
-     2716, 2685,    0, 2667,  573, 2716,    0, 2716, 2683, 2716,
-      573, 2674,    0, 2649, 2628, 2716, 2716,  222, 2716,  356,
-      448, 2716,  450, 2667,    0, 2716, 2678, 2716,    0,    0,
-      198, 2716, 2677, 2621, 2716, 2667,    0, 2642, 2621, 2716,
-     2673, 2716, 2671, 2668, 2640, 2639, 2716,  544, 2639,  579,
-     2634, 2635,  318,    0, 2623, 2631,  424,  562, 2614,  587,
-     2629, 2613, 2618, 2626, 2629, 2604, 2716, 2716, 2653,  612,
-      634, 2716, 2654,    0,  637, 2716, 2653,  600, 2616,    0,
-        0,  641,  647,  651,  669,    0,    0,  453, 2716,    0,
-
-      672, 2716, 2651, 2597,  605, 2716, 2649, 2616,  620,  657,
-      645, 2716,  662,    0, 2716, 2592,  688, 2716, 2646, 2592,
-     2636, 2625, 2716,    0, 2716, 2610,    0, 2716,    0,    0,
-     2642,    0,    0, 2640, 2716,    0, 2716,    0, 2602, 2598,
-      745,    0, 2638, 2716, 2716,    0, 2716,  688, 2716,  773,
-     2716, 2716, 2716, 2716,    0, 2716,  673, 2716,    0, 2716,
-        0, 2599, 2595,  690, 2716,  698,  707, 2716,  709, 2716,
-        0, 2716, 2716,    0,  596, 2579, 2716,  827,    0, 2596,
-     2592, 2632, 2716, 2628, 2716, 2593, 2592,    0,  642, 2582,
-      563, 2617, 2579,  620, 2578, 2577, 2583,  669, 2570, 2584,
-
-     2572,    0, 2569, 2716, 2570, 2571, 2579, 2582,  685,  125,
-     2570, 2567, 2566,  688, 2608, 2716,  716, 2568,    0,    0,
-      720, 2716, 2608,  884, 2562, 2559, 2569,    0,    0,  723,
-     2716,  739, 2716,  805, 2716,  808, 2562,  787,  869,  876,
-      930,  881,  973,  800,    0, 2548, 2716, 2716, 2716, 2570,
-        0, 2559,    0,    0, 2568, 2557,    0, 2716,    0, 1009,
-     2581,  678,  870,  871,  874,  879,  913,  992,  974, 1013,
-      885, 2565, 2554,    0, 1067, 2563, 2552, 2546, 2545, 2557,
-     2562, 2561, 2550, 2557,    0, 2554, 2537, 2556,    0, 2536,
-     2543, 2533, 2548, 2568, 2537, 2549, 2544, 2542, 2541, 2532,
-
-     2539, 2540, 2538, 2539,  578, 2520, 2538, 2525,  860, 2526,
-     2528, 2521, 2517, 2529,  817, 1044, 2716,  822, 1095,  914,
-     2532, 2523, 2517,    0,    0, 2524, 1102, 1025, 1142, 2539,
-     1028, 1163, 2716, 2513, 2521, 2523, 2507,    0, 2526, 1058,
-      891, 1014, 1019,  894, 1038, 1080, 1072, 1086, 1083, 1081,
-     2520, 2504, 2518, 2502, 2716, 2716, 2505, 2493, 2492, 2495,
-     2507, 1148, 2507, 2492,    0,    0, 2492, 2493, 2507,    0,
-     2525, 2490, 2498, 2522, 2485, 2495,    0, 2500, 2491, 2487,
-     2479, 2479, 2483,    0,  875, 2494, 2481, 2494, 2480, 2475,
-     2491, 2519, 2716,  920,  999, 2465, 2474, 2468, 2494, 2496,
-
-     1105, 1184, 1081,  902,  969, 2479, 2491, 2463, 2477, 2716,
-      165, 1090, 1144, 1143, 1147, 1163, 1095, 1145, 1037, 1085,
-     1150, 1173, 2461, 2475, 2459, 2473,    0, 2458,    0, 2460,
-        0, 1165, 2454, 2469,    0, 2461,    0, 2471, 2410, 2414,
-     2434, 2400, 2393, 2405, 2385, 2382,    0, 2383, 2335,    0,
-     2335, 2330, 2326, 2309, 2278, 2259, 2269, 2268, 2256, 2297,
-     1046, 2238, 2242, 2253, 1179, 1142, 1145, 2247, 2246,    0,
-        0, 1191, 1192, 1172, 1201, 1202, 1204, 1205, 1206, 1207,
-     1209, 1210, 1208,    0,    0,    0,    0, 2254,    0, 2221,
-     2229, 2218, 2208, 2200, 2209, 2198, 2195, 2165, 2168, 2149,
-
-     2132,    0,    0, 2129,    0, 2139, 2143, 2134, 2124, 2137,
-     2117, 2116,    0,    0, 1228, 2716, 1232, 2716, 2111, 2716,
-     2117, 2716, 2115, 2114, 2108, 2107, 2106, 2103, 2102, 2098,
-     2095, 2063, 2047, 1213, 2012, 1986, 1975,    0, 1954,    0,
-     1947, 1950, 1941, 1945,    0, 1942,    0,    0,    0, 1938,
-     1940, 1934, 1905,    0, 1872, 1234, 2716, 1888, 1882, 1881,
-     1864, 1848, 1832, 1828, 1827, 1826, 1823, 1806, 1809, 1784,
-     1787, 1772,    0, 1781, 1786,    0, 1766, 1767, 1759, 1744,
-     1213, 1736,    0, 1236, 2716, 1245, 2716, 2716, 2716, 2716,
-     2716, 2716, 2716, 2716, 2716, 2716, 2716, 1750, 1727, 1720,
-
-     1701, 1687, 1670, 1681, 1667, 1679, 1659,  689, 1658, 1671,
-     2716, 1657, 1627, 1621, 1635,    0, 1603, 1596, 1595, 1608,
-     1602, 1587, 1586, 1583, 1581, 1587, 1555,    0, 1547,    0,
-     1527, 1507, 1520, 1503, 1483, 1482, 1485, 1443, 1440, 1228,
-     2716, 1225, 1224, 1206, 1210, 2716, 1213, 1202, 1018,  948,
-     2716,  945, 2716,  884,  780,  771,  779, 2716, 2716,  689,
-      673,  581,  408,  318,   86,    0,    0, 2716, 1263, 1279,
-     1295, 1311, 1327, 1343, 1359, 1375, 1391, 1407, 1423, 1439,
-     1455, 1471, 1481, 1496, 1505, 1520, 1536, 1545, 1560, 1576,
-     1592, 1608, 1624, 1634, 1649, 1659, 1674, 1690, 1706, 1718,
-
-     1728, 1743, 1759, 1775, 1791, 1807, 1817, 1832, 1843, 1236,
-     1858, 1874, 1890, 1898, 1905, 1920, 1936, 1952, 1968, 1977,
-     1985, 2001, 2017, 2033, 2049, 2065, 2081, 2097, 2113, 2123,
-     2138, 2148, 2155, 2170, 2182, 2192, 2207, 2223, 2239, 2255,
-     2265, 2280, 2291, 2306, 2322, 2338, 2354, 2364, 2373, 2388,
-     2404, 2420, 2429, 2437, 2453, 2469, 2485
+        0,   84,  167,  250,  171,  184,  174,  179,  192,  233,
+      196,  200,  334,    0, 3343, 3340,  203,  416,  206,  211,
+      187,  216,  276,  417,  500,    0,  210,  223,  421,  427,
+      436,  440,  583,  588,  669,    0,  277,  299,  584,  751,
+      579,  580,  576,  732,  279,  305,  310,  444, 3378, 3975,
+      228, 3975, 3371,    0,  322, 3975, 3358,  423,  827, 3328,
+        0, 3975,  755, 3975, 3337, 3975,  448, 3312, 3975, 3975,
+     3323, 3291,  222,  408,  444,  764, 3975, 3311,  230, 3289,
+     3975, 3975, 3975, 3306,    0, 3306,  164, 3304, 3975, 3236,
+     3217, 3975, 3975, 3266,  239,  119, 3215, 3212, 3180,    0,
+
+     3248, 3975, 3243, 3975,  476, 3227, 3222, 3975, 3168,    0,
+     3975, 3975, 3975, 3203, 3975,  464, 3975, 3975, 3975, 3186,
+     3975,  742, 3975, 3161,  751,  180, 3975, 3975, 3171,    0,
+     3149,  757, 3975,    0, 3975, 3149, 3975,  200, 3138,    0,
+      429,  241, 3097, 3092, 3975, 3975,  306, 3975,  323, 3975,
+     3975, 3126, 3108, 3072, 3069,    0, 3975, 3115, 3975,    0,
+     3975,  446, 3975, 3114, 3031, 3098,  435,  371, 3045, 3026,
+     3975, 3076, 3975, 3074, 3070,  439,  440, 3975,  578,  751,
+      586,  562,  735,  752,    0,  572,  577,  588,  786,  749,
+      396,  809,  727,  582,  747,  753,  764,  769,  580, 3975,
+
+     3975, 3067,  588, 3975, 3975, 3053, 3002, 2996, 3975, 3975,
+     3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975,    0,
+     3975, 3046, 3975, 3975, 3975, 3018, 2986,  837, 3975, 2998,
+        0,  847, 3975, 2997,  817,  777,    0,    0,  891,  903,
+      912,  924,    0,  774,    0,  451, 3975,    0,  858, 3975,
+     2996, 2914,  472, 3975, 2974, 2953, 3975,  791,  236,  822,
+      899, 3975,  275,    0, 2873, 2872, 3975, 2871,  949, 3975,
+     2949, 2850, 2918, 2906, 3975,    0, 3975,  796, 3975,    0,
+        0, 2925,    0,    0, 2597, 3975, 3975, 3975, 3975,  795,
+      794, 3975, 3975,  484,    0, 2597, 3975,  877, 2596, 2594,
+
+     2594, 3975,    0, 3975,  918, 3975, 1005, 3975, 3975, 3975,
+     3975,    0, 3975,  611, 3975,    0, 3975,    0,  853,  851,
+     3975, 3975,  490, 3975,  608, 3975, 3975, 3975, 3975,    0,
+     3975, 3975,  596, 2510, 3975,    0, 3975, 3975, 2588, 3975,
+     2581, 3975,  894,  906,    0,  911,  717,  727,  923,  728,
+     2571,  882,  930,  889,  902,  916,  917,  940,  928,  923,
+      940,  933,    0,  932, 3975,  935,  939,  951,  956, 1059,
+      964,  965, 1052,  955,  957, 1099, 2578, 3975, 1078, 3975,
+     3975, 3975,    0, 3975, 3975, 3975,  987,    0,    0, 1087,
+     3975, 2576, 1132,  985, 1046, 1058,    0, 1058,    0, 1009,
+
+     3975, 1016, 3975, 1057, 3975, 1099, 3975, 1068,  731, 1088,
+     1095, 1178, 1244, 1280,  988,    0, 3975, 3975, 2492, 1162,
+     3975, 3975, 1081,    0, 1086,    0,    0, 1098, 1105, 1100,
+     3975, 1167, 1245, 1246, 1247, 1250, 2539, 1248, 1249, 1258,
+     1244, 1251, 1259, 1321, 1233, 1224,    0, 1072, 1228, 1243,
+     1261, 1287, 1298, 1289, 1298, 1287,    0, 1299, 1228, 1308,
+        0, 1280, 1298, 1307, 1316, 1314, 1316, 2532, 1322, 1337,
+     1338, 1340, 1342, 1342, 1348, 1353, 1356, 1347, 1357, 1362,
+     1366, 1358, 1353, 1356, 1377, 1366, 1370, 1371, 1367, 1383,
+     1384, 1379, 1391, 1392, 1381, 1388, 1397, 1275, 1455, 3975,
+
+     1439, 1463, 1444, 1415, 1412, 1415,    0, 1409,    0, 1429,
+     1492, 1558, 1594, 1524, 2449, 1564, 1639, 3975, 3975, 1537,
+     1556, 1560, 1407, 2427, 1558, 1563, 1559, 1564, 1572, 1584,
+     1574, 1562, 1615, 1619, 1609, 1625, 1626, 1643, 1614, 1651,
+     1662, 1658, 1664, 1665, 1616, 1616, 1637, 3975, 3975, 1638,
+     1631, 2352, 1634, 1641, 1655, 1650, 1677, 1679, 1671, 1689,
+        0,    0, 1690, 1677, 1681, 1697,    0, 2348, 1684, 1694,
+     2274, 1686, 1685, 1695,    0, 1692, 1711, 1704, 1703, 1701,
+     1713, 1703, 1704, 1712,    0, 1717, 1731, 1731, 1719, 1723,
+     1722, 1741, 1726, 1742, 1734, 1747, 1741, 2241, 3975, 1464,
+
+     1485, 1729, 1743, 1740,    0, 1721, 1591, 2173, 1585, 2139,
+     1771, 1807, 1417,  962, 1426, 1755, 2049, 1745, 1769, 3975,
+     1774, 1782, 1789, 1775, 1796, 1791, 1810, 1800, 1820, 1822,
+     1821, 1823, 1832, 1831, 1838, 1840, 1853, 1856, 1854, 1855,
+     1863, 1865, 1861, 1846, 1862,    0, 1853, 1864,    0, 1857,
+        0, 2008, 1866, 1862, 1869,    0, 1874, 1893, 1870,    0,
+     1888, 1875, 1886, 1882, 1880, 1878, 1897, 1876, 1882, 1889,
+     1889,    0, 1904, 1895, 1899, 1919,    0, 1907, 1909, 1908,
+     1923, 1791, 1924, 1925, 1919, 1747, 1917, 1918, 1918, 1938,
+     1924, 1726, 1599, 1927, 1937, 1970, 3975, 1702, 1652, 1923,
+
+     1755, 1941, 1625, 1618, 3975, 3975, 1961, 1977, 1966, 1969,
+     1956, 1979, 1983, 1986, 1989, 1984, 1992, 1987, 1994, 1990,
+     1988, 1995, 2007, 2004, 2016, 2022, 1996, 2028, 2018, 2026,
+        0,    0, 1620, 1990, 2009,    0, 2035, 2020, 2035, 2029,
+     2024, 2025, 2029, 1589, 2049, 2041, 2052, 2048, 2053, 2054,
+     2044, 2057,    0, 2064,    0, 2048,    0, 1576,    0, 2064,
+     2070, 2056,    0, 2096, 2062,    0, 2067, 2108,    0, 1531,
+     2072, 2078, 1438, 1853, 3975, 2105, 3975, 2068, 3975, 1463,
+     3975, 1407, 1402, 1348, 1345, 1314, 1307, 1269, 1260, 1256,
+     1210, 1158, 2106, 2111, 2097, 2118, 2122, 2129, 2125, 2140,
+
+     2131, 2136, 2141, 2143, 2156, 2131, 2138, 2147, 2101, 2151,
+     2138, 2153,    0, 2141,    0, 2144, 2165, 2153, 2159, 2158,
+     2165,    0, 2165,    0, 2167, 2169,    0, 2178,    0,    0,
+        0, 2183, 2167, 2179, 2210, 2178, 2189, 2188, 2189, 2202,
+     2186, 2194, 2218, 2196, 2202, 1119, 1114, 2206, 2118, 3975,
+     1106, 1100, 1081, 1068, 1065, 1061, 1057,  972,  968,  965,
+      914,  925,  893,  881,  874,  869,  865,  861,  854,  843,
+      807,  802,  776, 2235, 2212, 2226, 2221, 2227, 2239, 2238,
+     2228,    0, 2228, 2239, 2242, 2252,    0, 2238, 2244, 2249,
+     2244, 2258, 2263, 2269, 2255, 3975, 2263, 2265, 2265, 2281,
+
+     2265, 2262,    0, 2285, 2288, 2274, 3975, 2277, 2280, 2295,
+     2279, 2280, 2283, 2303, 2283, 2330, 3975, 2335, 3975, 3975,
+     3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975,  735,
+      612,  608,  598,  441,  374,  261,  245,  202,  152,  149,
+      137,  165, 2296, 2303, 2304, 2320, 2326, 2316, 2324, 2329,
+     2324, 2316, 2319, 2335, 2324, 2327,    0, 2332, 2328, 2327,
+     2332, 2345, 2348, 2352, 2344, 3975, 2338,    0, 2338, 2343,
+     2357, 2362, 2357, 3975, 2371, 2356, 2359, 2358, 2380, 3975,
+     3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975, 3975,
+     3975,  128, 2384, 2382, 2373, 2387, 2376, 2378, 2378,    0,
+
+     2395, 2396,    0, 2385, 2384, 2405, 2403, 2401, 2405, 2413,
+     3975, 2401, 3975, 3975, 3975, 2409, 2416, 2404, 3975, 3975,
+     2400, 2422, 2422, 2414, 2417, 2417, 3975, 2421, 2421, 2418,
+     2424, 2441, 2442, 2443,    0,    0, 2453,    0, 2436,    0,
+     2451, 3975, 3975, 2445, 3975, 3975, 2446, 2457, 2445, 2461,
+     2464, 2462, 2468, 2473, 2466, 2460,    0, 2462, 2459, 2461,
+     2483,    0, 2463, 3975, 3975, 3975, 2484, 2488, 2476, 2482,
+     3975, 2495, 2485, 2497, 2495, 2501, 2506, 2493,    0, 3975,
+     2496, 3975, 2508, 2498, 2506, 2503, 2506, 2505,    0, 2520,
+     3975, 3975, 2522, 2514,    0,    0, 2529, 2514, 2515,    0,
+
+        0, 2533, 2539,    0,    0, 3975, 2601, 2618, 2635, 2652,
+     2669, 2686, 2703, 2720, 2737, 2754, 2771, 2788, 2805, 2822,
+     2839, 2856, 2873, 2890, 2907, 2917, 2933, 2942, 2958, 2975,
+     2986, 3002, 3019, 3036, 3053, 3063, 3079, 3096, 3113, 3127,
+     3137, 3153, 3170, 3187, 3204, 3215, 2009, 3227, 3244, 3254,
+     3270, 3287, 3294, 3300, 3316, 3326, 3342, 3359, 3376, 2564,
+     3386, 3403, 3420, 3437, 3454, 3471, 3488, 3505, 3522, 3532,
+     3548, 3562, 3572, 3588, 3605, 3622, 3639, 3650, 3662, 3679,
+     3696, 3713, 3730, 3740, 3749, 3765, 3782, 3799, 2571, 3809,
+     3826, 3843, 3860, 3877, 3885, 3890, 3906, 3923, 3940, 3957
+
     } ;
 
-static yyconst short int yy_def[858] =
+static yyconst flex_int16_t yy_def[1201] =
     {   0,
-      768,  768,  769,  769,  770,  771,  772,  772,  768,    9,
-      773,  773,  768,   13,  774,  774,  775,  775,  776,  776,
-      777,  777,  778,  778,  768,   25,  779,  779,  780,  780,
-      781,  781,  768,   33,  768,   35,  782,  782,  768,  768,
-      768,  768,  768,  783,  768,  768,  768,  768,  784,  768,
-      785,  768,  768,  768,  768,  768,  768,  768,  768,  786,
-      787,  788,  768,  768,  768,  768,  768,  768,  789,  768,
-      789,  790,  791,  790,  790,  792,  768,  793,  768,  793,
-      768,  794,  794,  794,  793,  795,  768,  768,  795,  768,
-      768,  768,  796,  768,  768,  768,  768,  768,  768,  768,
-
-      768,  768,  768,  768,  787,  768,  768,  787,  797,  768,
-      768,  768,  798,  768,  787,  768,  799,  768,  799,  768,
-      800,  768,  801,  801,  801,  768,  768,  802,  768,  802,
-      803,  768,  803,  768,  804,  768,  804,  768,  805,  806,
-      806,  768,  806,  806,  768,  806,  807,  807,  807,  768,
-      768,  768,  768,  808,  768,  768,  768,  809,  809,  809,
-      809,  809,  809,  809,  809,  809,  809,  810,  809,  809,
-      809,  809,  809,  809,  809,  809,  768,  768,  811,  768,
-      768,  768,  768,  783,  768,  768,  768,  768,  768,  812,
-      813,  768,  768,  768,  768,  814,  815,  816,  768,  785,
-
-      768,  768,  768,  768,  817,  768,  768,  768,  818,  818,
-      819,  768,  768,  820,  768,  821,  768,  768,  768,  768,
-      768,  768,  768,  822,  768,  768,  823,  768,  824,  825,
-      825,  826,  827,  828,  768,  829,  768,  830,  830,  830,
-      768,  831,  768,  768,  768,  832,  768,  768,  768,  833,
-      768,  768,  768,  768,  834,  768,  835,  768,  835,  768,
-      836,  836,  836,  837,  768,  837,  838,  768,  838,  768,
-      839,  768,  768,  840,  840,  840,  768,  768,  841,  841,
-      841,  768,  768,  842,  768,  768,  768,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-
-      843,  843,  843,  768,  843,  843,  843,  843,  843,  843,
-      843,  843,  843,  843,  844,  768,  768,  768,  845,  846,
-      847,  768,  768,  768,  768,  768,  768,  848,  849,  850,
-      768,  850,  768,  851,  768,  851,  768,  852,  852,  852,
-      768,  852,  852,  768,  853,  854,  768,  768,  768,  768,
-      855,  768,  826,  827,  830,  830,  241,  768,  241,  241,
-      833,  833,  833,  833,  833,  833,  833,  833,  833,  833,
-      833,  836,  836,  278,  278,  841,  841,  768,  768,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-
-      843,  843,  843,  843,  843,  843,  843,  843,  768,  843,
-      843,  843,  843,  768,  847,  847,  768,  847,  847,  768,
-      768,  768,  768,  848,  849,  768,  341,  852,  343,  341,
-      852,  343,  768,  768,  768,  830,  830,  360,  768,  833,
-      833,  833,  833,  833,  833,  833,  833,  833,  833,  833,
-      836,  836,  841,  841,  768,  768,  843,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-      843,  843,  843,  843,  768,  768,  768,  843,  843,  843,
-      843,  768,  768,  847,  847,  768,  768,  768,  768,  427,
-
-      852,  343,  852,  852,  852,  768,  768,  830,  830,  768,
-      833,  833,  833,  833,  833,  833,  833,  833,  833,  833,
-      833,  833,  836,  836,  841,  841,  843,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-      843,  768,  768,  768,  768,  843,  843,  843,  843,  768,
-      856,  768,  768,  768,  852,  852,  852,  768,  768,  830,
-      830,  833,  833,  833,  833,  833,  833,  833,  833,  833,
-      833,  833,  833,  836,  836,  841,  841,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  843,
-
-      843,  843,  843,  843,  843,  843,  768,  768,  768,  768,
-      843,  843,  843,  843,  856,  768,  856,  768,  768,  768,
-      768,  768,  833,  833,  833,  833,  833,  833,  833,  833,
-      833,  833,  833,  833,  843,  843,  843,  843,  843,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  843,  768,
-      768,  768,  768,  843,  843,  857,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  833,  843,
-      843,  843,  843,  843,  843,  843,  843,  843,  768,  768,
-      768,  768,  843,  857,  768,  857,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  843,  843,
-
-      843,  843,  843,  843,  843,  768,  768,  768,  768,  768,
-      768,  843,  843,  843,  843,  843,  843,  843,  768,  768,
-      768,  768,  768,  768,  843,  843,  843,  843,  843,  843,
-      768,  768,  768,  768,  768,  768,  843,  843,  843,  843,
-      768,  768,  768,  768,  768,  768,  843,  843,  843,  843,
-      768,  768,  768,  768,  843,  843,  843,  768,  768,  843,
-      843,  843,  843,  843,  843,  843,  843,    0,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768
+     1106, 1106, 1107, 1107, 1108, 1109, 1110, 1110, 1111, 1111,
+     1112, 1112, 1106,   13, 1113, 1113, 1114, 1114, 1115, 1115,
+     1116, 1116, 1117, 1117, 1106,   25, 1118, 1118, 1119, 1119,
+     1120, 1120, 1121, 1121, 1106,   35, 1122, 1122, 1123, 1123,
+     1113, 1113, 1113, 1113, 1124, 1124, 1125, 1125, 1106, 1106,
+     1106, 1106, 1106, 1126, 1106, 1106, 1106, 1106, 1127, 1106,
+     1128, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1129, 1130, 1131, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1132, 1133, 1132, 1134, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1135,
+
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1136,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1130, 1106, 1106, 1130, 1137, 1106, 1106, 1106, 1138,
+     1106, 1130, 1106, 1139, 1106, 1139, 1106, 1140, 1106, 1141,
+     1141, 1141, 1106, 1106, 1106, 1106, 1142, 1106, 1142, 1106,
+     1106, 1106, 1106, 1106, 1106, 1143, 1106, 1143, 1106, 1144,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1145, 1106, 1106, 1106, 1146, 1146,
+     1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1147,
+     1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1106,
+
+     1106, 1148, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1149,
+     1106, 1149, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1150, 1106, 1106, 1106, 1106, 1106, 1151, 1152, 1106, 1106,
+     1106, 1106, 1153, 1151, 1154, 1155, 1106, 1156, 1106, 1106,
+     1106, 1106, 1157, 1106, 1106, 1106, 1106, 1106, 1158, 1158,
+     1159, 1106, 1106, 1160, 1106, 1106, 1106, 1161, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1162, 1106, 1106, 1106, 1163,
+     1164, 1164, 1165, 1166, 1167, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1168, 1169, 1106, 1106, 1106, 1106, 1106,
+
+     1106, 1106, 1170, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1171, 1106, 1172, 1106, 1172, 1106, 1173, 1173, 1173,
+     1106, 1106, 1174, 1106, 1174, 1106, 1106, 1106, 1106, 1175,
+     1106, 1106, 1106, 1106, 1106, 1176, 1106, 1106, 1106, 1106,
+     1177, 1106, 1106, 1106, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1106, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1179, 1106, 1106, 1106,
+     1106, 1106, 1180, 1106, 1106, 1106, 1106, 1181, 1182, 1183,
+     1106, 1106, 1106, 1106, 1106, 1106, 1184, 1181, 1185, 1186,
+
+     1106, 1186, 1106, 1187, 1106, 1187, 1106, 1106, 1188, 1188,
+     1188, 1106, 1188, 1188, 1106, 1189, 1106, 1106, 1190, 1106,
+     1106, 1106, 1106, 1191, 1106, 1192, 1193, 1106, 1106, 1194,
+     1106, 1194, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1196, 1196, 1197, 1106, 1106, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1106, 1106, 1183, 1183, 1106,
+
+     1183, 1183, 1106, 1106, 1106, 1106, 1184, 1198, 1185, 1106,
+     1106, 1188,  414,  412,  412, 1188,  414, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1195, 1196, 1196, 1106, 1106, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1106, 1106, 1106, 1106, 1106, 1183,
+
+     1183, 1106, 1106, 1106, 1198, 1198, 1198, 1106,  511,  511,
+     1188,  414, 1188, 1188, 1188, 1106, 1106, 1106, 1106, 1106,
+     1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1196, 1196, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1106, 1106, 1106,
+     1106, 1106, 1199, 1106, 1106, 1198, 1106, 1198, 1106, 1188,
+
+     1188, 1188, 1106, 1106, 1106, 1106, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1196, 1196, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1106, 1178, 1178, 1178, 1106, 1178, 1106,
+     1106, 1106, 1106, 1199, 1106, 1199, 1106, 1106, 1106, 1106,
+     1106, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+
+     1195, 1195, 1195, 1195, 1195, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1106, 1106, 1106, 1106, 1106, 1106, 1178, 1178, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1200, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
+     1195, 1195, 1195, 1195, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+
+     1106, 1106, 1178, 1178, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1200, 1106, 1200, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1195, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1178, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1178, 1178, 1178,
+     1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1178, 1178, 1178, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1106,
+     1106, 1106, 1106, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+     1106, 1106, 1178, 1178, 1178, 1178, 1178, 1178, 1178, 1178,
+
+     1178, 1178, 1178, 1178, 1178,    0, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106
+
     } ;
 
-static yyconst short int yy_nxt[2775] =
+static yyconst flex_int16_t yy_nxt[4060] =
     {   0,
-       40,   41,   42,   43,   40,   40,   40,   40,   40,   40,
-       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
-       40,   40,   40,   44,   44,   40,   40,   40,   40,   44,
-       44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
-       44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
-       44,   44,   44,   44,   44,   40,   40,   40,   40,   45,
-       46,   47,   40,   48,   40,   49,   40,   40,   40,   40,
-       40,   40,   50,   40,   40,   40,   40,   40,   40,   40,
-       40,   51,   51,   40,   40,   40,   40,   51,   51,   51,
-       51,   51,   51,   51,   51,   51,   51,   51,   51,   51,
-
-       51,   51,   51,   51,   51,   51,   51,   51,   51,   51,
-       51,   51,   51,   40,   40,   40,   53,   54,   55,   56,
-      767,   57,   70,   71,   58,   58,   58,  129,  130,   58,
-       73,   70,   74,  129,  130,   59,   75,   87,   88,   89,
-       60,   61,   87,   88,   89,  188,   96,   97,  224,  132,
-      133,  210,  211,   96,   97,  404,   98,  134,  405,   99,
-       99,   99,   99,   98,  213,  213,   99,   99,   99,   99,
-       62,   58,   58,   63,   64,   65,   56,  252,   57,   66,
-       40,   58,   58,   58,  439,  189,   58,  102,  103,  104,
-       40,  252,   67,  102,  103,  104,  225,   60,   61,  275,
-
-       68,  100,  214,  107,  108,  276,  109,  178,  100,  179,
-      232,  105,  233,  107,  108,  572,  109,  105,  132,  133,
-      180,  180,  180,  180,  265,  266,  134,   62,   58,   58,
-       78,   78,   79,   80,   78,   78,   78,   78,   78,   78,
-       81,   78,   78,   78,   78,   78,   78,   78,   78,   78,
-       78,   78,   78,   82,   82,   78,   78,   78,   78,   82,
+       50,   51,   52,   50,   53,   50,   50,   50,   50,   50,
+       50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
+       50,   50,   50,   50,   50,   50,   50,   54,   54,   54,
+       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
+       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
+       54,   54,   50,   50,   50,   50,   54,   54,   54,   54,
+       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
+       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
+       54,   50,   50,   50,   50,   55,   56,   50,   57,   50,
+       58,   50,   59,   50,   50,   50,   50,   50,   50,   50,
+
+       50,   60,   50,   50,   50,   50,   50,   50,   50,   50,
+       50,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   50,   50,   50,   50,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   50,   50,   50,   63,   64,
+      291,   65,   66,   83,   67,   84,   89,   68,   69,   70,
+       70,   89, 1027,   70,   71,   86,   83,  992,   84,   50,
+       72,  991,   87,   70,   93,  309,   94,  101,  102,  291,
+
+      103,  101,  102,  990,  103,  113,  989,  114,  119,  315,
+      120,  121,  148,  119,  149,  120,  121,  115,   50,   73,
+       74,  116,  116,  116,  116,  148,   90,  149,   91,  228,
+      229,   90,  230,   91,  309,   93,   95,   94,  276,  124,
+      125,   99,  126,   96,   97,  283,   98,  284,   75,   70,
+       70,   76,   77,  316,   78,   66,  988,   67,   79,  122,
+       68,   69,   70,   70,  122,   95,   70,   71,  124,  125,
+      290,  126,   96,   80,  260,  261,   70,   95,  128,  201,
+      129,  221,  202,  222,   96,   97,  117,   98,  410,  411,
+      223,  130,  320,  415,  415,  203,  203,  203,  203,  987,
+
+      290,  201,   73,   74,  202,   81,   95,  221,  324,  222,
+      325,  277,  225,   96,  226,  986,  223,  203,  203,  203,
+      203,  320,  227,  232,  233,  324,  234,  325,  131,  132,
+      133,   75,   70,   70,  104,  105,  106,  104,  107,  104,
+      104,  104,  104,  104,  104,  104,  108,  104,  108,  104,
+      104,  104,  104,  104,  104,  104,  104,  104,  104,  109,
+      104,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  104,  104,  104,  104,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  104,  104,  104,  113,  128,
+      114,  129,  291,  151,  235,  152,  263,  263,  985,  151,
+      115,  152,  130,  153,  116,  116,  116,  116,  157,  153,
+      158,  159,  157,  366,  158,  159,  225,  333,  226,  254,
+      254,  291,  255,  401,  334,  402,  227,  265,  264,  266,
+      319,  236,  267,  267,  267,  267,  290,  343,  344,  131,
+      132,  133,  366,  154,  405,  155,  406,  298,  299,  154,
+      300,  155,  305,  305,  305,  305,  431,  264,  432,  160,
+      319,  236,  324,  160,  325,  984,  290,  343,  344,  117,
+
+      134,  134,  135,  134,  136,  137,  134,  134,  134,  138,
+      134,  134,  134,  134,  134,  134,  134,  139,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  140,  140,  140,
+      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
+      140,  140,  140,  140,  141,  140,  140,  140,  140,  140,
+      140,  142,  143,  134,  144,  134,  140,  140,  140,  140,
+      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
+      140,  140,  140,  141,  140,  140,  140,  140,  140,  140,
+      142,  145,  134,  146,  162,  163,  205,  164,  206,  162,
+      163,  165,  164,  353,  211,  211,  165,  333,  216,  351,
+
+      166,  212,  212,  358,  334,  166,  379,  379,  379,  379,
+      324,  217,  325,  352,  213,  213,  346,  359,  347,  360,
+      315,  218,  348,  353,  214,  214,  219,  167,  371,  215,
+      215,  376,  167,  358,  168,  169,  207,  170,  208,  168,
+      169,  217,  170,  352,  213,  213,  346,  359,  347,  360,
+      218,  348,  983,  214,  214,  219,  167,  371,  215,  215,
+      376,  167,  982,  168,  316,  209,  981,  210,  168,  171,
+      172,  173,  171,  174,  175,  171,  171,  171,  171,  171,
+      171,  171,  171,  171,  171,  171,  171,  171,  176,  177,
+      171,  171,  171,  178,  171,  171,  179,  180,  181,  182,
+
+      183,  184,  185,  186,  187,  185,  185,  188,  189,  190,
+      191,  192,  185,  193,  194,  195,  196,  197,  198,  185,
+      199,  171,  171,  171,  171,  171,  179,  180,  181,  182,
+      183,  184,  185,  186,  187,  185,  185,  188,  189,  190,
+      191,  192,  193,  194,  195,  196,  197,  198,  185,  199,
+      171,  171,  171,  205,  216,  206,  249,  250,  370,  251,
+      263,  263,  452,  252,  354,  269,  270,  217,  271,  263,
+      263,  453,  272,  456,  372,  263,  263,  218,  349,  356,
+      364,  273,  219,  410,  411,  355,  350,  274,  370,  980,
+      365,  452,  264,  373,  354,  374,  375,  217,  941,  357,
+
+      453,  264,  456,  207,  372,  208,  218,  264,  349,  356,
+      364,  219,  387,  361,  355,  398,  350,  362,  235,  275,
+      365,  264,  408,  373,  940,  374,  375,  425,  357,  939,
+      264,  428,  209,  429,  210,  238,  264,  253,  228,  229,
+      367,  230,  387,  361,  412,  398,  253,  362,  232,  233,
+      368,  234,  408,  369,  239,  236,  240,  425,  240,  249,
+      250,  428,  251,  429,  240,  938,  252,  240,  241,  242,
+      367,  240,  243,  244,  410,  411,  937,  245,  298,  299,
+      368,  300,  369,  936,  239,  236,  240,  935,  240,  445,
+      446,  934,  390,  391,  240,  392,  933,  240,  241,  242,
+
+      240,  243,  244,  932,  390,  391,  245,  392,  246,  393,
+      393,  393,  393,  390,  391,  931,  392,  413,  413,  445,
+      446,  393,  393,  393,  393,  390,  391,  458,  392,  448,
+      393,  393,  393,  393,  461,  394,  305,  305,  305,  305,
+      253,  449,  393,  393,  393,  393,  450,  930,  462,  414,
+      269,  270,  454,  271,  395,  464,  458,  272,  459,  448,
+      451,  463,  460,  461,  394,  396,  273,  465,  929,  455,
+      466,  449,  274,  468,  467,  469,  450,  462,  414,  470,
+      471,  472,  454,  473,  395,  464,  474,  476,  459,  451,
+      463,  480,  460,  482,  481,  396,  475,  465,  455,  485,
+
+      466,  486,  468,  467,  275,  469,  262,  262,  470,  471,
+      472,  401,  473,  402,  410,  411,  474,  476,  401,  928,
+      402,  480,  927,  482,  481,  475,  926,  497,  485,  504,
+      486,  253,  433,  434,  435,  436,  437,  437,  438,  437,
+      437,  437,  437,  439,  437,  437,  437,  440,  437,  437,
+      441,  437,  442,  437,  437,  443,  437,  497,  504,  405,
+      444,  406,  433,  434,  435,  436,  437,  437,  438,  437,
+      437,  437,  437,  439,  437,  437,  437,  440,  437,  441,
+      437,  442,  437,  437,  443,  437,  477,  483,  499,  500,
+      478,  501,  505,  506,  484,  479,  379,  379,  379,  379,
+
+      508,  405,  431,  406,  432,  502,  502,  502,  502,  510,
+      511,  925,  520,  512,  512,  924,  477,  483,  548,  923,
+      478,  505,  922,  506,  484,  479,  487,  521,  488,  522,
+      508,  489,  490,  503,  391,  921,  392,  491,  492,  510,
+      410,  411,  520,  493,  494,  513,  523,  548,  495,  409,
+      393,  393,  393,  393,  920,  496,  487,  521,  488,  522,
+      919,  489,  490,  519,  519,  519,  519,  491,  492,  431,
+      914,  432,  493,  494,  513,  913,  523,  495,  409,  409,
+      861,  409,  409,  409,  409,  409,  409,  409,  409,  409,
+      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
+
+      409,  409,  409,  409,  409,  514,  514,  514,  514,  514,
+      514,  514,  514,  514,  514,  514,  514,  514,  514,  514,
+      514,  514,  514,  514,  514,  514,  514,  514,  514,  514,
+      410,  411,  860,  515,  409,  514,  514,  514,  514,  514,
+      514,  514,  514,  514,  514,  514,  514,  514,  514,  514,
+      514,  514,  514,  514,  514,  514,  514,  514,  514,  409,
+      409,  409,  516,  516,  546,  547,  524,  524,  524,  524,
+      524,  524,  524,  524,  549,  558,  550,  599,  859,  600,
+      524,  524,  858,  525,  526,  528,  533,  527,  551,  535,
+      530,  857,  529,  534,  546,  547,  410,  411,  517,  517,
+
+      517,  517,  531,  549,  558,  532,  550,  517,  517,  517,
+      517,  517,  517,  525,  526,  528,  533,  527,  551,  535,
+      530,  529,  552,  534,  560,  553,  554,  555,  556,  856,
+      557,  531,  410,  411,  532,  559,  855,  517,  517,  517,
+      517,  517,  517, 1106,  561,  562,  563,  565,  536,  537,
+      538,  539,  552,  560,  540,  553,  554,  555,  556,  541,
+      557,  564,  567,  542,  568,  559,  543,  854,  544,  569,
+      853,  545,  570,  561,  571,  562,  563,  565,  536,  537,
+      538,  539,  572,  573,  540,  574,  575,  576,  577,  541,
+      564,  578,  567,  542,  568,  543,  581,  544,  582,  569,
+
+      545,  579,  570,  583,  571,  584,  585,  580,  586,  587,
+      606,  588,  572,  573,  589,  574,  575,  576,  577,  590,
+      591,  578,  592,  593,  852,  594,  581,  582,  598,  851,
+      595,  579,  583,  596,  597,  584,  585,  580,  586,  587,
+      588,  500,  602,  600,  589,  503,  391,  603,  392,  590,
+      591,  619,  592,  593,  594,  604,  499,  500,  598,  501,
+      595,  608,  596,  597,  601,  500,  599,  501,  600,  410,
+      411,  259,  602,  502,  502,  502,  502,  603,  410,  411,
+      619,  502,  502,  502,  502,  604,  601,  500,  850,  501,
+      607,  608,  409,  409,  848,  409,  409,  409,  409,  409,
+
+      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
+      409,  409,  409,  409,  409,  409,  409,  409,  409,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  410,  411,  613,  610,  409,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  409,  409,  409,  611,  611,  616,  409,
+      524,  524,  614,  614,  524,  524,  524,  845,  617,  618,
+      623,  828,  696,  697,  524,  698,  524,  625,  621,  626,
+
+      622,  775,  629,  776,  817,  624,  524,  700,  616,  628,
+      410,  411,  612,  612,  612,  612,  410,  411,  617,  618,
+      623,  612,  612,  612,  612,  612,  612,  625,  621,  626,
+      622,  524,  629,  627,  624,  806,  524,  524,  524,  628,
+      409,  524,  630,  781,  632,  644,  643,  524,  524,  636,
+      780,  612,  612,  612,  612,  612,  612,  615,  615,  615,
+      615,  631,  627,  633,  634,  524,  615,  615,  615,  615,
+      615,  615,  630,  524,  632,  644,  643,  779,  646,  636,
+      524,  645,  647,  635,  524,  649,  524,  524,  650,  651,
+      652,  631,  653,  633,  634,  637,  615,  615,  615,  615,
+
+      615,  615,  639,  638,  697,  640,  641,  642,  646,  654,
+      645,  647,  656,  635,  649,  655,  658,  650,  657,  651,
+      652,  659,  606,  660,  637,  661,  662,  692,  664,  665,
+      669,  639,  667,  638,  640,  668,  641,  642,  670,  654,
+      671,  672,  656,  673,  675,  655,  658,  657,  674,  676,
+      677,  659,  660,  678,  661,  679,  662,  664,  680,  665,
+      669,  667,  681,  683,  668,  682,  684,  670,  685,  687,
+      671,  672,  686,  673,  675,  688,  690,  674,  676,  677,
+      693,  689,  691,  678,  694,  679,  695,  703,  680,  701,
+      701,  705,  681,  683,  682,  684,  524,  524,  685,  687,
+
+      706,  686,  607,  768,  524,  688,  690,  410,  411,  693,
+      689,  524,  691,  524,  694,  695,  708,  703,  524,  710,
+      705,  707,  524,  410,  411,  702,  702,  702,  702,  709,
+      706,  711,  524,  712,  702,  702,  702,  702,  702,  702,
+      714,  713,  524,  524,  524,  524,  708,  764,  710,  715,
+      707,  716,  717,  524,  524,  775,  718,  776,  721,  709,
+      524,  711,  524,  712,  702,  702,  702,  702,  702,  702,
+      714,  713,  719,  723,  720,  524,  524,  524,  524,  715,
+      724,  716,  717,  524,  722,  524,  718,  524,  721,  726,
+      728,  752,  731,  732,  734,  727,  730,  748,  733,  736,
+
+      741,  738,  719,  723,  720,  725,  735,  729,  743,  740,
+      724,  739,  742,  722,  744,  745,  746,  747,  749,  726,
+      728,  731,  750,  732,  734,  727,  730,  733,  751,  736,
+      741,  738,  753,  754,  725,  755,  735,  729,  740,  756,
+      739,  757,  742,  744,  758,  745,  746,  747,  749,  759,
+      761,  750,  760,  762,  763,  765,  766,  767,  751,  769,
+      770,  753,  754,  771,  755,  772,  773,  777,  778,  756,
+      757,  696,  697,  758,  698,  410,  411,  409,  524,  759,
+      761,  760,  762,  524,  763,  765,  766,  767,  524,  769,
+      770,  524,  771,  410,  411,  772,  773,  777,  778,  524,
+
+      782,  524,  786,  784,  783,  524,  524,  785,  524,  524,
+      524,  524,  524,  787,  524,  791,  524,  524,  524,  363,
+      363,  807,  793,  737,  795,  802,  524,  788,  796,  524,
+      782,  786,  789,  784,  783,  790,  792,  785,  524,  797,
+      524,  794,  798,  787,  524,  791,  799,  800,  524,  804,
+      524,  807,  793,  808,  795,  802,  788,  803,  796,  805,
+      811,  789,  801,  809,  790,  792,  812,  813,  797,  814,
+      794,  815,  798,  810,  704,  816,  799,  800,  818,  804,
+      819,  820,  808,  821,  822,  823,  825,  803,  824,  805,
+      811,  826,  801,  809,  827,  829,  812,  813,  814,  830,
+
+      815,  831,  838,  810,  816,  839,  846,  775,  818,  776,
+      819,  820,  849,  821,  822,  823,  825,  824,  847,  524,
+      917,  826,  918,  827,  864,  829,  832,  833,  524,  830,
+      831,  834,  838,  524,  835,  839,  846,  836,  840,  841,
+      524,  849,  837,  842,  524,  878,  843,  524,  847,  844,
+      863,  524,  862,  524,  864,  865,  832,  833,  524,  868,
+      866,  834,  524,  524,  835,  524,  875,  836,  840,  841,
+      876,  837,  872,  842,  878,  867,  843,  870,  524,  844,
+      863,  862,  871,  880,  869,  865,  882,  873,  877,  868,
+      866,  874,  879,  881,  409,  883,  875,  884,  699,  885,
+
+      876,  886,  872,  887,  867,  888,  870,  889,  890,  891,
+      892,  871,  880,  869,  894,  882,  873,  895,  877,  896,
+      902,  874,  879,  881,  883,  901,  893,  884,  885,  903,
+      904,  886,  887,  905,  907,  888,  906,  889,  890,  891,
+      892,  897,  692,  911,  894,  898,  895,  912,  899,  896,
+      902,  915,  943,  908,  901,  893,  909,  524,  900,  903,
+      904,  944,  946,  905,  907,  906,  910,  945,  947,  948,
+      950,  897,  911,  949,  951,  898,  912,  952,  899,  953,
+      915,  942,  943,  908,  954,  955,  909,  900,  956,  666,
+      957,  944,  946,  958,  959,  910,  945,  960,  947,  948,
+
+      950,  961,  949,  962,  951,  963,  964,  952,  965,  953,
+      942,  966,  967,  954,  968,  955,  969,  971,  956,  957,
+      970,  972,  973,  958,  959,  974,  975,  960,  976,  979,
+      961,  977,  917,  962,  918,  963,  964,  917,  965,  918,
+      966,  967,  993,  994,  968,  995,  969,  971,  978,  970,
+      996,  972,  973,  997,  974,  975,  998,  976,  979,  999,
+     1000,  977, 1001,  663, 1002, 1003, 1004,  648, 1005, 1006,
+     1007,  993, 1008,  994, 1009,  995, 1010,  978, 1011, 1012,
+      996, 1013, 1014,  997, 1015, 1016,  998, 1017, 1018,  999,
+     1000, 1019, 1001, 1002, 1003, 1020, 1004, 1005, 1021, 1006,
+
+     1007, 1008, 1022, 1009, 1025, 1010, 1023, 1026, 1011, 1012,
+     1024, 1013, 1014, 1015, 1016, 1028, 1017, 1029, 1018, 1030,
+     1031, 1019, 1032, 1033, 1034, 1020, 1035, 1036, 1021, 1037,
+     1038, 1022, 1039, 1025, 1040, 1023, 1041, 1026, 1042, 1024,
+     1043, 1044, 1045, 1046, 1047, 1028, 1048, 1029, 1030, 1049,
+     1031, 1032, 1033, 1034, 1050, 1057, 1035, 1036, 1037, 1038,
+     1051, 1052, 1039, 1053, 1040, 1054, 1041, 1055, 1042, 1056,
+     1043, 1044, 1045, 1046, 1047, 1048, 1058, 1059, 1060, 1049,
+     1061,  620, 1062, 1063, 1050, 1057, 1064, 1065, 1066, 1051,
+     1052, 1067, 1053, 1068, 1054, 1069, 1055, 1070, 1056, 1071,
+
+     1072, 1073, 1074, 1075,  409, 1076, 1058, 1059, 1060, 1077,
+     1061, 1062, 1078, 1063, 1079, 1080, 1064, 1065, 1066, 1081,
+     1067, 1082, 1083, 1068, 1084, 1069, 1085, 1070, 1086, 1071,
+     1072, 1073, 1074, 1075, 1076, 1087, 1088, 1089, 1077, 1090,
+     1091, 1092, 1078, 1079, 1093, 1080, 1094,  566, 1095, 1081,
+     1082, 1096, 1083, 1097, 1084, 1098, 1085, 1099, 1086, 1100,
+     1101,  524, 1102, 1103, 1104, 1087, 1088, 1089, 1090, 1091,
+     1105, 1092,  416, 1093,  416,  420, 1094, 1095,  391,  518,
+     1096,  518, 1097,  378,  457, 1098,  342, 1099, 1100,  339,
+     1101, 1102, 1103,  336, 1104,  301,  299,  301,  296,  286,
+
+     1105,   62,   62,   62,   62,   62,   62,   62,   62,   62,
+       62,   62,   62,   62,   62,   62,   62,   62,   82,   82,
        82,   82,   82,   82,   82,   82,   82,   82,   82,   82,
-       82,   82,   82,   82,   82,   82,   82,   83,   82,   82,
-       82,   82,   82,   82,   84,   78,   78,   78,   90,   90,
-       40,   90,   90,   90,   90,   90,   90,   90,   91,   90,
-
-       91,   90,   90,   90,   90,   90,   90,   90,   90,   90,
-       92,   93,   93,   90,   90,   90,   90,   93,   93,   93,
-       93,   93,   93,   93,   93,   93,   93,   93,   93,   93,
-       93,   93,   93,   93,   93,   93,   93,   93,   93,   93,
-       93,   93,   93,   90,   90,   90,  111,  112,  296,  111,
-      112,  178,  766,  179,  181,  182,  183,  113,  265,  266,
-      113,  185,  186,  187,  180,  180,  180,  180,  297,  114,
-      115,  116,  114,  115,  116,  117,  117,  118,  119,  120,
-      117,  117,  117,  121,  117,  117,  117,  117,  117,  122,
-      117,  117,  117,  117,  117,  117,  117,  117,  123,  123,
-
-      117,  117,  117,  117,  123,  123,  123,  123,  123,  123,
+       82,   82,   82,   82,   82,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   88,   88,   88,   88,   88,   88,   88,   88,
+       88,   88,   88,   88,   88,   88,   88,   88,   88,   92,
+       92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
+       92,   92,   92,   92,   92,   92,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+
+      100,  100,  100,   50,   50,   50,   50,   50,   50,   50,
+       50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
+      112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
+      112,  112,  112,  112,  112,  112,  112,  118,  118,  118,
+      118,  118,  118,  118,  118,  118,  118,  118,  118,  118,
+      118,  118,  118,  118,  123,  123,  123,  123,  123,  123,
       123,  123,  123,  123,  123,  123,  123,  123,  123,  123,
-      123,  123,  124,  123,  123,  123,  123,  123,  123,  125,
-      126,  117,  127,  136,  137,  138,  136,  137,  138,  206,
-      206,  207,  215,  215,  215,  215,  248,  248,  248,  248,
-      268,  269,  268,  269,  300,  331,  332,  139,  301,  765,
-      139,  140,  141,  142,  143,  140,  140,  140,  144,  140,
-      140,  145,  140,  140,  140,  146,  140,  140,  140,  140,
-      140,  140,  140,  140,  147,  147,  140,  140,  140,  140,
+      123,  127,  127,  127,  127,  127,  127,  127,  127,  127,
+      127,  127,  127,  127,  127,  127,  127,  127,  147,  147,
       147,  147,  147,  147,  147,  147,  147,  147,  147,  147,
 
-      147,  147,  147,  147,  147,  147,  147,  147,  148,  147,
-      147,  147,  147,  147,  147,  149,  140,  140,  140,  150,
-      151,  152,  153,  154,  150,  150,  150,  150,  150,  150,
-      150,  150,  150,  150,  150,  155,  156,  150,  150,  150,
-      157,  150,  150,  150,  150,  150,  150,  150,  150,  158,
-      159,  160,  161,  162,  163,  164,  164,  165,  164,  164,
-      166,  167,  168,  169,  170,  164,  171,  172,  164,  173,
-      174,  175,  164,  176,  150,  150,  150,  191,  201,  202,
-      203,  258,  213,  213,  204,  289,  213,  213,  213,  213,
-      292,  290,  217,  218,  219,  383,  303,  275,  220,  259,
-
-      192,  188,  193,  276,  193,  221,  304,  335,  336,  293,
-      193,  222,  384,  193,  194,  195,  480,  193,  196,  223,
-      214,  306,  481,  197,  214,  198,  214,  317,  317,  317,
-      317,  307,  764,  205,  308,  181,  182,  183,  185,  186,
-      187,  189,  321,  322,  323,  339,  340,  205,  321,  322,
-      323,  387,  321,  322,  323,  388,  324,  324,  324,  324,
-      342,  342,  324,  324,  324,  324,  324,  324,  324,  324,
-      321,  322,  323,  201,  202,  203,  341,  344,  344,  204,
-      380,  258,  339,  340,  324,  324,  324,  324,  325,  217,
-      218,  219,  265,  266,  381,  220,  326,  439,  343,  259,
-
-      265,  266,  221,  248,  248,  248,  248,  673,  222,  268,
-      269,  268,  269,  327,  392,  402,  223,  409,  393,  440,
-      410,  416,  417,  418,  403,  331,  332,  763,  205,  411,
-      412,  317,  317,  317,  317,  419,  419,  419,  419,  721,
-      413,  331,  332,  722,  205,  357,  357,  358,  359,  357,
-      357,  357,  357,  357,  357,  360,  357,  357,  357,  357,
-      357,  357,  357,  357,  357,  357,  357,  357,  360,  360,
-      357,  357,  357,  357,  360,  360,  360,  360,  360,  360,
-      360,  360,  360,  360,  360,  360,  360,  360,  360,  360,
-      360,  360,  360,  360,  360,  360,  360,  360,  360,  360,
-
-      357,  357,  357,  362,  363,  364,  365,  335,  336,  366,
-      335,  336,  339,  340,  367,  212,  212,  762,  368,  493,
-      494,  369,  761,  370,  417,  494,  371,  374,  374,  760,
-      374,  374,  374,  374,  374,  374,  374,  375,  374,  374,
-      374,  374,  374,  374,  374,  374,  374,  374,  374,  374,
-      375,  375,  374,  374,  374,  374,  375,  375,  375,  375,
-      375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
-      375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
-      375,  375,  374,  374,  374,  420,  322,  323,  427,  439,
-      439,  428,  428,  439,  339,  340,  431,  431,  439,  324,
-
-      324,  324,  324,  338,  439,  485,  339,  340,  486,  487,
-      439,  441,  443,  439,  442,  420,  322,  323,  450,  552,
-      759,  513,  493,  494,  516,  553,  444,  339,  340,  429,
-      338,  338,  439,  338,  338,  338,  338,  338,  338,  338,
-      338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
-      338,  338,  338,  430,  430,  339,  340,  445,  338,  338,
+      147,  147,  147,  147,  147,  150,  150,  150,  150,  150,
+      150,  150,  150,  150,  150,  150,  150,  150,  150,  150,
+      150,  150,  156,  156,  156,  156,  156,  156,  156,  156,
+      156,  156,  156,  156,  156,  156,  156,  156,  156,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  200,  200,  200,  200,
+      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
+      200,  200,  200,  204,  204,  204,  204,  204,  204,  204,
+      204,  204,  204,  204,  204,  204,  204,  204,  204,  204,
+      220,  220,  220,  220,  220,  220,  220,  220,  220,  220,
+
+      220,  220,  220,  220,  220,  220,  220,  224,  224,  224,
+      224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
+      224,  224,  224,  224,  231,  231,  282,  231,  231,  423,
+      422,  421,  231,  237,  237,  237,  237,  237,  237,  237,
+      237,  237,  237,  237,  237,  237,  237,  237,  237,  248,
+      248,  270,  248,  248,  420,  418,  417,  248,  259,  407,
+      259,  259,  259,  259,  259,  259,  259,  259,  259,  259,
+      259,  259,  259,  259,  259,  262,  254,  262,  262,  262,
+      262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
+      262,  262,  268,  268,  268,  403,  268,  268,  250,  233,
+
+      229,  268,  280,  386,  280,  280,  280,  280,  280,  280,
+      280,  280,  280,  280,  280,  280,  280,  280,  280,  281,
+      385,  281,  281,  281,  281,  281,  281,  281,  281,  281,
+      281,  281,  281,  281,  281,  281,  285,  285,  285,  285,
+      285,  285,  285,  285,  285,  285,  285,  285,  384,  285,
+      382,  285,  285,  295,  381,  380,  295,  295,  295,  295,
+      295,  295,  295,  295,  295,  295,  295,  295,  295,  295,
+      303,  303,  378,  303,  303,  342,  340,  339,  303,  308,
+      338,  308,  308,  308,  308,  308,  308,  308,  308,  308,
+      308,  308,  308,  308,  308,  308,  311,  337,  311,  311,
+
+      311,  311,  311,  311,  311,  311,  311,  311,  311,  311,
+      317,  311,  311,  312,  336,  312,  335,  331,  312,  312,
+      312,  312,  312,  329,  328,  327,  312,  314,  326,  314,
+      314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
+      314,  314,  314,  314,  318,  318,  322,  318,  318,  321,
+      317,  313,  318,  323,  323,  323,  323,  323,  323,  323,
+      323,  323,  323,  323,  323,  323,  323,  323,  323,  323,
+      330,  307,  330,  310,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  307,  330,  330,  330,  332,  306,  332,
+      332,  332,  332,  332,  332,  332,  332,  332,  332,  332,
+
+      332,  332,  332,  332,  341,  304,  341,  341,  341,  341,
+      341,  341,  341,  341,  341,  341,  341,  341,  341,  341,
+      341,  345,  345,  302,  299,  345,  345,  377,  301,  377,
+      377,  377,  377,  377,  377,  377,  377,  377,  377,  377,
+      377,  377,  377,  377,  383,  297,  383,  383,  383,  296,
+      383,  383,  383,  383,  383,  383,  383,  383,  383,  383,
+      383,  231,  231,  294,  231,  231,  293,  292,  289,  231,
+      388,  288,  388,  388,  388,  388,  388,  388,  388,  388,
+      388,  388,  388,  388,  388,  388,  388,  389,  287,  389,
+      389,  389,  389,  389,  389,  389,  389,  389,  389,  389,
+
+      389,  389,  389,  389,  397,  397,  286,  282,  279,  397,
+      399,  399,  278,  270,  258,  399,  400,  400,  400,  400,
+      400,  400,  400,  400,  400,  400,  400,  400,  400,  400,
+      400,  400,  400,  248,  248,  257,  248,  248,  256,  250,
+      247,  248,  404,  404,  404,  404,  404,  404,  404,  404,
+      404,  404,  404,  404,  404,  404,  404,  404,  404,  409,
+      233,  409,  409,  409,  409,  409,  409,  409,  409,  409,
+      409,  409,  409,  229,  409,  409,  259, 1106,  259,  259,
+      259,  259,  259,  259,  259,  259,  259,  259,  259,  259,
+      259,  259,  259,  419,  419,  111,  419,  419,  111, 1106,
+
+     1106,  419,  419,  424, 1106,  424,  424,  424,  424,  424,
+      424,  424,  424,  424,  424,  424,  424,  424,  424,  424,
+      280, 1106,  280,  280,  280,  280,  280,  280,  280,  280,
+      280,  280,  280,  280,  280,  280,  280,  281, 1106,  281,
+      281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
+      281,  281,  281,  281,  426, 1106,  426,  426,  426,  426,
+      426,  426,  426,  426,  426,  426,  426,  426,  426,  426,
+      426,  427, 1106,  427,  427,  427,  427,  427,  427,  427,
+      427,  427,  427,  427,  427,  427,  427,  427,  285,  285,
+      285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
+
+     1106,  285, 1106,  285,  285,  430,  430,  430,  430,  430,
       430,  430,  430,  430,  430,  430,  430,  430,  430,  430,
+      430,  430,  295, 1106, 1106,  295,  295,  295,  295,  295,
+      295,  295,  295,  295,  295,  295,  295,  295,  295,  303,
+      303, 1106,  303,  303, 1106, 1106, 1106,  303,  312, 1106,
+      312, 1106, 1106,  312,  312,  312,  312,  312, 1106, 1106,
+     1106,  312,  314, 1106,  314,  314,  314,  314,  314,  314,
+      314,  314,  314,  314,  314,  314,  314,  314,  314,  318,
+      318, 1106,  318,  318, 1106, 1106, 1106,  318,  323,  323,
+      323,  323,  323,  323,  323,  323,  323,  323,  323,  323,
+
+      323,  323,  323,  323,  323,  330, 1106,  330, 1106,  330,
+      330,  330,  330,  330,  330,  330,  330,  330, 1106,  330,
+      330,  330,  447, 1106,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  341,
+     1106,  341,  341,  341,  341,  341,  341,  341,  341,  341,
+      341,  341,  341,  341,  341,  341,  345,  345, 1106, 1106,
+      345,  345,  377, 1106,  377,  377,  377,  377,  377,  377,
+      377,  377,  377,  377,  377,  377,  377,  377,  377,  383,
+     1106,  383,  383,  383, 1106,  383,  383,  383,  383,  383,
+      383,  383,  383,  383,  383,  383,  388, 1106,  388,  388,
+
+      388,  388,  388,  388,  388,  388,  388,  388,  388,  388,
+      388,  388,  388,  389, 1106,  389,  389,  389,  389,  389,
+      389,  389,  389,  389,  389,  389,  389,  389,  389,  389,
+      498,  498,  498,  498,  498,  498,  498,  498,  498,  498,
+      498,  498,  498,  498,  498,  498,  498,  507,  507, 1106,
+      507,  507, 1106, 1106, 1106,  507,  509,  509, 1106,  509,
+      509, 1106, 1106, 1106,  509,  400,  400,  400,  400,  400,
+      400,  400,  400,  400,  400,  400,  400,  400,  400,  400,
+      400,  400,  404,  404,  404,  404,  404,  404,  404,  404,
+      404,  404,  404,  404,  404,  404,  404,  404,  404,  409,
+
+     1106,  409,  409,  409,  409,  409,  409,  409,  409,  409,
+      409,  409,  409, 1106,  409,  409,  419,  419, 1106,  419,
+      419, 1106, 1106, 1106,  419,  419,  424, 1106,  424,  424,
+      424,  424,  424,  424,  424,  424,  424,  424,  424,  424,
+      424,  424,  424,  426, 1106,  426,  426,  426,  426,  426,
+      426,  426,  426,  426,  426,  426,  426,  426,  426,  426,
+      427, 1106,  427,  427,  427,  427,  427,  427,  427,  427,
+      427,  427,  427,  427,  427,  427,  427,  430,  430,  430,
       430,  430,  430,  430,  430,  430,  430,  430,  430,  430,
-      430,  430,  430,  430,  430,  338,  338,  338,  432,  432,
-      432,  432,  758,  439,  339,  340,  432,  757,  339,  340,
-
-      495,  417,  418,  432,  432,  432,  432,  432,  432,  360,
-      360,  439,  438,  360,  360,  360,  360,  360,  360,  448,
-      360,  360,  360,  360,  360,  360,  360,  360,  360,  360,
-      360,  360,  439,  439,  360,  360,  360,  360,  439,  446,
-      501,  501,  447,  504,  504,  416,  417,  418,  616,  617,
-      339,  340,  638,  339,  340,  515,  439,  439,  449,  419,
-      419,  419,  419,  514,  360,  360,  360,  375,  375,  580,
-      375,  375,  375,  375,  375,  375,  375,  439,  375,  375,
-      375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
-      517,  439,  375,  375,  375,  375,  495,  417,  418,  439,
-
-      439,  511,  439,  512,  439,  439,  339,  340,  209,  439,
-      419,  419,  419,  419,  439,  519,  520,  581,  518,  522,
-      566,  566,  375,  375,  375,  500,  500,  573,  521,  578,
-      339,  340,  500,  500,  500,  500,  500,  500,  500,  500,
-      500,  500,  500,  500,  500,  500,  500,  500,  500,  500,
-      500,  500,  500,  500,  500,  500,  500,  502,  502,  502,
-      502,  532,  439,  439,  439,  502,  439,  339,  340,  439,
-      339,  340,  502,  502,  502,  502,  502,  502,  505,  505,
-      505,  505,  439,  533,  582,  576,  505,  574,  579,  534,
-      575,  439,  439,  505,  505,  505,  505,  505,  505,  567,
-
-      567,  567,  567,  590,  339,  340,  338,  567,  577,  583,
-      439,  439,  625,  591,  567,  567,  567,  567,  567,  567,
-      439,  439,  624,  439,  439,  439,  439,  439,  439,  439,
-      616,  617,  439,  623,  616,  617,  685,  686,  685,  686,
-      756,  628,  626,  632,  708,  755,  634,  685,  686,  302,
-      302,  627,  629,  754,  753,  630,  631,  633,  752,  751,
-      750,  709,  669,   52,   52,   52,   52,   52,   52,   52,
-       52,   52,   52,   52,   52,   52,   52,   52,   52,   69,
-       69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
-       69,   69,   69,   69,   69,   72,   72,   72,   72,   72,
-
-       72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
-       72,   76,   76,   76,   76,   76,   76,   76,   76,   76,
-       76,   76,   76,   76,   76,   76,   76,   86,   86,   86,
-       86,   86,   86,   86,   86,   86,   86,   86,   86,   86,
-       86,   86,   86,   40,   40,   40,   40,   40,   40,   40,
-       40,   40,   40,   40,   40,   40,   40,   40,   40,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,  101,  101,  101,  101,  101,
-      101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
-      101,  106,  106,  106,  106,  106,  106,  106,  106,  106,
-
-      106,  106,  106,  106,  106,  106,  106,  110,  110,  110,
-      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
-      110,  110,  110,  128,  128,  128,  128,  128,  128,  128,
-      128,  128,  128,  128,  128,  128,  128,  128,  128,  131,
-      131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
-      131,  131,  131,  131,  131,  135,  135,  135,  135,  135,
-      135,  135,  135,  135,  135,  135,  135,  135,  135,  135,
-      135,  177,  177,  177,  177,  177,  177,  177,  177,  177,
-      177,  177,  177,  177,  177,  177,  177,  184,  184,  184,
-      184,  749,  748,  184,  184,  184,  190,  190,  190,  190,
-
-      190,  190,  190,  190,  190,  190,  190,  190,  190,  190,
-      190,  200,  200,  200,  200,  747,  746,  200,  200,  200,
-      209,  745,  209,  209,  209,  209,  209,  209,  209,  209,
-      209,  209,  209,  209,  209,  209,  212,  744,  212,  212,
-      212,  212,  212,  212,  212,  212,  212,  212,  212,  212,
-      212,  212,  216,  216,  216,  743,  742,  216,  216,  216,
-      227,  741,  227,  227,  227,  227,  227,  227,  227,  227,
-      227,  227,  227,  227,  227,  227,  229,  740,  229,  229,
-      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
-      229,  229,  230,  739,  230,  230,  230,  230,  230,  230,
-
-      230,  230,  230,  230,  230,  230,  230,  230,  234,  234,
-      234,  234,  234,  234,  234,  234,  234,  234,  234,  234,
-      234,  234,  234,  234,  236,  738,  236,  236,  737,  236,
-      236,  236,  736,  735,  236,  236,  734,  733,  732,  236,
-      238,  238,  238,  238,  731,  730,  238,  238,  238,  242,
-      729,  242,  242,  242,  242,  242,  242,  242,  242,  242,
-      242,  242,  242,  242,  242,  246,  246,  246,  246,  728,
-      727,  246,  246,  246,  251,  726,  251,  251,  251,  251,
-      251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
-      254,  725,  254,  254,  254,  254,  254,  254,  254,  254,
-
-      254,  724,  254,  254,  254,  254,  255,  723,  720,  719,
-      255,  255,  255,  255,  718,  717,  255,  255,  257,  716,
-      257,  257,  257,  257,  257,  257,  257,  257,  257,  257,
-      257,  257,  257,  257,  261,  261,  261,  261,  715,  714,
-      261,  261,  261,  264,  264,  264,  264,  264,  264,  264,
-      264,  264,  264,  264,  264,  264,  264,  264,  264,  267,
-      267,  267,  267,  713,  267,  267,  267,  267,  267,  267,
-      267,  267,  267,  267,  267,  271,  712,  711,  271,  271,
-      271,  271,  271,  271,  271,  710,  271,  271,  271,  271,
-      271,  273,  707,  273,  273,  273,  273,  273,  273,  273,
-
-      273,  273,  273,  273,  273,  273,  273,  274,  706,  274,
-      274,  705,  274,  274,  274,  704,  703,  274,  274,  702,
-      701,  700,  274,  279,  279,  279,  279,  699,  698,  279,
-      279,  279,  284,  697,  284,  284,  284,  284,  284,  284,
-      284,  284,  284,  284,  284,  284,  284,  284,  288,  288,
-      696,  288,  288,  695,  694,  693,  288,  288,  315,  692,
-      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
-      315,  315,  315,  315,  319,  691,  319,  319,  319,  319,
-      319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
-      320,  690,  320,  320,  320,  320,  320,  320,  320,  320,
-
-      320,  320,  320,  320,  320,  320,  328,  328,  689,  688,
-      328,  328,  328,  329,  329,  687,  683,  329,  329,  329,
-      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
-      330,  330,  330,  330,  330,  330,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  338,  682,  338,  338,  338,  338,  338,  338,
-      338,  338,  338,  681,  338,  338,  338,  338,  209,  680,
-      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
-      209,  209,  209,  209,  345,  345,  679,  678,  677,  676,
-      345,  346,  346,  346,  346,  675,  674,  346,  346,  346,
-
-      346,  351,  673,  351,  351,  351,  351,  351,  351,  351,
-      351,  351,  351,  351,  351,  351,  351,  227,  672,  227,
-      227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
-      227,  227,  227,  229,  671,  229,  229,  229,  229,  229,
-      229,  229,  229,  229,  229,  229,  229,  229,  229,  230,
-      670,  230,  230,  230,  230,  230,  230,  230,  230,  230,
-      230,  230,  230,  230,  230,  353,  668,  353,  353,  353,
-      353,  353,  353,  353,  353,  353,  353,  353,  353,  353,
-      353,  354,  667,  354,  354,  354,  354,  354,  354,  354,
-      354,  354,  354,  354,  354,  354,  354,  234,  234,  234,
-
-      234,  234,  234,  234,  234,  234,  234,  234,  234,  234,
-      234,  234,  234,  236,  666,  236,  236,  665,  236,  236,
-      236,  664,  663,  236,  236,  662,  661,  660,  236,  238,
-      238,  238,  238,  659,  658,  238,  238,  238,  242,  657,
-      242,  242,  242,  242,  242,  242,  242,  242,  242,  242,
-      242,  242,  242,  242,  246,  246,  246,  246,  656,  655,
-      246,  246,  246,  361,  361,  654,  653,  652,  361,  361,
-      255,  651,  650,  649,  255,  255,  255,  255,  648,  647,
-      255,  255,  257,  646,  257,  257,  257,  257,  257,  257,
-      257,  257,  257,  257,  257,  257,  257,  257,  261,  261,
-
-      261,  261,  645,  644,  261,  261,  261,  264,  264,  264,
-      264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
-      264,  264,  264,  267,  267,  267,  267,  643,  267,  267,
-      267,  267,  267,  267,  267,  267,  267,  267,  267,  271,
-      642,  641,  271,  271,  271,  271,  271,  271,  271,  640,
-      271,  271,  271,  271,  271,  274,  639,  274,  274,  638,
-      274,  274,  274,  637,  636,  274,  274,  635,  622,  621,
-      274,  279,  279,  279,  279,  620,  619,  279,  279,  279,
-      284,  618,  284,  284,  284,  284,  284,  284,  284,  284,
-      284,  284,  284,  284,  284,  284,  288,  288,  560,  288,
-
-      288,  614,  613,  612,  288,  288,  315,  611,  315,  315,
-      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
-      315,  315,  319,  610,  319,  319,  319,  319,  319,  319,
-      319,  319,  319,  319,  319,  319,  319,  319,  320,  609,
-      320,  320,  320,  320,  320,  320,  320,  320,  320,  320,
-      320,  320,  320,  320,  415,  415,  415,  415,  415,  415,
-      415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
-      424,  424,  424,  424,  608,  607,  424,  424,  424,  425,
-      425,  425,  425,  606,  605,  425,  425,  425,  330,  330,
-      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
-
-      330,  330,  330,  330,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      338,  604,  338,  338,  338,  338,  338,  338,  338,  338,
-      338,  603,  338,  338,  338,  338,  433,  433,  602,  601,
-      600,  599,  433,  346,  346,  346,  346,  598,  597,  346,
-      346,  346,  346,  351,  596,  351,  351,  351,  351,  351,
-      351,  351,  351,  351,  351,  351,  351,  351,  351,  615,
-      615,  615,  615,  615,  615,  615,  615,  615,  615,  615,
-      615,  615,  615,  615,  615,  684,  684,  684,  684,  684,
-      684,  684,  684,  684,  684,  684,  684,  684,  684,  684,
-
-      684,  595,  594,  593,  592,  589,  588,  587,  586,  585,
-      584,  571,  570,  569,  568,  565,  564,  563,  562,  561,
-      560,  559,  558,  557,  556,  555,  554,  551,  550,  549,
-      548,  547,  546,  545,  544,  543,  542,  541,  540,  539,
-      538,  537,  536,  535,  531,  530,  529,  528,  527,  526,
-      525,  524,  523,  510,  509,  508,  507,  506,  503,  499,
-      498,  497,  496,  492,  491,  490,  489,  488,  484,  483,
-      482,  479,  478,  477,  476,  475,  474,  473,  472,  471,
-      470,  469,  468,  467,  466,  465,  464,  463,  462,  461,
-      460,  459,  458,  457,  456,  455,  454,  453,  452,  451,
-
-      439,  437,  436,  435,  434,  347,  426,  423,  422,  421,
-      322,  414,  316,  408,  407,  406,  401,  400,  399,  398,
-      397,  396,  395,  394,  391,  390,  389,  386,  385,  382,
-      379,  378,  285,  282,  377,  376,  278,  373,  372,  243,
-      356,  355,  235,  231,  352,  350,  349,  348,  218,  347,
-      337,  206,  333,  202,  318,  186,  182,  316,  314,  313,
-      312,  311,  310,  309,  305,  299,  298,  295,  294,  291,
-      287,  286,  285,  283,  282,  281,  280,  260,  278,  277,
-      272,  270,  263,  262,  260,  256,  250,  253,  250,  249,
-      247,  245,  244,  243,  241,  240,  239,  237,  235,  228,
-
-      231,  228,  226,  218,  208,  202,  199,  186,  182,  768,
-       94,   94,   85,   77,   77,   39,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768
+      430,  430,  430,  430,  437,  437,  437,  318,  318, 1106,
+
+      318,  318, 1106, 1106, 1106,  318,  447, 1106,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  605, 1106,  605,  605,  605,  605,  605,
+      605,  605,  605,  605,  605,  605,  605,  605,  605,  605,
+      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
+      774,  774,  774,  774,  774,  774,  774,  916,  916,  916,
+      916,  916,  916,  916,  916,  916,  916,  916,  916,  916,
+      916,  916,  916,  916,   49, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106
     } ;
 
-static yyconst short int yy_chk[2775] =
+static yyconst flex_int16_t yy_chk[4060] =
     {   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,    1,    1,    1,    1,    1,    2,    2,
+        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,    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,    3,    3,    3,    3,
-      765,    3,    5,    5,    3,    3,    3,   27,   27,    3,
-        6,    6,    6,   28,   28,    3,    6,   11,   11,   11,
-        3,    3,   12,   12,   12,   48,   17,   17,   66,   29,
-       29,   60,   60,   18,   18,  310,   17,   29,  310,   17,
-       17,   17,   17,   18,   61,   61,   18,   18,   18,   18,
-        3,    3,    3,    4,    4,    4,    4,  109,    4,    4,
-       21,    4,    4,    4,  511,   48,    4,   19,   19,   19,
-       22,  109,    4,   20,   20,   20,   66,    4,    4,  141,
-
-        4,   17,   61,   21,   21,  141,   21,   37,   18,   37,
-       75,   19,   75,   22,   22,  511,   22,   20,   30,   30,
-       37,   37,   37,   37,  128,  128,   30,    4,    4,    4,
-        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
-        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
-        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
-        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
-        9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
-        9,    9,    9,    9,    9,    9,    9,    9,   13,   13,
+        2,    2,    2,    2,    2,    2,    2,    2,    3,    3,
+       96,    3,    3,    5,    3,    5,    7,    3,    3,    3,
+        3,    8,  992,    3,    3,    6,    6,  942,    6,   21,
+        3,  941,    6,    3,    9,  126,    9,   11,   11,   96,
+
+       11,   12,   12,  940,   12,   17,  939,   17,   19,  138,
+       19,   19,   27,   20,   27,   20,   20,   17,   22,    3,
+        3,   17,   17,   17,   17,   28,    7,   28,    7,   51,
+       51,    8,   51,    8,  126,   10,    9,   10,   79,   21,
+       21,   10,   21,    9,    9,   87,    9,   87,    3,    3,
+        3,    4,    4,  138,    4,    4,  938,    4,    4,   19,
+        4,    4,    4,    4,   20,    9,    4,    4,   22,   22,
+       95,   22,    9,    4,   73,   73,    4,   10,   23,   37,
+       23,   45,   37,   45,   10,   10,   17,   10,  259,  259,
+       45,   23,  142,  263,  263,   37,   37,   37,   37,  937,
+
+       95,   38,    4,    4,   38,    4,   10,   46,  147,   46,
+      147,   79,   47,   10,   47,  936,   46,   38,   38,   38,
+       38,  142,   47,   55,   55,  149,   55,  149,   23,   23,
+       23,    4,    4,    4,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
-
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
-       13,   13,   13,   13,   13,   13,   23,   23,  163,   24,
-       24,   38,  764,   38,   41,   41,   41,   23,  130,  130,
-       24,   45,   45,   45,   38,   38,   38,   38,  163,   23,
-       23,   23,   24,   24,   24,   25,   25,   25,   25,   25,
+
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   18,   24,
+       18,   24,  168,   29,   58,   29,   74,   74,  935,   30,
+       18,   30,   24,   29,   18,   18,   18,   18,   31,   30,
+       31,   31,   32,  191,   32,   32,   48,  162,   48,   67,
+       67,  168,   67,  246,  162,  246,   48,   75,   74,   75,
+      141,   58,   75,   75,   75,   75,  167,  176,  177,   24,
+       24,   24,  191,   29,  253,   29,  253,  105,  105,   30,
+      105,   30,  116,  116,  116,  116,  294,   74,  294,   31,
+      141,   58,  323,   32,  323,  934,  167,  176,  177,   18,
+
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
-
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
-       25,   25,   25,   31,   31,   31,   32,   32,   32,   57,
-       57,   57,   62,   62,   62,   62,   99,   99,   99,   99,
-      131,  131,  133,  133,  167,  198,  198,   31,  167,  763,
-       32,   33,   33,   33,   33,   33,   33,   33,   33,   33,
-       33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
-       33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
-       33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
-
-       33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
-       33,   33,   33,   33,   33,   33,   33,   33,   33,   35,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   33,   33,   39,   33,   39,   34,
+       34,   33,   34,  182,   41,   42,   34,  333,   43,  181,
+
+       33,   41,   42,  186,  333,   34,  203,  203,  203,  203,
+      325,   43,  325,  181,   41,   42,  179,  187,  179,  188,
+      314,   43,  179,  182,   41,   42,   43,   33,  194,   41,
+       42,  199,   34,  186,   33,   33,   39,   33,   39,   34,
+       34,   43,   34,  181,   41,   42,  179,  187,  179,  188,
+       43,  179,  933,   41,   42,   43,   33,  194,   41,   42,
+      199,   34,  932,   33,  314,   39,  931,   39,   34,   35,
        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
+
        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
-       35,   35,   35,   35,   35,   35,   35,   49,   53,   53,
-       53,  121,  105,  105,   53,  158,  108,  108,  115,  115,
-      160,  158,   63,   63,   63,  291,  168,  275,   63,  121,
-
-       49,  188,   49,  275,   49,   63,  168,  205,  205,  160,
-       49,   63,  291,   49,   49,   49,  405,   49,   49,   63,
-      105,  170,  405,   49,  108,   49,  115,  180,  180,  180,
-      180,  170,  762,   53,  170,  181,  181,  181,  185,  185,
-      185,  188,  192,  192,  192,  209,  209,   63,  193,  193,
-      193,  294,  194,  194,  194,  294,  192,  192,  192,  192,
-      211,  211,  193,  193,  193,  193,  194,  194,  194,  194,
-      195,  195,  195,  201,  201,  201,  210,  213,  213,  201,
-      289,  257,  210,  210,  195,  195,  195,  195,  192,  217,
-      217,  217,  264,  264,  289,  217,  194,  362,  211,  257,
-
-      266,  266,  217,  248,  248,  248,  248,  761,  217,  267,
-      267,  269,  269,  195,  298,  309,  217,  314,  298,  362,
-      314,  321,  321,  321,  309,  330,  330,  760,  201,  314,
-      314,  317,  317,  317,  317,  321,  321,  321,  321,  708,
-      314,  332,  332,  708,  217,  241,  241,  241,  241,  241,
-      241,  241,  241,  241,  241,  241,  241,  241,  241,  241,
-      241,  241,  241,  241,  241,  241,  241,  241,  241,  241,
-      241,  241,  241,  241,  241,  241,  241,  241,  241,  241,
-      241,  241,  241,  241,  241,  241,  241,  241,  241,  241,
-      241,  241,  241,  241,  241,  241,  241,  241,  241,  241,
-
-      241,  241,  241,  250,  250,  250,  250,  334,  334,  250,
-      336,  336,  338,  338,  250,  344,  344,  757,  250,  415,
-      415,  250,  756,  250,  418,  418,  250,  278,  278,  755,
-      278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
-      278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
-      278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
-      278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
-      278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
-      278,  278,  278,  278,  278,  324,  324,  324,  339,  363,
-      364,  340,  340,  365,  339,  339,  342,  342,  366,  324,
-
-      324,  324,  324,  340,  371,  409,  342,  342,  409,  409,
-      441,  363,  365,  444,  364,  420,  420,  420,  371,  485,
-      754,  441,  494,  494,  444,  485,  366,  504,  504,  340,
-      341,  341,  367,  341,  341,  341,  341,  341,  341,  341,
-      341,  341,  341,  341,  341,  341,  341,  341,  341,  341,
-      341,  341,  341,  341,  341,  341,  341,  367,  341,  341,
-      341,  341,  341,  341,  341,  341,  341,  341,  341,  341,
-      341,  341,  341,  341,  341,  341,  341,  341,  341,  341,
-      341,  341,  341,  341,  341,  341,  341,  341,  343,  343,
-      343,  343,  752,  369,  505,  505,  343,  750,  343,  343,
-
-      495,  495,  495,  343,  343,  343,  343,  343,  343,  360,
-      360,  368,  360,  360,  360,  360,  360,  360,  360,  369,
-      360,  360,  360,  360,  360,  360,  360,  360,  360,  360,
-      360,  360,  370,  442,  360,  360,  360,  360,  443,  368,
-      428,  428,  368,  431,  431,  416,  416,  416,  561,  561,
-      428,  428,  749,  431,  431,  443,  519,  445,  370,  416,
-      416,  416,  416,  442,  360,  360,  360,  375,  375,  519,
-      375,  375,  375,  375,  375,  375,  375,  440,  375,  375,
-      375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
-      445,  447,  375,  375,  375,  375,  419,  419,  419,  446,
-
-      450,  440,  449,  440,  520,  448,  503,  503,  503,  512,
-      419,  419,  419,  419,  517,  447,  448,  520,  446,  450,
-      501,  501,  375,  375,  375,  427,  427,  512,  449,  517,
-      501,  501,  427,  427,  427,  427,  427,  427,  427,  427,
-      427,  427,  427,  427,  427,  427,  427,  427,  427,  427,
-      427,  427,  427,  427,  427,  427,  427,  429,  429,  429,
-      429,  462,  514,  513,  518,  429,  515,  566,  566,  521,
-      567,  567,  429,  429,  429,  429,  429,  429,  432,  432,
-      432,  432,  516,  462,  521,  515,  432,  513,  518,  462,
-      514,  574,  522,  432,  432,  432,  432,  432,  432,  502,
-
-      502,  502,  502,  532,  565,  565,  565,  502,  516,  522,
-      572,  573,  574,  532,  502,  502,  502,  502,  502,  502,
-      575,  576,  573,  577,  578,  579,  580,  583,  581,  582,
-      615,  615,  634,  572,  617,  617,  656,  656,  684,  684,
-      748,  577,  575,  581,  681,  747,  583,  686,  686,  810,
-      810,  576,  578,  745,  744,  579,  580,  582,  743,  742,
-      740,  681,  634,  769,  769,  769,  769,  769,  769,  769,
-      769,  769,  769,  769,  769,  769,  769,  769,  769,  770,
-      770,  770,  770,  770,  770,  770,  770,  770,  770,  770,
-      770,  770,  770,  770,  770,  771,  771,  771,  771,  771,
-
-      771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
-      771,  772,  772,  772,  772,  772,  772,  772,  772,  772,
-      772,  772,  772,  772,  772,  772,  772,  773,  773,  773,
-      773,  773,  773,  773,  773,  773,  773,  773,  773,  773,
-      773,  773,  773,  774,  774,  774,  774,  774,  774,  774,
-      774,  774,  774,  774,  774,  774,  774,  774,  774,  775,
-      775,  775,  775,  775,  775,  775,  775,  775,  775,  775,
-      775,  775,  775,  775,  775,  776,  776,  776,  776,  776,
-      776,  776,  776,  776,  776,  776,  776,  776,  776,  776,
-      776,  777,  777,  777,  777,  777,  777,  777,  777,  777,
-
-      777,  777,  777,  777,  777,  777,  777,  778,  778,  778,
-      778,  778,  778,  778,  778,  778,  778,  778,  778,  778,
-      778,  778,  778,  779,  779,  779,  779,  779,  779,  779,
-      779,  779,  779,  779,  779,  779,  779,  779,  779,  780,
-      780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
-      780,  780,  780,  780,  780,  781,  781,  781,  781,  781,
-      781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
-      781,  782,  782,  782,  782,  782,  782,  782,  782,  782,
-      782,  782,  782,  782,  782,  782,  782,  783,  783,  783,
-      783,  739,  738,  783,  783,  783,  784,  784,  784,  784,
-
-      784,  784,  784,  784,  784,  784,  784,  784,  784,  784,
-      784,  785,  785,  785,  785,  737,  736,  785,  785,  785,
-      786,  735,  786,  786,  786,  786,  786,  786,  786,  786,
-      786,  786,  786,  786,  786,  786,  787,  734,  787,  787,
-      787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
-      787,  787,  788,  788,  788,  733,  732,  788,  788,  788,
-      789,  731,  789,  789,  789,  789,  789,  789,  789,  789,
-      789,  789,  789,  789,  789,  789,  790,  729,  790,  790,
-      790,  790,  790,  790,  790,  790,  790,  790,  790,  790,
-      790,  790,  791,  727,  791,  791,  791,  791,  791,  791,
-
-      791,  791,  791,  791,  791,  791,  791,  791,  792,  792,
-      792,  792,  792,  792,  792,  792,  792,  792,  792,  792,
-      792,  792,  792,  792,  793,  726,  793,  793,  725,  793,
-      793,  793,  724,  723,  793,  793,  722,  721,  720,  793,
-      794,  794,  794,  794,  719,  718,  794,  794,  794,  795,
-      717,  795,  795,  795,  795,  795,  795,  795,  795,  795,
-      795,  795,  795,  795,  795,  796,  796,  796,  796,  715,
-      714,  796,  796,  796,  797,  713,  797,  797,  797,  797,
-      797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
-      798,  712,  798,  798,  798,  798,  798,  798,  798,  798,
-
-      798,  710,  798,  798,  798,  798,  799,  709,  707,  706,
-      799,  799,  799,  799,  705,  704,  799,  799,  800,  703,
-      800,  800,  800,  800,  800,  800,  800,  800,  800,  800,
-      800,  800,  800,  800,  801,  801,  801,  801,  702,  701,
-      801,  801,  801,  802,  802,  802,  802,  802,  802,  802,
-      802,  802,  802,  802,  802,  802,  802,  802,  802,  803,
-      803,  803,  803,  700,  803,  803,  803,  803,  803,  803,
-      803,  803,  803,  803,  803,  804,  699,  698,  804,  804,
-      804,  804,  804,  804,  804,  682,  804,  804,  804,  804,
-      804,  805,  680,  805,  805,  805,  805,  805,  805,  805,
-
-      805,  805,  805,  805,  805,  805,  805,  806,  679,  806,
-      806,  678,  806,  806,  806,  677,  675,  806,  806,  674,
-      672,  671,  806,  807,  807,  807,  807,  670,  669,  807,
-      807,  807,  808,  668,  808,  808,  808,  808,  808,  808,
-      808,  808,  808,  808,  808,  808,  808,  808,  809,  809,
-      667,  809,  809,  666,  665,  664,  809,  809,  811,  663,
-      811,  811,  811,  811,  811,  811,  811,  811,  811,  811,
-      811,  811,  811,  811,  812,  662,  812,  812,  812,  812,
-      812,  812,  812,  812,  812,  812,  812,  812,  812,  812,
-      813,  661,  813,  813,  813,  813,  813,  813,  813,  813,
-
-      813,  813,  813,  813,  813,  813,  814,  814,  660,  659,
-      814,  814,  814,  815,  815,  658,  655,  815,  815,  815,
-      816,  816,  816,  816,  816,  816,  816,  816,  816,  816,
-      816,  816,  816,  816,  816,  816,  817,  817,  817,  817,
-      817,  817,  817,  817,  817,  817,  817,  817,  817,  817,
-      817,  817,  818,  653,  818,  818,  818,  818,  818,  818,
-      818,  818,  818,  652,  818,  818,  818,  818,  819,  651,
-      819,  819,  819,  819,  819,  819,  819,  819,  819,  819,
-      819,  819,  819,  819,  820,  820,  650,  646,  644,  643,
-      820,  821,  821,  821,  821,  642,  641,  821,  821,  821,
-
-      821,  822,  639,  822,  822,  822,  822,  822,  822,  822,
-      822,  822,  822,  822,  822,  822,  822,  823,  637,  823,
-      823,  823,  823,  823,  823,  823,  823,  823,  823,  823,
-      823,  823,  823,  824,  636,  824,  824,  824,  824,  824,
-      824,  824,  824,  824,  824,  824,  824,  824,  824,  825,
-      635,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  826,  633,  826,  826,  826,
-      826,  826,  826,  826,  826,  826,  826,  826,  826,  826,
-      826,  827,  632,  827,  827,  827,  827,  827,  827,  827,
-      827,  827,  827,  827,  827,  827,  827,  828,  828,  828,
-
-      828,  828,  828,  828,  828,  828,  828,  828,  828,  828,
-      828,  828,  828,  829,  631,  829,  829,  630,  829,  829,
-      829,  629,  628,  829,  829,  627,  626,  625,  829,  830,
-      830,  830,  830,  624,  623,  830,  830,  830,  831,  621,
-      831,  831,  831,  831,  831,  831,  831,  831,  831,  831,
-      831,  831,  831,  831,  832,  832,  832,  832,  619,  612,
-      832,  832,  832,  833,  833,  611,  610,  609,  833,  833,
-      834,  608,  607,  606,  834,  834,  834,  834,  604,  601,
-      834,  834,  835,  600,  835,  835,  835,  835,  835,  835,
-      835,  835,  835,  835,  835,  835,  835,  835,  836,  836,
-
-      836,  836,  599,  598,  836,  836,  836,  837,  837,  837,
-      837,  837,  837,  837,  837,  837,  837,  837,  837,  837,
-      837,  837,  837,  838,  838,  838,  838,  597,  838,  838,
-      838,  838,  838,  838,  838,  838,  838,  838,  838,  839,
-      596,  595,  839,  839,  839,  839,  839,  839,  839,  594,
-      839,  839,  839,  839,  839,  840,  593,  840,  840,  592,
-      840,  840,  840,  591,  590,  840,  840,  588,  569,  568,
-      840,  841,  841,  841,  841,  564,  563,  841,  841,  841,
-      842,  562,  842,  842,  842,  842,  842,  842,  842,  842,
-      842,  842,  842,  842,  842,  842,  843,  843,  560,  843,
-
-      843,  559,  558,  557,  843,  843,  844,  556,  844,  844,
-      844,  844,  844,  844,  844,  844,  844,  844,  844,  844,
-      844,  844,  845,  555,  845,  845,  845,  845,  845,  845,
-      845,  845,  845,  845,  845,  845,  845,  845,  846,  554,
-      846,  846,  846,  846,  846,  846,  846,  846,  846,  846,
-      846,  846,  846,  846,  847,  847,  847,  847,  847,  847,
-      847,  847,  847,  847,  847,  847,  847,  847,  847,  847,
-      848,  848,  848,  848,  553,  552,  848,  848,  848,  849,
-      849,  849,  849,  551,  549,  849,  849,  849,  850,  850,
-      850,  850,  850,  850,  850,  850,  850,  850,  850,  850,
-
-      850,  850,  850,  850,  851,  851,  851,  851,  851,  851,
-      851,  851,  851,  851,  851,  851,  851,  851,  851,  851,
-      852,  548,  852,  852,  852,  852,  852,  852,  852,  852,
-      852,  546,  852,  852,  852,  852,  853,  853,  545,  544,
-      543,  542,  853,  854,  854,  854,  854,  541,  540,  854,
-      854,  854,  854,  855,  539,  855,  855,  855,  855,  855,
-      855,  855,  855,  855,  855,  855,  855,  855,  855,  856,
-      856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
-      856,  856,  856,  856,  856,  857,  857,  857,  857,  857,
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-
-      857,  538,  536,  534,  533,  530,  528,  526,  525,  524,
-      523,  509,  508,  507,  506,  500,  499,  498,  497,  496,
-      492,  491,  490,  489,  488,  487,  486,  483,  482,  481,
-      480,  479,  478,  476,  475,  474,  473,  472,  471,  469,
-      468,  467,  464,  463,  461,  460,  459,  458,  457,  454,
-      453,  452,  451,  439,  437,  436,  435,  434,  430,  426,
-      423,  422,  421,  414,  413,  412,  411,  410,  408,  407,
-      406,  404,  403,  402,  401,  400,  399,  398,  397,  396,
-      395,  394,  393,  392,  391,  390,  388,  387,  386,  384,
-      383,  382,  381,  380,  379,  378,  377,  376,  373,  372,
-
-      361,  356,  355,  352,  350,  346,  337,  327,  326,  325,
-      323,  318,  315,  313,  312,  311,  308,  307,  306,  305,
-      303,  301,  300,  299,  297,  296,  295,  293,  292,  290,
-      287,  286,  284,  282,  281,  280,  276,  263,  262,  243,
-      240,  239,  234,  231,  226,  222,  221,  220,  219,  216,
-      208,  207,  204,  203,  189,  187,  183,  179,  176,  175,
-      174,  173,  172,  171,  169,  166,  165,  162,  161,  159,
-      156,  155,  154,  153,  151,  149,  148,  146,  144,  143,
-      137,  134,  125,  124,  122,  119,  114,  112,  107,  103,
-       97,   92,   89,   87,   85,   84,   83,   80,   76,   74,
-
-       73,   71,   67,   65,   59,   55,   50,   47,   43,   39,
-       16,   15,   10,    8,    7,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
-      768,  768,  768,  768
+       35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
+       35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
+       35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
+       35,   35,   35,   40,   44,   40,   63,   63,  193,   63,
+      122,  122,  347,   63,  183,   76,   76,   44,   76,  125,
+      125,  348,   76,  350,  195,  132,  132,   44,  180,  184,
+      190,   76,   44,  409,  409,  183,  180,   76,  193,  930,
+      190,  347,  122,  196,  183,  197,  198,   44,  873,  184,
+
+      348,  125,  350,   40,  195,   40,   44,  132,  180,  184,
+      190,   44,  236,  189,  183,  244,  180,  189,  235,   76,
+      190,  122,  258,  196,  872,  197,  198,  278,  184,  871,
+      125,  290,   40,  291,   40,   59,  132,   63,  228,  228,
+      192,  228,  236,  189,  260,  244,   76,  189,  232,  232,
+      192,  232,  258,  192,   59,  235,   59,  278,   59,  249,
+      249,  290,  249,  291,   59,  870,  249,   59,   59,   59,
+      192,   59,   59,   59,  260,  260,  869,   59,  298,  298,
+      192,  298,  192,  868,   59,  235,   59,  867,   59,  319,
+      320,  866,  239,  239,   59,  239,  865,   59,   59,   59,
+
+       59,   59,   59,  864,  240,  240,   59,  240,   59,  239,
+      239,  239,  239,  241,  241,  863,  241,  261,  261,  319,
+      320,  240,  240,  240,  240,  242,  242,  352,  242,  343,
+      241,  241,  241,  241,  354,  239,  305,  305,  305,  305,
+      249,  344,  242,  242,  242,  242,  346,  862,  355,  261,
+      269,  269,  349,  269,  241,  357,  352,  269,  353,  343,
+      346,  356,  353,  354,  239,  242,  269,  358,  861,  349,
+      359,  344,  269,  360,  359,  361,  346,  355,  261,  362,
+      364,  366,  349,  367,  241,  357,  368,  369,  353,  346,
+      356,  371,  353,  372,  371,  242,  368,  358,  349,  374,
+
+      359,  375,  360,  359,  269,  361,  415,  415,  362,  364,
+      366,  400,  367,  400,  614,  614,  368,  369,  402,  860,
+      402,  371,  859,  372,  371,  368,  858,  387,  374,  394,
+      375,  269,  307,  307,  307,  307,  307,  307,  307,  307,
+      307,  307,  307,  307,  307,  307,  307,  307,  307,  307,
+      307,  307,  307,  307,  307,  307,  307,  387,  394,  404,
+      307,  404,  307,  307,  307,  307,  307,  307,  307,  307,
+      307,  307,  307,  307,  307,  307,  307,  307,  307,  307,
+      307,  307,  307,  307,  307,  307,  370,  373,  390,  390,
+      370,  390,  395,  396,  373,  370,  379,  379,  379,  379,
+
+      398,  406,  430,  406,  430,  390,  390,  390,  390,  408,
+      410,  857,  423,  411,  411,  856,  370,  373,  448,  855,
+      370,  395,  854,  396,  373,  370,  376,  425,  376,  428,
+      398,  376,  376,  393,  393,  853,  393,  376,  376,  408,
+      410,  410,  423,  376,  376,  411,  429,  448,  376,  411,
+      393,  393,  393,  393,  852,  376,  376,  425,  376,  428,
+      851,  376,  376,  420,  420,  420,  420,  376,  376,  432,
+      847,  432,  376,  376,  411,  846,  429,  376,  412,  412,
+      792,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+
+      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  791,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      412,  412,  413,  413,  445,  446,  441,  433,  434,  435,
+      438,  439,  436,  442,  449,  459,  450,  498,  790,  498,
+      440,  443,  789,  433,  434,  436,  441,  435,  451,  443,
+      439,  788,  438,  442,  445,  446,  413,  413,  414,  414,
+
+      414,  414,  440,  449,  459,  440,  450,  414,  414,  414,
+      414,  414,  414,  433,  434,  436,  441,  435,  451,  443,
+      439,  438,  452,  442,  462,  453,  454,  455,  456,  787,
+      458,  440,  414,  414,  440,  460,  786,  414,  414,  414,
+      414,  414,  414,  444,  463,  464,  465,  467,  444,  444,
+      444,  444,  452,  462,  444,  453,  454,  455,  456,  444,
+      458,  466,  469,  444,  470,  460,  444,  785,  444,  471,
+      784,  444,  472,  463,  473,  464,  465,  467,  444,  444,
+      444,  444,  474,  475,  444,  476,  477,  478,  479,  444,
+      466,  480,  469,  444,  470,  444,  482,  444,  483,  471,
+
+      444,  481,  472,  484,  473,  485,  486,  481,  487,  488,
+      508,  489,  474,  475,  490,  476,  477,  478,  479,  491,
+      492,  480,  493,  494,  783,  495,  482,  483,  497,  782,
+      496,  481,  484,  496,  496,  485,  486,  481,  487,  488,
+      489,  501,  504,  501,  490,  503,  503,  505,  503,  491,
+      492,  523,  493,  494,  495,  506,  499,  499,  497,  499,
+      496,  510,  496,  496,  502,  502,  600,  502,  600,  613,
+      613,  613,  504,  499,  499,  499,  499,  505,  615,  615,
+      523,  502,  502,  502,  502,  506,  601,  601,  780,  601,
+      508,  510,  511,  511,  773,  511,  511,  511,  511,  511,
+
+      511,  511,  511,  511,  511,  511,  511,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  511,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  511,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  511,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  514,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  511,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  511,  511,  511,  511,
+      511,  511,  511,  511,  511,  511,  512,  512,  520,  514,
+      525,  527,  516,  516,  532,  526,  528,  770,  521,  522,
+      526,  758,  607,  607,  529,  607,  531,  528,  525,  529,
+
+      525,  693,  532,  693,  744,  527,  530,  609,  520,  531,
+      512,  512,  513,  513,  513,  513,  516,  516,  521,  522,
+      526,  513,  513,  513,  513,  513,  513,  528,  525,  529,
+      525,  535,  532,  530,  527,  733,  539,  533,  545,  531,
+      609,  534,  533,  704,  535,  546,  545,  536,  537,  539,
+      703,  513,  513,  513,  513,  513,  513,  517,  517,  517,
+      517,  534,  530,  536,  537,  538,  517,  517,  517,  517,
+      517,  517,  533,  540,  535,  546,  545,  699,  550,  539,
+      542,  547,  551,  538,  541,  553,  543,  544,  554,  555,
+      556,  534,  557,  536,  537,  540,  517,  517,  517,  517,
+
+      517,  517,  542,  541,  698,  542,  543,  544,  550,  557,
+      547,  551,  558,  538,  553,  557,  560,  554,  559,  555,
+      556,  563,  606,  564,  540,  565,  566,  692,  569,  570,
+      574,  542,  572,  541,  542,  573,  543,  544,  576,  557,
+      577,  578,  558,  579,  581,  557,  560,  559,  580,  582,
+      583,  563,  564,  584,  565,  586,  566,  569,  587,  570,
+      574,  572,  588,  590,  573,  589,  591,  576,  592,  594,
+      577,  578,  593,  579,  581,  595,  596,  580,  582,  583,
+      602,  595,  597,  584,  603,  586,  604,  616,  587,  611,
+      611,  618,  588,  590,  589,  591,  621,  624,  592,  594,
+
+      619,  593,  606,  686,  622,  595,  596,  701,  701,  602,
+      595,  623,  597,  626,  603,  604,  622,  616,  625,  624,
+      618,  621,  628,  611,  611,  612,  612,  612,  612,  623,
+      619,  625,  627,  626,  612,  612,  612,  612,  612,  612,
+      628,  627,  629,  631,  630,  632,  622,  682,  624,  629,
+      621,  630,  631,  634,  633,  774,  632,  774,  634,  623,
+      635,  625,  636,  626,  612,  612,  612,  612,  612,  612,
+      628,  627,  633,  636,  633,  637,  639,  640,  638,  629,
+      637,  630,  631,  643,  635,  641,  632,  642,  634,  639,
+      641,  668,  644,  645,  648,  640,  643,  664,  647,  650,
+
+      655,  653,  633,  636,  633,  638,  648,  642,  658,  654,
+      637,  653,  657,  635,  659,  661,  662,  663,  665,  639,
+      641,  644,  666,  645,  648,  640,  643,  647,  667,  650,
+      655,  653,  669,  670,  638,  671,  648,  642,  654,  673,
+      653,  674,  657,  659,  675,  661,  662,  663,  665,  676,
+      679,  666,  678,  680,  681,  683,  684,  685,  667,  687,
+      688,  669,  670,  689,  671,  690,  691,  694,  695,  673,
+      674,  696,  696,  675,  696,  700,  700,  700,  711,  676,
+      679,  678,  680,  707,  681,  683,  684,  685,  709,  687,
+      688,  710,  689,  702,  702,  690,  691,  694,  695,  708,
+
+      707,  712,  711,  709,  708,  713,  716,  710,  714,  718,
+      721,  715,  720,  712,  717,  716,  719,  722,  727, 1147,
+     1147,  734,  718,  652,  720,  727,  724,  713,  721,  723,
+      707,  711,  714,  709,  708,  715,  717,  710,  725,  722,
+      729,  719,  723,  712,  726,  716,  724,  725,  730,  729,
+      728,  734,  718,  735,  720,  727,  713,  728,  721,  730,
+      738,  714,  726,  737,  715,  717,  739,  740,  722,  741,
+      719,  742,  723,  737,  617,  743,  724,  725,  745,  729,
+      746,  747,  735,  748,  749,  750,  752,  728,  751,  730,
+      738,  754,  726,  737,  756,  760,  739,  740,  741,  761,
+
+      742,  762,  765,  737,  743,  767,  771,  776,  745,  776,
+      746,  747,  778,  748,  749,  750,  752,  751,  772,  795,
+      849,  754,  849,  756,  795,  760,  764,  764,  793,  761,
+      762,  764,  765,  794,  764,  767,  771,  764,  768,  768,
+      796,  778,  764,  768,  797,  809,  768,  799,  772,  768,
+      794,  798,  793,  801,  795,  796,  764,  764,  802,  799,
+      797,  764,  800,  803,  764,  804,  806,  764,  768,  768,
+      807,  764,  803,  768,  809,  798,  768,  801,  805,  768,
+      794,  793,  802,  811,  800,  796,  814,  804,  808,  799,
+      797,  805,  810,  812,  610,  816,  806,  817,  608,  818,
+
+      807,  819,  803,  820,  798,  821,  801,  823,  825,  826,
+      828,  802,  811,  800,  832,  814,  804,  833,  808,  834,
+      837,  805,  810,  812,  816,  836,  828,  817,  818,  838,
+      839,  819,  820,  840,  842,  821,  841,  823,  825,  826,
+      828,  835,  598,  844,  832,  835,  833,  845,  835,  834,
+      837,  848,  875,  843,  836,  828,  843,  874,  835,  838,
+      839,  876,  878,  840,  842,  841,  843,  877,  879,  880,
+      883,  835,  844,  881,  884,  835,  845,  885,  835,  886,
+      848,  874,  875,  843,  888,  889,  843,  835,  890,  571,
+      891,  876,  878,  892,  893,  843,  877,  894,  879,  880,
+
+      883,  895,  881,  897,  884,  898,  899,  885,  900,  886,
+      874,  901,  902,  888,  904,  889,  905,  908,  890,  891,
+      906,  909,  910,  892,  893,  911,  912,  894,  913,  915,
+      895,  914,  916,  897,  916,  898,  899,  918,  900,  918,
+      901,  902,  943,  944,  904,  945,  905,  908,  914,  906,
+      946,  909,  910,  947,  911,  912,  948,  913,  915,  949,
+      950,  914,  951,  568,  952,  953,  954,  552,  955,  956,
+      958,  943,  959,  944,  960,  945,  961,  914,  962,  963,
+      946,  964,  965,  947,  967,  969,  948,  970,  971,  949,
+      950,  972,  951,  952,  953,  973,  954,  955,  975,  956,
+
+      958,  959,  976,  960,  978,  961,  977,  979,  962,  963,
+      977,  964,  965,  967,  969,  993,  970,  994,  971,  995,
+      996,  972,  997,  998,  999,  973, 1001, 1002,  975, 1004,
+     1005,  976, 1006,  978, 1007,  977, 1008,  979, 1009,  977,
+     1010, 1012, 1016, 1017, 1018,  993, 1021,  994,  995, 1022,
+      996,  997,  998,  999, 1023, 1031, 1001, 1002, 1004, 1005,
+     1024, 1025, 1006, 1026, 1007, 1028, 1008, 1029, 1009, 1030,
+     1010, 1012, 1016, 1017, 1018, 1021, 1032, 1033, 1034, 1022,
+     1037,  524, 1039, 1041, 1023, 1031, 1044, 1047, 1048, 1024,
+     1025, 1049, 1026, 1050, 1028, 1051, 1029, 1052, 1030, 1053,
+
+     1054, 1055, 1056, 1058,  515, 1059, 1032, 1033, 1034, 1060,
+     1037, 1039, 1061, 1041, 1063, 1067, 1044, 1047, 1048, 1068,
+     1049, 1069, 1070, 1050, 1072, 1051, 1073, 1052, 1074, 1053,
+     1054, 1055, 1056, 1058, 1059, 1075, 1076, 1077, 1060, 1078,
+     1081, 1083, 1061, 1063, 1084, 1067, 1085,  468, 1086, 1068,
+     1069, 1087, 1070, 1088, 1072, 1090, 1073, 1093, 1074, 1094,
+     1097,  437, 1098, 1099, 1102, 1075, 1076, 1077, 1078, 1081,
+     1103, 1083, 1160, 1084, 1160,  419, 1085, 1086,  392, 1189,
+     1087, 1189, 1088,  377,  351, 1090,  341, 1093, 1094,  339,
+     1097, 1098, 1099,  334, 1102,  301,  300,  299,  296,  285,
+
+     1103, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107,
+     1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1108, 1108,
+     1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108,
+     1108, 1108, 1108, 1108, 1108, 1109, 1109, 1109, 1109, 1109,
+     1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109,
+     1109, 1109, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110,
+     1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1111,
+     1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111,
+     1111, 1111, 1111, 1111, 1111, 1111, 1112, 1112, 1112, 1112,
+     1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112,
+
+     1112, 1112, 1112, 1113, 1113, 1113, 1113, 1113, 1113, 1113,
+     1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113,
+     1114, 1114, 1114, 1114, 1114, 1114, 1114, 1114, 1114, 1114,
+     1114, 1114, 1114, 1114, 1114, 1114, 1114, 1115, 1115, 1115,
+     1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115,
+     1115, 1115, 1115, 1115, 1116, 1116, 1116, 1116, 1116, 1116,
+     1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116,
+     1116, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117,
+     1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1118, 1118,
+     1118, 1118, 1118, 1118, 1118, 1118, 1118, 1118, 1118, 1118,
+
+     1118, 1118, 1118, 1118, 1118, 1119, 1119, 1119, 1119, 1119,
+     1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119,
+     1119, 1119, 1120, 1120, 1120, 1120, 1120, 1120, 1120, 1120,
+     1120, 1120, 1120, 1120, 1120, 1120, 1120, 1120, 1120, 1121,
+     1121, 1121, 1121, 1121, 1121, 1121, 1121, 1121, 1121, 1121,
+     1121, 1121, 1121, 1121, 1121, 1121, 1122, 1122, 1122, 1122,
+     1122, 1122, 1122, 1122, 1122, 1122, 1122, 1122, 1122, 1122,
+     1122, 1122, 1122, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
+     1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
+     1124, 1124, 1124, 1124, 1124, 1124, 1124, 1124, 1124, 1124,
+
+     1124, 1124, 1124, 1124, 1124, 1124, 1124, 1125, 1125, 1125,
+     1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
+     1125, 1125, 1125, 1125, 1126, 1126,  282, 1126, 1126,  274,
+      273,  272, 1126, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
+     1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1128,
+     1128,  271, 1128, 1128,  268,  266,  265, 1128, 1129,  256,
+     1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
+     1129, 1129, 1129, 1129, 1129, 1130,  255, 1130, 1130, 1130,
+     1130, 1130, 1130, 1130, 1130, 1130, 1130, 1130, 1130, 1130,
+     1130, 1130, 1131, 1131, 1131,  252, 1131, 1131,  251,  234,
+
+      230, 1131, 1132,  227, 1132, 1132, 1132, 1132, 1132, 1132,
+     1132, 1132, 1132, 1132, 1132, 1132, 1132, 1132, 1132, 1133,
+      226, 1133, 1133, 1133, 1133, 1133, 1133, 1133, 1133, 1133,
+     1133, 1133, 1133, 1133, 1133, 1133, 1134, 1134, 1134, 1134,
+     1134, 1134, 1134, 1134, 1134, 1134, 1134, 1134,  222, 1134,
+      208, 1134, 1134, 1135,  207,  206, 1135, 1135, 1135, 1135,
+     1135, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 1135,
+     1136, 1136,  202, 1136, 1136,  175,  174,  172, 1136, 1137,
+      170, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137,
+     1137, 1137, 1137, 1137, 1137, 1137, 1138,  169, 1138, 1138,
+
+     1138, 1138, 1138, 1138, 1138, 1138, 1138, 1138, 1138, 1138,
+      166, 1138, 1138, 1139,  165, 1139,  164,  158, 1139, 1139,
+     1139, 1139, 1139,  155,  154,  153, 1139, 1140,  152, 1140,
+     1140, 1140, 1140, 1140, 1140, 1140, 1140, 1140, 1140, 1140,
+     1140, 1140, 1140, 1140, 1141, 1141,  144, 1141, 1141,  143,
+      139,  136, 1141, 1142, 1142, 1142, 1142, 1142, 1142, 1142,
+     1142, 1142, 1142, 1142, 1142, 1142, 1142, 1142, 1142, 1142,
+     1143,  131, 1143,  129, 1143, 1143, 1143, 1143, 1143, 1143,
+     1143, 1143, 1143,  124, 1143, 1143, 1143, 1144,  120, 1144,
+     1144, 1144, 1144, 1144, 1144, 1144, 1144, 1144, 1144, 1144,
+
+     1144, 1144, 1144, 1144, 1145,  114, 1145, 1145, 1145, 1145,
+     1145, 1145, 1145, 1145, 1145, 1145, 1145, 1145, 1145, 1145,
+     1145, 1146, 1146,  109,  107, 1146, 1146, 1148,  106, 1148,
+     1148, 1148, 1148, 1148, 1148, 1148, 1148, 1148, 1148, 1148,
+     1148, 1148, 1148, 1148, 1149,  103, 1149, 1149, 1149,  101,
+     1149, 1149, 1149, 1149, 1149, 1149, 1149, 1149, 1149, 1149,
+     1149, 1150, 1150,   99, 1150, 1150,   98,   97,   94, 1150,
+     1151,   91, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151,
+     1151, 1151, 1151, 1151, 1151, 1151, 1151, 1152,   90, 1152,
+     1152, 1152, 1152, 1152, 1152, 1152, 1152, 1152, 1152, 1152,
+
+     1152, 1152, 1152, 1152, 1153, 1153,   88,   86,   84, 1153,
+     1154, 1154,   80,   78,   72, 1154, 1155, 1155, 1155, 1155,
+     1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155,
+     1155, 1155, 1155, 1156, 1156,   71, 1156, 1156,   68,   65,
+       60, 1156, 1157, 1157, 1157, 1157, 1157, 1157, 1157, 1157,
+     1157, 1157, 1157, 1157, 1157, 1157, 1157, 1157, 1157, 1158,
+       57, 1158, 1158, 1158, 1158, 1158, 1158, 1158, 1158, 1158,
+     1158, 1158, 1158,   53, 1158, 1158, 1159,   49, 1159, 1159,
+     1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159,
+     1159, 1159, 1159, 1161, 1161,   16, 1161, 1161,   15,    0,
+
+        0, 1161, 1161, 1162,    0, 1162, 1162, 1162, 1162, 1162,
+     1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162,
+     1163,    0, 1163, 1163, 1163, 1163, 1163, 1163, 1163, 1163,
+     1163, 1163, 1163, 1163, 1163, 1163, 1163, 1164,    0, 1164,
+     1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164,
+     1164, 1164, 1164, 1164, 1165,    0, 1165, 1165, 1165, 1165,
+     1165, 1165, 1165, 1165, 1165, 1165, 1165, 1165, 1165, 1165,
+     1165, 1166,    0, 1166, 1166, 1166, 1166, 1166, 1166, 1166,
+     1166, 1166, 1166, 1166, 1166, 1166, 1166, 1166, 1167, 1167,
+     1167, 1167, 1167, 1167, 1167, 1167, 1167, 1167, 1167, 1167,
+
+        0, 1167,    0, 1167, 1167, 1168, 1168, 1168, 1168, 1168,
+     1168, 1168, 1168, 1168, 1168, 1168, 1168, 1168, 1168, 1168,
+     1168, 1168, 1169,    0,    0, 1169, 1169, 1169, 1169, 1169,
+     1169, 1169, 1169, 1169, 1169, 1169, 1169, 1169, 1169, 1170,
+     1170,    0, 1170, 1170,    0,    0,    0, 1170, 1171,    0,
+     1171,    0,    0, 1171, 1171, 1171, 1171, 1171,    0,    0,
+        0, 1171, 1172,    0, 1172, 1172, 1172, 1172, 1172, 1172,
+     1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1173,
+     1173,    0, 1173, 1173,    0,    0,    0, 1173, 1174, 1174,
+     1174, 1174, 1174, 1174, 1174, 1174, 1174, 1174, 1174, 1174,
+
+     1174, 1174, 1174, 1174, 1174, 1175,    0, 1175,    0, 1175,
+     1175, 1175, 1175, 1175, 1175, 1175, 1175, 1175,    0, 1175,
+     1175, 1175, 1176,    0, 1176, 1176, 1176, 1176, 1176, 1176,
+     1176, 1176, 1176, 1176, 1176, 1176, 1176, 1176, 1176, 1177,
+        0, 1177, 1177, 1177, 1177, 1177, 1177, 1177, 1177, 1177,
+     1177, 1177, 1177, 1177, 1177, 1177, 1178, 1178,    0,    0,
+     1178, 1178, 1179,    0, 1179, 1179, 1179, 1179, 1179, 1179,
+     1179, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 1180,
+        0, 1180, 1180, 1180,    0, 1180, 1180, 1180, 1180, 1180,
+     1180, 1180, 1180, 1180, 1180, 1180, 1181,    0, 1181, 1181,
+
+     1181, 1181, 1181, 1181, 1181, 1181, 1181, 1181, 1181, 1181,
+     1181, 1181, 1181, 1182,    0, 1182, 1182, 1182, 1182, 1182,
+     1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182,
+     1183, 1183, 1183, 1183, 1183, 1183, 1183, 1183, 1183, 1183,
+     1183, 1183, 1183, 1183, 1183, 1183, 1183, 1184, 1184,    0,
+     1184, 1184,    0,    0,    0, 1184, 1185, 1185,    0, 1185,
+     1185,    0,    0,    0, 1185, 1186, 1186, 1186, 1186, 1186,
+     1186, 1186, 1186, 1186, 1186, 1186, 1186, 1186, 1186, 1186,
+     1186, 1186, 1187, 1187, 1187, 1187, 1187, 1187, 1187, 1187,
+     1187, 1187, 1187, 1187, 1187, 1187, 1187, 1187, 1187, 1188,
+
+        0, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
+     1188, 1188, 1188,    0, 1188, 1188, 1190, 1190,    0, 1190,
+     1190,    0,    0,    0, 1190, 1190, 1191,    0, 1191, 1191,
+     1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191,
+     1191, 1191, 1191, 1192,    0, 1192, 1192, 1192, 1192, 1192,
+     1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192,
+     1193,    0, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193,
+     1193, 1193, 1193, 1193, 1193, 1193, 1193, 1194, 1194, 1194,
+     1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194,
+     1194, 1194, 1194, 1194, 1195, 1195, 1195, 1196, 1196,    0,
+
+     1196, 1196,    0,    0,    0, 1196, 1197,    0, 1197, 1197,
+     1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+     1197, 1197, 1197, 1198,    0, 1198, 1198, 1198, 1198, 1198,
+     1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198,
+     1199, 1199, 1199, 1199, 1199, 1199, 1199, 1199, 1199, 1199,
+     1199, 1199, 1199, 1199, 1199, 1199, 1199, 1200, 1200, 1200,
+     1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200,
+     1200, 1200, 1200, 1200, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106,
+     1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106, 1106
     } ;
 
-static yy_state_type yy_last_accepting_state;
-static char *yy_last_accepting_cpos;
-
-/* 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
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
+static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
+static char *yy_full_match;
+static int yy_lp;
+#define REJECT \
+{ \
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
+yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
+++(yy_lp); \
+goto find_rule; \
+}
+
+static int yy_more_flag = 0;
+static int yy_more_len = 0;
+#define yymore() ((yy_more_flag) = 1)
+#define YY_MORE_ADJ (yy_more_len)
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
 #line 1 "scan.l"
-#define INITIAL 0
-/* scan.l - scanner for flex input */
+/* scan.l - scanner for flex input -*-C-*- */
 #line 4 "scan.l"
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Vern Paxson.
- * 
- * The United States Government has rights in this work pursuant
- * to contract no. DE-AC03-76SF00098 between the United States
- * Department of Energy and the University of California.
- *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * 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.
- */
+/*  Copyright (c) 1990 The Regents of the University of California. */
+/*  All rights reserved. */
 
-/* $Header: /home/daffy/u0/vern/flex/RCS/scan.l,v 2.56 95/04/24 12:17:19 vern Exp $ */
-/* $FreeBSD$ */
+/*  This code is derived from software contributed to Berkeley by */
+/*  Vern Paxson. */
+
+/*  The United States Government has rights in this work pursuant */
+/*  to contract no. DE-AC03-76SF00098 between the United States */
+/*  Department of Energy and the University of California. */
+
+/*  This file is part of flex. */
+
+/*  Redistribution and use in source and binary forms, with or without */
+/*  modification, are permitted provided that the following conditions */
+/*  are met: */
+
+/*  1. Redistributions of source code must retain the above copyright */
+/*     notice, this list of conditions and the following disclaimer. */
+/*  2. Redistributions in binary form must reproduce the above copyright */
+/*     notice, this list of conditions and the following disclaimer in the */
+/*     documentation and/or other materials provided with the distribution. */
+
+/*  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. */
 
 #include "flexdef.h"
 #include "parse.h"
+extern bool tablesverify, tablesext;
+extern int trlcontxt; /* Set in  parse.y for each rule. */
+extern const char *escaped_qstart, *escaped_qend;
 
 #define ACTION_ECHO add_action( yytext )
 #define ACTION_IFDEF(def, should_define) \
@@ -1291,6 +1932,17 @@ char *yytext;
 		action_define( def, 1 ); \
 	}
 
+#define ACTION_ECHO_QSTART add_action (escaped_qstart)
+#define ACTION_ECHO_QEND   add_action (escaped_qend)
+
+#define ACTION_M4_IFDEF(def, should_define) \
+    do{ \
+        if ( should_define ) \
+            buf_m4_define( &m4defs_buf, def, NULL);\
+        else \
+            buf_m4_undefine( &m4defs_buf, def);\
+    } while(0)
+
 #define MARK_END_OF_PROLOG mark_prolog();
 
 #define YY_DECL \
@@ -1301,7 +1953,15 @@ char *yytext;
 	return CHAR;
 
 #define RETURNNAME \
+	if(yyleng < MAXLINE) \
+         { \
 	strcpy( nmstr, yytext ); \
+	 } \
+	else \
+	 { \
+	   synerr(_("Input line too long\n")); \
+	   FLEX_EXIT(EXIT_FAILURE);  \
+	 }  \
 	return NAME;
 
 #define PUT_BACK_STRING(str, start) \
@@ -1315,8 +1975,21 @@ char *yytext;
 #define CHECK_YYMORE(str) \
 	if ( all_lower( str ) ) \
 		yymore_used = true;
-#define YY_STACK_USED 1
-#define YY_NO_TOP_STATE 1
+
+#define YY_USER_INIT \
+	if ( getenv("POSIXLY_CORRECT") ) \
+		posix_compat = true;
+
+
+
+
+
+
+
+
+#line 1990 "<stdout>"
+
+#define INITIAL 0
 #define SECT2 1
 #define SECT2PROLOG 2
 #define SECT3 3
@@ -1326,7 +1999,6 @@ char *yytext;
 #define CARETISBOL 7
 #define NUM 8
 #define QUOTE 9
-
 #define FIRSTCCL 10
 #define CCL 11
 #define ACTION 12
@@ -1334,11 +2006,56 @@ char *yytext;
 #define COMMENT 14
 #define ACTION_STRING 15
 #define PERCENT_BRACE_ACTION 16
-
 #define OPTION 17
 #define LINEDIR 18
+#define CODEBLOCK_MATCH_BRACE 19
+#define GROUP_WITH_PARAMS 20
+#define GROUP_MINUS_PARAMS 21
+#define EXTENDED_COMMENT 22
+#define COMMENT_DISCARD 23
+
+#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
 
-#line 1342 "scan.c"
+static int yy_init_globals (void );
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy (void );
+
+int yyget_debug (void );
+
+void yyset_debug (int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra (void );
+
+void yyset_extra (YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in (void );
+
+void yyset_in  (FILE * in_str  );
+
+FILE *yyget_out (void );
+
+void yyset_out  (FILE * out_str  );
+
+yy_size_t yyget_leng (void );
+
+char *yyget_text (void );
+
+int yyget_lineno (void );
+
+void yyset_lineno (int line_number  );
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -1346,79 +2063,53 @@ char *yytext;
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap YY_PROTO(( void ));
+extern "C" int yywrap (void );
 #else
-extern int yywrap YY_PROTO(( void ));
+extern int yywrap (void );
 #endif
 #endif
 
 #ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+    static void yyunput (int c,char *buf_ptr  );
 #endif
-
+    
 #ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+static int yy_flex_strlen (yyconst char * );
 #endif
 
 #ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
-#else
-static int input YY_PROTO(( void ));
-#endif
-#endif
-
-#if YY_STACK_USED
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-#ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
-#endif
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
-#endif
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( void ));
-#endif
 
+#ifdef __cplusplus
+static int yyinput (void );
 #else
-#define YY_NO_PUSH_STATE 1
-#define YY_NO_POP_STATE 1
-#define YY_NO_TOP_STATE 1
+static int input (void );
 #endif
 
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
 #endif
 
+        static int yy_start_stack_ptr = 0;
+        static int yy_start_stack_depth = 0;
+        static int *yy_start_stack = NULL;
+    
+    static void yy_push_state (int new_state );
+    
+    static void yy_pop_state (void );
+    
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
 #define YY_READ_BUF_SIZE 8192
 #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 (void) fwrite( yytext, yyleng, 1, yyout )
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -1426,9 +2117,10 @@ YY_MALLOC_DECL
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-	if ( yy_current_buffer->yy_is_interactive ) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 		{ \
-		int c = '*', n; \
+		int c = '*'; \
+		size_t n; \
 		for ( n = 0; n < max_size && \
 			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 			buf[n] = (char) c; \
@@ -1438,9 +2130,22 @@ YY_MALLOC_DECL
 			YY_FATAL_ERROR( "input in flex scanner failed" ); \
 		result = n; \
 		} \
-	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
-		  && ferror( yyin ) ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
+	else \
+		{ \
+		errno=0; \
+		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
 #endif
 
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
@@ -1461,12 +2166,18 @@ YY_MALLOC_DECL
 #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 int yylex YY_PROTO(( void ))
-#endif
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
 
 /* Code executed at the beginning of each rule, after yytext and yyleng
  * have been set up.
@@ -1482,39 +2193,47 @@ YY_MALLOC_DECL
 
 #define YY_RULE_SETUP \
 	if ( yyleng > 0 ) \
-		yy_current_buffer->yy_at_bol = \
+		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
 				(yytext[yyleng - 1] == '\n'); \
 	YY_USER_ACTION
 
+/** The main scanner function which does all the work.
+ */
 YY_DECL
-	{
+{
 	yy_state_type yy_current_state;
 	char *yy_cp, *yy_bp;
 	int yy_act;
-
-#line 95 "scan.l"
+    
+#line 131 "scan.l"
 
 	static int bracelevel, didadef, indented_code;
 	static int doing_rule_action = false;
 	static int option_sense;
 
 	int doing_codeblock = false;
-	int i;
-	Char nmdef[MAXLINE], myesc();
+	int i, brace_depth=0, brace_start_line=0;
+	Char nmdef[MAXLINE];
 
 
-#line 1507 "scan.c"
+#line 2219 "<stdout>"
 
-	if ( yy_init )
+	if ( !(yy_init) )
 		{
-		yy_init = 0;
+		(yy_init) = 1;
 
 #ifdef YY_USER_INIT
 		YY_USER_INIT;
 #endif
 
-		if ( ! yy_start )
-			yy_start = 1;	/* first start state */
+        /* Create the reject buffer large enough to save one state per allowed character. */
+        if ( ! (yy_state_buf) )
+            (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
+            if ( ! (yy_state_buf) )
+                YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
 
 		if ( ! yyin )
 			yyin = stdin;
@@ -1522,100 +2241,111 @@ YY_DECL
 		if ( ! yyout )
 			yyout = stdout;
 
-		if ( ! yy_current_buffer )
-			yy_current_buffer =
-				yy_create_buffer( yyin, YY_BUF_SIZE );
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer(yyin,YY_BUF_SIZE );
+		}
 
-		yy_load_buffer_state();
+		yy_load_buffer_state( );
 		}
 
 	while ( 1 )		/* loops until end-of-file is reached */
 		{
-		yy_cp = yy_c_buf_p;
+		(yy_more_len) = 0;
+		if ( (yy_more_flag) )
+			{
+			(yy_more_len) = (yy_c_buf_p) - (yytext_ptr);
+			(yy_more_flag) = 0;
+			}
+		yy_cp = (yy_c_buf_p);
 
 		/* Support of yytext. */
-		*yy_cp = yy_hold_char;
+		*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_current_state = (yy_start);
 		yy_current_state += YY_AT_BOL();
+
+		(yy_state_ptr) = (yy_state_buf);
+		*(yy_state_ptr)++ = yy_current_state;
+
 yy_match:
 		do
 			{
-			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;
-				}
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*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 >= 769 )
+				if ( yy_current_state >= 1107 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			*(yy_state_ptr)++ = yy_current_state;
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 2716 );
+		while ( yy_base[yy_current_state] != 3975 );
 
 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_current_state = *--(yy_state_ptr);
+		(yy_lp) = yy_accept[yy_current_state];
+goto find_rule; /* avoid `defined but not used' warning */
+find_rule: /* we branch to this label when backing up */
+		for ( ; ; ) /* until we find what rule we matched */
+			{
+			if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
+				{
+				yy_act = yy_acclist[(yy_lp)];
+					{
+					(yy_full_match) = yy_cp;
+					break;
+					}
+				}
+			--yy_cp;
+			yy_current_state = *--(yy_state_ptr);
+			(yy_lp) = 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 106 "scan.l"
+#line 142 "scan.l"
 indented_code = true; BEGIN(CODEBLOCK);
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 107 "scan.l"
+#line 143 "scan.l"
 ACTION_ECHO; yy_push_state( COMMENT );
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 108 "scan.l"
+#line 144 "scan.l"
 yy_push_state( LINEDIR );
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 109 "scan.l"
+#line 145 "scan.l"
 return SCDECL;
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 110 "scan.l"
+#line 146 "scan.l"
 return XSCDECL;
 	YY_BREAK
 case 6:
+/* rule 6 can match eol */
 YY_RULE_SETUP
-#line 111 "scan.l"
+#line 147 "scan.l"
 {
 			++linenum;
 			line_directive_out( (FILE *) 0, 1 );
@@ -1624,13 +2354,30 @@ YY_RULE_SETUP
 			}
 	YY_BREAK
 case 7:
+/* rule 7 can match eol */
 YY_RULE_SETUP
-#line 118 "scan.l"
-/* discard */
+#line 153 "scan.l"
+{
+                brace_start_line = linenum;
+                ++linenum;
+                buf_linedir( &top_buf, infilename?infilename:"<stdin>", linenum);
+                brace_depth = 1;
+                yy_push_state(CODEBLOCK_MATCH_BRACE);
+            }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 120 "scan.l"
+#line 161 "scan.l"
+synerr( _("malformed '%top' directive") );
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 163 "scan.l"
+/* discard */
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 165 "scan.l"
 {
 			sectnum = 2;
 			bracelevel = 0;
@@ -1640,123 +2387,206 @@ YY_RULE_SETUP
 			return SECTEND;
 			}
 	YY_BREAK
-case 9:
+case 11:
+/* rule 11 can match eol */
 YY_RULE_SETUP
-#line 129 "scan.l"
+#line 174 "scan.l"
 yytext_is_array = false; ++linenum;
 	YY_BREAK
-case 10:
+case 12:
+/* rule 12 can match eol */
 YY_RULE_SETUP
-#line 130 "scan.l"
+#line 175 "scan.l"
 yytext_is_array = true; ++linenum;
 	YY_BREAK
-case 11:
+case 13:
 YY_RULE_SETUP
-#line 132 "scan.l"
+#line 177 "scan.l"
 BEGIN(OPTION); return OPTION_OP;
 	YY_BREAK
-case 12:
+case 14:
+/* rule 14 can match eol */
 YY_RULE_SETUP
-#line 134 "scan.l"
+#line 179 "scan.l"
 ++linenum; /* ignore */
 	YY_BREAK
-case 13:
+case 15:
+/* rule 15 can match eol */
 YY_RULE_SETUP
-#line 135 "scan.l"
+#line 180 "scan.l"
 ++linenum;	/* ignore */
 	YY_BREAK
-case 14:
+/* xgettext: no-c-format */
+case 16:
+/* rule 16 can match eol */
 YY_RULE_SETUP
-#line 137 "scan.l"
+#line 183 "scan.l"
 synerr( _( "unrecognized '%' directive" ) );
 	YY_BREAK
-case 15:
+case 17:
 YY_RULE_SETUP
-#line 139 "scan.l"
+#line 185 "scan.l"
 {
+			if(yyleng < MAXLINE)
+        		 {
 			strcpy( nmstr, yytext );
+			 }
+			else
+			 {
+			   synerr( _("Definition name too long\n"));
+			   FLEX_EXIT(EXIT_FAILURE);
+			 }
+
 			didadef = false;
 			BEGIN(PICKUPDEF);
 			}
 	YY_BREAK
-case 16:
+case 18:
 YY_RULE_SETUP
-#line 145 "scan.l"
+#line 200 "scan.l"
 RETURNNAME;
 	YY_BREAK
-case 17:
+case 19:
+/* rule 19 can match eol */
 YY_RULE_SETUP
-#line 146 "scan.l"
+#line 201 "scan.l"
 ++linenum; /* allows blank lines in section 1 */
 	YY_BREAK
-case 18:
+case 20:
+/* rule 20 can match eol */
 YY_RULE_SETUP
-#line 147 "scan.l"
+#line 202 "scan.l"
 ACTION_ECHO; ++linenum; /* maybe end of comment line */
 	YY_BREAK
 
 
-case 19:
+case 21:
 YY_RULE_SETUP
-#line 152 "scan.l"
+#line 207 "scan.l"
 ACTION_ECHO; yy_pop_state();
 	YY_BREAK
-case 20:
+case 22:
 YY_RULE_SETUP
-#line 153 "scan.l"
+#line 208 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 21:
+case 23:
 YY_RULE_SETUP
-#line 154 "scan.l"
+#line 209 "scan.l"
+ACTION_ECHO_QSTART;
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 210 "scan.l"
+ACTION_ECHO_QEND;
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 211 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 22:
+case 26:
+/* rule 26 can match eol */
 YY_RULE_SETUP
-#line 155 "scan.l"
+#line 212 "scan.l"
 ++linenum; ACTION_ECHO;
 	YY_BREAK
 
 
-case 23:
+/* This is the same as COMMENT, but is discarded rather than output. */
+case 27:
 YY_RULE_SETUP
-#line 159 "scan.l"
+#line 217 "scan.l"
 yy_pop_state();
 	YY_BREAK
-case 24:
+case 28:
+YY_RULE_SETUP
+#line 218 "scan.l"
+;
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 219 "scan.l"
+;
+	YY_BREAK
+case 30:
+/* rule 30 can match eol */
+YY_RULE_SETUP
+#line 220 "scan.l"
+++linenum;
+	YY_BREAK
+
+
+case 31:
+YY_RULE_SETUP
+#line 224 "scan.l"
+yy_pop_state();
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 225 "scan.l"
+;
+	YY_BREAK
+case 33:
+/* rule 33 can match eol */
+YY_RULE_SETUP
+#line 226 "scan.l"
+++linenum;        
+	YY_BREAK
+
+
+case 34:
+/* rule 34 can match eol */
+YY_RULE_SETUP
+#line 230 "scan.l"
+yy_pop_state();
+	YY_BREAK
+case 35:
 YY_RULE_SETUP
-#line 160 "scan.l"
+#line 231 "scan.l"
 linenum = myctoi( yytext );
 	YY_BREAK
-case 25:
+case 36:
 YY_RULE_SETUP
-#line 162 "scan.l"
+#line 233 "scan.l"
 {
 			flex_free( (void *) infilename );
 			infilename = copy_string( yytext + 1 );
 			infilename[strlen( infilename ) - 1] = '\0';
 			}
 	YY_BREAK
-case 26:
+case 37:
 YY_RULE_SETUP
-#line 167 "scan.l"
+#line 238 "scan.l"
 /* ignore spurious characters */
 	YY_BREAK
 
 
-case 27:
+case 38:
+/* rule 38 can match eol */
 YY_RULE_SETUP
-#line 171 "scan.l"
+#line 242 "scan.l"
 ++linenum; BEGIN(INITIAL);
 	YY_BREAK
-case 28:
+case 39:
+YY_RULE_SETUP
+#line 244 "scan.l"
+ACTION_ECHO_QSTART;
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 245 "scan.l"
+ACTION_ECHO_QEND;
+	YY_BREAK
+case 41:
 YY_RULE_SETUP
-#line 173 "scan.l"
+#line 246 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 29:
+case 42:
+/* rule 42 can match eol */
 YY_RULE_SETUP
-#line 175 "scan.l"
+#line 248 "scan.l"
 {
 			++linenum;
 			ACTION_ECHO;
@@ -1766,17 +2596,79 @@ YY_RULE_SETUP
 	YY_BREAK
 
 
-case 30:
+case 43:
 YY_RULE_SETUP
-#line 185 "scan.l"
+#line 257 "scan.l"
+{
+                if( --brace_depth == 0){
+                    /* TODO: Matched. */
+                    yy_pop_state();
+                }else
+                    buf_strnappend(&top_buf, yytext, yyleng);
+            }
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 265 "scan.l"
+{
+                brace_depth++;
+                buf_strnappend(&top_buf, yytext, yyleng);
+            }
+	YY_BREAK
+case 45:
+/* rule 45 can match eol */
+YY_RULE_SETUP
+#line 270 "scan.l"
+{
+                ++linenum;
+                buf_strnappend(&top_buf, yytext, yyleng);
+            }
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 275 "scan.l"
+buf_strnappend(&top_buf, escaped_qstart, strlen(escaped_qstart));
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 276 "scan.l"
+buf_strnappend(&top_buf, escaped_qend, strlen(escaped_qend));
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 278 "scan.l"
+{
+                buf_strnappend(&top_buf, yytext, yyleng);
+               }
+	YY_BREAK
+case YY_STATE_EOF(CODEBLOCK_MATCH_BRACE):
+#line 282 "scan.l"
+{
+                linenum = brace_start_line;
+                synerr(_("Unmatched '{'"));
+                yyterminate();
+                }
+	YY_BREAK
+
+
+case 49:
+YY_RULE_SETUP
+#line 291 "scan.l"
 /* separates name and definition */
 	YY_BREAK
-case 31:
+case 50:
 YY_RULE_SETUP
-#line 187 "scan.l"
+#line 293 "scan.l"
 {
+ 		        if(yyleng < MAXLINE)
+ 		         {
 			strcpy( (char *) nmdef, yytext );
-
+ 		         }
+ 		        else
+ 		         {
+ 		           format_synerr( _("Definition value for {%s} too long\n"), nmstr);
+ 		           FLEX_EXIT(EXIT_FAILURE);
+			 }
 			/* Skip trailing whitespace. */
 			for ( i = strlen( (char *) nmdef ) - 1;
 			      i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
@@ -1789,9 +2681,10 @@ YY_RULE_SETUP
 			didadef = true;
 			}
 	YY_BREAK
-case 32:
+case 51:
+/* rule 51 can match eol */
 YY_RULE_SETUP
-#line 202 "scan.l"
+#line 315 "scan.l"
 {
 			if ( ! didadef )
 				synerr( _( "incomplete name definition" ) );
@@ -1801,266 +2694,435 @@ YY_RULE_SETUP
 	YY_BREAK
 
 
-case 33:
+case 52:
+/* rule 52 can match eol */
 YY_RULE_SETUP
-#line 212 "scan.l"
+#line 325 "scan.l"
 ++linenum; BEGIN(INITIAL);
 	YY_BREAK
-case 34:
+case 53:
 YY_RULE_SETUP
-#line 213 "scan.l"
+#line 326 "scan.l"
 option_sense = true;
 	YY_BREAK
-case 35:
+case 54:
 YY_RULE_SETUP
-#line 215 "scan.l"
+#line 328 "scan.l"
 return '=';
 	YY_BREAK
-case 36:
+case 55:
 YY_RULE_SETUP
-#line 217 "scan.l"
+#line 330 "scan.l"
 option_sense = ! option_sense;
 	YY_BREAK
-case 37:
+case 56:
 YY_RULE_SETUP
-#line 219 "scan.l"
+#line 332 "scan.l"
 csize = option_sense ? 128 : 256;
 	YY_BREAK
-case 38:
+case 57:
 YY_RULE_SETUP
-#line 220 "scan.l"
+#line 333 "scan.l"
 csize = option_sense ? 256 : 128;
 	YY_BREAK
-case 39:
+case 58:
 YY_RULE_SETUP
-#line 222 "scan.l"
+#line 335 "scan.l"
 long_align = option_sense;
 	YY_BREAK
-case 40:
+case 59:
 YY_RULE_SETUP
-#line 223 "scan.l"
+#line 336 "scan.l"
 {
-			action_define( "YY_ALWAYS_INTERACTIVE", option_sense );
+			ACTION_M4_IFDEF( "M4""_YY_ALWAYS_INTERACTIVE", option_sense );
+            interactive = option_sense;
 			}
 	YY_BREAK
-case 41:
+case 60:
 YY_RULE_SETUP
-#line 226 "scan.l"
+#line 340 "scan.l"
 yytext_is_array = option_sense;
 	YY_BREAK
-case 42:
+case 61:
 YY_RULE_SETUP
-#line 227 "scan.l"
+#line 341 "scan.l"
+ansi_func_defs = option_sense;
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 342 "scan.l"
+ansi_func_protos = option_sense;
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 343 "scan.l"
 backing_up_report = option_sense;
 	YY_BREAK
-case 43:
+case 64:
 YY_RULE_SETUP
-#line 228 "scan.l"
+#line 344 "scan.l"
 interactive = ! option_sense;
 	YY_BREAK
-case 44:
+case 65:
+YY_RULE_SETUP
+#line 345 "scan.l"
+bison_bridge_lval = option_sense;
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 346 "scan.l"
+{ if((bison_bridge_lloc = option_sense))
+                            bison_bridge_lval = true;
+                     }
+	YY_BREAK
+case 67:
 YY_RULE_SETUP
-#line 229 "scan.l"
+#line 349 "scan.l"
 C_plus_plus = option_sense;
 	YY_BREAK
-case 45:
+case 68:
 YY_RULE_SETUP
-#line 230 "scan.l"
-caseins = ! option_sense;
+#line 350 "scan.l"
+sf_set_case_ins(!option_sense);
 	YY_BREAK
-case 46:
+case 69:
 YY_RULE_SETUP
-#line 231 "scan.l"
-caseins = option_sense;
+#line 351 "scan.l"
+sf_set_case_ins(option_sense);
 	YY_BREAK
-case 47:
+case 70:
 YY_RULE_SETUP
-#line 232 "scan.l"
+#line 352 "scan.l"
 ddebug = option_sense;
 	YY_BREAK
-case 48:
+case 71:
 YY_RULE_SETUP
-#line 233 "scan.l"
+#line 353 "scan.l"
 spprdflt = ! option_sense;
 	YY_BREAK
-case 49:
+case 72:
 YY_RULE_SETUP
-#line 234 "scan.l"
+#line 354 "scan.l"
 useecs = option_sense;
 	YY_BREAK
-case 50:
+case 73:
 YY_RULE_SETUP
-#line 235 "scan.l"
+#line 355 "scan.l"
 {
 			useecs = usemecs = false;
 			use_read = fullspd = true;
 			}
 	YY_BREAK
-case 51:
+case 74:
 YY_RULE_SETUP
-#line 239 "scan.l"
+#line 359 "scan.l"
 {
 			useecs = usemecs = false;
 			use_read = fulltbl = true;
 			}
 	YY_BREAK
-case 52:
+case 75:
 YY_RULE_SETUP
-#line 243 "scan.l"
+#line 363 "scan.l"
 ACTION_IFDEF("YY_NO_INPUT", ! option_sense);
 	YY_BREAK
-case 53:
+case 76:
 YY_RULE_SETUP
-#line 244 "scan.l"
+#line 364 "scan.l"
 interactive = option_sense;
 	YY_BREAK
-case 54:
+case 77:
 YY_RULE_SETUP
-#line 245 "scan.l"
+#line 365 "scan.l"
 lex_compat = option_sense;
 	YY_BREAK
-case 55:
+case 78:
 YY_RULE_SETUP
-#line 246 "scan.l"
+#line 366 "scan.l"
+posix_compat = option_sense;
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
+#line 367 "scan.l"
 {
-			action_define( "YY_MAIN", option_sense );
-			do_yywrap = ! option_sense;
+			ACTION_M4_IFDEF( "M4""_YY_MAIN", option_sense);
+            /* Override yywrap */
+            if( option_sense == true )
+                do_yywrap = false;
 			}
 	YY_BREAK
-case 56:
+case 80:
 YY_RULE_SETUP
-#line 250 "scan.l"
+#line 373 "scan.l"
 usemecs = option_sense;
 	YY_BREAK
-case 57:
+case 81:
 YY_RULE_SETUP
-#line 251 "scan.l"
+#line 374 "scan.l"
 {
-			action_define( "YY_NEVER_INTERACTIVE", option_sense );
+			ACTION_M4_IFDEF( "M4""_YY_NEVER_INTERACTIVE", option_sense );
+            interactive = !option_sense;
 			}
 	YY_BREAK
-case 58:
+case 82:
 YY_RULE_SETUP
-#line 254 "scan.l"
+#line 378 "scan.l"
 performance_report += option_sense ? 1 : -1;
 	YY_BREAK
-case 59:
+case 83:
 YY_RULE_SETUP
-#line 255 "scan.l"
+#line 379 "scan.l"
 yytext_is_array = ! option_sense;
 	YY_BREAK
-case 60:
+case 84:
 YY_RULE_SETUP
-#line 256 "scan.l"
+#line 380 "scan.l"
 use_read = option_sense;
 	YY_BREAK
-case 61:
+case 85:
 YY_RULE_SETUP
-#line 257 "scan.l"
+#line 381 "scan.l"
+reentrant = option_sense;
+	YY_BREAK
+case 86:
+YY_RULE_SETUP
+#line 382 "scan.l"
 reject_really_used = option_sense;
 	YY_BREAK
-case 62:
+case 87:
 YY_RULE_SETUP
-#line 258 "scan.l"
-action_define( "YY_STACK_USED", option_sense );
+#line 383 "scan.l"
+ACTION_M4_IFDEF( "M4""_YY_STACK_USED", option_sense );
 	YY_BREAK
-case 63:
+case 88:
 YY_RULE_SETUP
-#line 259 "scan.l"
+#line 384 "scan.l"
 do_stdinit = option_sense;
 	YY_BREAK
-case 64:
+case 89:
 YY_RULE_SETUP
-#line 260 "scan.l"
+#line 385 "scan.l"
 use_stdout = option_sense;
 	YY_BREAK
-case 65:
+case 90:
 YY_RULE_SETUP
-#line 261 "scan.l"
-ACTION_IFDEF("YY_NO_UNPUT", ! option_sense);
+#line 386 "scan.l"
+ACTION_IFDEF("YY_NO_UNISTD_H", ! option_sense);
 	YY_BREAK
-case 66:
+case 91:
 YY_RULE_SETUP
-#line 262 "scan.l"
+#line 387 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_UNPUT", ! option_sense);
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
+#line 388 "scan.l"
 printstats = option_sense;
 	YY_BREAK
-case 67:
+case 93:
 YY_RULE_SETUP
-#line 263 "scan.l"
+#line 389 "scan.l"
 nowarn = ! option_sense;
 	YY_BREAK
-case 68:
+case 94:
 YY_RULE_SETUP
-#line 264 "scan.l"
-do_yylineno = option_sense;
+#line 390 "scan.l"
+do_yylineno = option_sense; ACTION_M4_IFDEF("M4""_YY_USE_LINENO", option_sense);
 	YY_BREAK
-case 69:
+case 95:
 YY_RULE_SETUP
-#line 265 "scan.l"
+#line 391 "scan.l"
 yymore_really_used = option_sense;
 	YY_BREAK
-case 70:
+case 96:
 YY_RULE_SETUP
-#line 266 "scan.l"
+#line 392 "scan.l"
 do_yywrap = option_sense;
 	YY_BREAK
-case 71:
+case 97:
 YY_RULE_SETUP
-#line 268 "scan.l"
-ACTION_IFDEF("YY_NO_PUSH_STATE", ! option_sense);
+#line 394 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_PUSH_STATE", ! option_sense);
 	YY_BREAK
-case 72:
+case 98:
 YY_RULE_SETUP
-#line 269 "scan.l"
-ACTION_IFDEF("YY_NO_POP_STATE", ! option_sense);
+#line 395 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_POP_STATE", ! option_sense);
 	YY_BREAK
-case 73:
+case 99:
 YY_RULE_SETUP
-#line 270 "scan.l"
-ACTION_IFDEF("YY_NO_TOP_STATE", ! option_sense);
+#line 396 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_TOP_STATE", ! option_sense);
 	YY_BREAK
-case 74:
+case 100:
 YY_RULE_SETUP
-#line 272 "scan.l"
-ACTION_IFDEF("YY_NO_SCAN_BUFFER", ! option_sense);
+#line 398 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SCAN_BUFFER", ! option_sense);
 	YY_BREAK
-case 75:
+case 101:
 YY_RULE_SETUP
-#line 273 "scan.l"
-ACTION_IFDEF("YY_NO_SCAN_BYTES", ! option_sense);
+#line 399 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SCAN_BYTES", ! option_sense);
 	YY_BREAK
-case 76:
+case 102:
 YY_RULE_SETUP
-#line 274 "scan.l"
-ACTION_IFDEF("YY_NO_SCAN_STRING", ! option_sense);
+#line 400 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SCAN_STRING", ! option_sense);
 	YY_BREAK
-case 77:
+case 103:
 YY_RULE_SETUP
-#line 276 "scan.l"
+#line 402 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_FLEX_ALLOC", ! option_sense);
+	YY_BREAK
+case 104:
+YY_RULE_SETUP
+#line 403 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_FLEX_REALLOC", ! option_sense);
+	YY_BREAK
+case 105:
+YY_RULE_SETUP
+#line 404 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_FLEX_FREE", ! option_sense);
+	YY_BREAK
+case 106:
+YY_RULE_SETUP
+#line 406 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_DEBUG", ! option_sense);
+	YY_BREAK
+case 107:
+YY_RULE_SETUP
+#line 407 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_DEBUG", ! option_sense);
+	YY_BREAK
+case 108:
+YY_RULE_SETUP
+#line 408 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_EXTRA", ! option_sense);
+	YY_BREAK
+case 109:
+YY_RULE_SETUP
+#line 409 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_EXTRA", ! option_sense);
+	YY_BREAK
+case 110:
+YY_RULE_SETUP
+#line 410 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_LENG", ! option_sense);
+	YY_BREAK
+case 111:
+YY_RULE_SETUP
+#line 411 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_TEXT", ! option_sense);
+	YY_BREAK
+case 112:
+YY_RULE_SETUP
+#line 412 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_LINENO", ! option_sense);
+	YY_BREAK
+case 113:
+YY_RULE_SETUP
+#line 413 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_LINENO", ! option_sense);
+	YY_BREAK
+case 114:
+YY_RULE_SETUP
+#line 414 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_IN", ! option_sense);
+	YY_BREAK
+case 115:
+YY_RULE_SETUP
+#line 415 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_IN", ! option_sense);
+	YY_BREAK
+case 116:
+YY_RULE_SETUP
+#line 416 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_OUT", ! option_sense);
+	YY_BREAK
+case 117:
+YY_RULE_SETUP
+#line 417 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_OUT", ! option_sense);
+	YY_BREAK
+case 118:
+YY_RULE_SETUP
+#line 418 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_LVAL", ! option_sense);
+	YY_BREAK
+case 119:
+YY_RULE_SETUP
+#line 419 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_LVAL", ! option_sense);
+	YY_BREAK
+case 120:
+YY_RULE_SETUP
+#line 420 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_GET_LLOC", ! option_sense);
+	YY_BREAK
+case 121:
+YY_RULE_SETUP
+#line 421 "scan.l"
+ACTION_M4_IFDEF("M4""_YY_NO_SET_LLOC", ! option_sense);
+	YY_BREAK
+case 122:
+YY_RULE_SETUP
+#line 423 "scan.l"
+return OPT_EXTRA_TYPE;
+	YY_BREAK
+case 123:
+YY_RULE_SETUP
+#line 424 "scan.l"
 return OPT_OUTFILE;
 	YY_BREAK
-case 78:
+case 124:
 YY_RULE_SETUP
-#line 277 "scan.l"
+#line 425 "scan.l"
 return OPT_PREFIX;
 	YY_BREAK
-case 79:
+case 125:
 YY_RULE_SETUP
-#line 278 "scan.l"
+#line 426 "scan.l"
 return OPT_YYCLASS;
 	YY_BREAK
-case 80:
+case 126:
+YY_RULE_SETUP
+#line 427 "scan.l"
+return OPT_HEADER;
+	YY_BREAK
+case 127:
+YY_RULE_SETUP
+#line 428 "scan.l"
+return OPT_TABLES;
+	YY_BREAK
+case 128:
+YY_RULE_SETUP
+#line 429 "scan.l"
+{
+                    tablesverify = option_sense;
+                    if(!tablesext && option_sense)
+                        tablesext = true;
+                    }
+	YY_BREAK
+case 129:
 YY_RULE_SETUP
-#line 280 "scan.l"
+#line 436 "scan.l"
 {
+			if(yyleng-1 < MAXLINE)
+        		 {
 			strcpy( nmstr, yytext + 1 );
+			 }
+			else
+			 {
+			   synerr( _("Option line too long\n"));
+			   FLEX_EXIT(EXIT_FAILURE);
+			 }
 			nmstr[strlen( nmstr ) - 1] = '\0';
 			return NAME;
 			}
 	YY_BREAK
-case 81:
+case 130:
 YY_RULE_SETUP
-#line 286 "scan.l"
+#line 450 "scan.l"
 {
 			format_synerr( _( "unrecognized %%option: %s" ),
 				yytext );
@@ -2068,30 +3130,31 @@ YY_RULE_SETUP
 			}
 	YY_BREAK
 
-case 82:
+case 131:
+/* rule 131 can match eol */
 YY_RULE_SETUP
-#line 293 "scan.l"
+#line 457 "scan.l"
 ++linenum; BEGIN(INITIAL);
 	YY_BREAK
 
-case 83:
+case 132:
 YY_RULE_SETUP
-#line 297 "scan.l"
+#line 461 "scan.l"
 ++bracelevel; yyless( 2 );	/* eat only %{ */
 	YY_BREAK
-case 84:
+case 133:
 YY_RULE_SETUP
-#line 298 "scan.l"
+#line 462 "scan.l"
 --bracelevel; yyless( 2 );	/* eat only %} */
 	YY_BREAK
-case 85:
+case 134:
 YY_RULE_SETUP
-#line 300 "scan.l"
+#line 464 "scan.l"
 ACTION_ECHO;	/* indented code in prolog */
 	YY_BREAK
-case 86:
+case 135:
 YY_RULE_SETUP
-#line 302 "scan.l"
+#line 466 "scan.l"
 {	/* non-indented code */
 			if ( bracelevel <= 0 )
 				{ /* not in %{ ... %} */
@@ -2104,18 +3167,19 @@ YY_RULE_SETUP
 				ACTION_ECHO;
 			}
 	YY_BREAK
-case 87:
+case 136:
 YY_RULE_SETUP
-#line 314 "scan.l"
+#line 478 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 88:
+case 137:
+/* rule 137 can match eol */
 YY_RULE_SETUP
-#line 315 "scan.l"
+#line 479 "scan.l"
 ++linenum; ACTION_ECHO;
 	YY_BREAK
 case YY_STATE_EOF(SECT2PROLOG):
-#line 317 "scan.l"
+#line 481 "scan.l"
 {
 			mark_prolog();
 			sectnum = 0;
@@ -2124,14 +3188,15 @@ case YY_STATE_EOF(SECT2PROLOG):
 	YY_BREAK
 
 
-case 89:
+case 138:
+/* rule 138 can match eol */
 YY_RULE_SETUP
-#line 325 "scan.l"
+#line 489 "scan.l"
 ++linenum; /* allow blank lines in section 2 */
 	YY_BREAK
-case 90:
+case 139:
 YY_RULE_SETUP
-#line 327 "scan.l"
+#line 491 "scan.l"
 {
 			indented_code = false;
 			doing_codeblock = true;
@@ -2139,40 +3204,52 @@ YY_RULE_SETUP
 			BEGIN(PERCENT_BRACE_ACTION);
 			}
 	YY_BREAK
-case 91:
+case 140:
 YY_RULE_SETUP
-#line 334 "scan.l"
-BEGIN(SC); return '<';
+#line 498 "scan.l"
+{
+                        /* Allow "<" to appear in (?x) patterns. */
+                        if (!sf_skip_ws())
+                            BEGIN(SC);
+                        return '<';
+                    }
 	YY_BREAK
-case 92:
+case 141:
 YY_RULE_SETUP
-#line 335 "scan.l"
+#line 504 "scan.l"
 return '^';
 	YY_BREAK
-case 93:
+case 142:
 YY_RULE_SETUP
-#line 336 "scan.l"
+#line 505 "scan.l"
 BEGIN(QUOTE); return '"';
 	YY_BREAK
-case 94:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp = yy_bp + 1;
+case 143:
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
+(yy_c_buf_p) = yy_cp = yy_bp + 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 337 "scan.l"
-BEGIN(NUM); return '{';
+#line 506 "scan.l"
+{
+			BEGIN(NUM);
+			if ( lex_compat || posix_compat )
+				return BEGIN_REPEAT_POSIX;
+			else
+				return BEGIN_REPEAT_FLEX;
+			}
 	YY_BREAK
-case 95:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp = yy_bp + 1;
+case 144:
+/* rule 144 can match eol */
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
+(yy_c_buf_p) = yy_cp = yy_bp + 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 338 "scan.l"
+#line 513 "scan.l"
 return '$';
 	YY_BREAK
-case 96:
+case 145:
 YY_RULE_SETUP
-#line 340 "scan.l"
+#line 515 "scan.l"
 {
 			bracelevel = 1;
 			BEGIN(PERCENT_BRACE_ACTION);
@@ -2185,91 +3262,138 @@ YY_RULE_SETUP
 				}
 			}
 	YY_BREAK
-case 97:
+case 146:
+/* rule 146 can match eol */
 YY_RULE_SETUP
-#line 351 "scan.l"
-continued_action = true; ++linenum; return '\n';
+#line 526 "scan.l"
+{
+                        if (sf_skip_ws()){
+                            /* We're in the middle of a (?x: ) pattern. */
+                            /* Push back everything starting at the "|" */
+                            size_t amt;
+                            amt = strchr (yytext, '|') - yytext;
+                            yyless(amt);
+                        }
+                        else {
+                            continued_action = true;
+                            ++linenum;
+                            return '\n';
+                        }
+                    }
 	YY_BREAK
-case 98:
+case 147:
 YY_RULE_SETUP
-#line 353 "scan.l"
+#line 541 "scan.l"
 {
-			yyless( yyleng - 2 );	/* put back '/', '*' */
-			bracelevel = 0;
-			continued_action = false;
-			BEGIN(ACTION);
+
+                if (sf_skip_ws()){
+                    /* We're in the middle of a (?x: ) pattern. */
+                    yy_push_state(COMMENT_DISCARD);
+                }
+                else{
+                    yyless( yyleng - 2 );	/* put back '/', '*' */
+                    bracelevel = 0;
+                    continued_action = false;
+                    BEGIN(ACTION);
+                }
 			}
 	YY_BREAK
-case 99:
+case 148:
 YY_RULE_SETUP
-#line 360 "scan.l"
-/* allow indented rules */
+#line 555 "scan.l"
+/* allow indented rules */ ;
 	YY_BREAK
-case 100:
+case 149:
 YY_RULE_SETUP
-#line 362 "scan.l"
+#line 557 "scan.l"
 {
-			/* This rule is separate from the one below because
-			 * otherwise we get variable trailing context, so
-			 * we can't build the scanner using -{f,F}.
-			 */
-			bracelevel = 0;
-			continued_action = false;
-			BEGIN(ACTION);
-
-			if ( in_rule )
-				{
-				doing_rule_action = true;
-				in_rule = false;
-				return '\n';
-				}
+            if (sf_skip_ws()){
+                /* We're in the middle of a (?x: ) pattern. */
+            }
+            else{
+                /* This rule is separate from the one below because
+                 * otherwise we get variable trailing context, so
+                 * we can't build the scanner using -{f,F}.
+                 */
+                bracelevel = 0;
+                continued_action = false;
+                BEGIN(ACTION);
+
+                if ( in_rule )
+                    {
+                    doing_rule_action = true;
+                    in_rule = false;
+                    return '\n';
+                    }
+            }
 			}
 	YY_BREAK
-case 101:
+case 150:
+/* rule 150 can match eol */
 YY_RULE_SETUP
-#line 379 "scan.l"
+#line 579 "scan.l"
 {
-			bracelevel = 0;
-			continued_action = false;
-			BEGIN(ACTION);
-			unput( '\n' );	/* so <ACTION> sees it */
-
-			if ( in_rule )
-				{
-				doing_rule_action = true;
-				in_rule = false;
-				return '\n';
-				}
+            if (sf_skip_ws()){
+                /* We're in the middle of a (?x: ) pattern. */
+                ++linenum;
+            }
+            else{
+                bracelevel = 0;
+                continued_action = false;
+                BEGIN(ACTION);
+                unput( '\n' );	/* so <ACTION> sees it */
+
+                if ( in_rule )
+                    {
+                    doing_rule_action = true;
+                    in_rule = false;
+                    return '\n';
+                    }
+            }
 			}
 	YY_BREAK
-case 102:
-#line 394 "scan.l"
-case 103:
+case 151:
+#line 600 "scan.l"
+case 152:
 YY_RULE_SETUP
-#line 394 "scan.l"
+#line 600 "scan.l"
 return EOF_OP;
 	YY_BREAK
-case 104:
+case 153:
 YY_RULE_SETUP
-#line 396 "scan.l"
+#line 602 "scan.l"
 {
 			sectnum = 3;
 			BEGIN(SECT3);
+			outn("/* Begin user sect3 */");
 			yyterminate(); /* to stop the parser */
 			}
 	YY_BREAK
-case 105:
+case 154:
 YY_RULE_SETUP
-#line 402 "scan.l"
+#line 609 "scan.l"
 {
 			int cclval;
 
+			if(yyleng < MAXLINE)
+        		 {
 			strcpy( nmstr, yytext );
+			 }
+			else
+			 {
+			   synerr( _("Input line too long\n"));
+			   FLEX_EXIT(EXIT_FAILURE);
+			 }
 
 			/* Check to see if we've already encountered this
 			 * ccl.
 			 */
-			if ( (cclval = ccllookup( (Char *) nmstr )) != 0 )
+			if (0 /* <--- This "0" effectively disables the reuse of a
+                   * character class (purely based on its source text).
+                   * The reason it was disabled is so yacc/bison can parse
+                   * ccl operations, such as ccl difference and union.
+                   */
+                &&  (cclval = ccllookup( (Char *) nmstr )) != 0 )
 				{
 				if ( input() != ']' )
 					synerr( _( "bad character class" ) );
@@ -2295,15 +3419,41 @@ YY_RULE_SETUP
 				}
 			}
 	YY_BREAK
-case 106:
+case 155:
 YY_RULE_SETUP
-#line 436 "scan.l"
+#line 655 "scan.l"
+return CCL_OP_DIFF;
+	YY_BREAK
+case 156:
+YY_RULE_SETUP
+#line 656 "scan.l"
+return CCL_OP_UNION;
+	YY_BREAK
+/* Check for :space: at the end of the rule so we don't
+     * wrap the expanded regex in '(' ')' -- breaking trailing
+     * context.
+     */
+case 157:
+/* rule 157 can match eol */
+YY_RULE_SETUP
+#line 663 "scan.l"
 {
 			Char *nmdefptr;
-			Char *ndlookup();
+            int end_is_ws, end_ch;
+
+            end_ch = yytext[yyleng-1];
+            end_is_ws = end_ch != '}' ? 1 : 0;
 
+ 			if(yyleng-1 < MAXLINE)
+         		 {
 			strcpy( nmstr, yytext + 1 );
-			nmstr[yyleng - 2] = '\0';  /* chop trailing brace */
+ 			 }
+ 			else
+ 			 {
+ 			   synerr( _("Input line too long\n"));
+ 			   FLEX_EXIT(EXIT_FAILURE);
+ 			 }
+nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
 
 			if ( (nmdefptr = ndlookup( nmstr )) == 0 )
 				format_synerr(
@@ -2313,9 +3463,12 @@ YY_RULE_SETUP
 			else
 				{ /* push back name surrounded by ()'s */
 				int len = strlen( (char *) nmdefptr );
+                if (end_is_ws)
+                    unput(end_ch);
 
 				if ( lex_compat || nmdefptr[0] == '^' ||
-				     (len > 0 && nmdefptr[len - 1] == '$') )
+				     (len > 0 && nmdefptr[len - 1] == '$')
+                     || (end_is_ws && trlcontxt && !sf_skip_ws()))
 					{ /* don't use ()'s after all */
 					PUT_BACK_STRING((char *) nmdefptr, 0);
 
@@ -2332,69 +3485,126 @@ YY_RULE_SETUP
 				}
 			}
 	YY_BREAK
-case 107:
+case 158:
+YY_RULE_SETUP
+#line 711 "scan.l"
+{
+                    if (sf_skip_ws())
+                        yy_push_state(COMMENT_DISCARD);
+                    else{
+                        /* Push back the "*" and return "/" as usual. */
+                        yyless(1);
+                        return '/';
+                    }
+                }
+	YY_BREAK
+case 159:
 YY_RULE_SETUP
-#line 470 "scan.l"
+#line 721 "scan.l"
+{
+                    if (lex_compat || posix_compat){
+                        /* Push back the "?#" and treat it like a normal parens. */
+                        yyless(1);
+                        sf_push(); 
+                        return '(';
+                    }
+                    else
+                        yy_push_state(EXTENDED_COMMENT);
+                }
+	YY_BREAK
+case 160:
+YY_RULE_SETUP
+#line 731 "scan.l"
+{
+                    sf_push();
+                    if (lex_compat || posix_compat)
+                        /* Push back the "?" and treat it like a normal parens. */
+                        yyless(1);
+                    else
+                        BEGIN(GROUP_WITH_PARAMS);
+                    return '(';
+                }
+	YY_BREAK
+case 161:
+YY_RULE_SETUP
+#line 740 "scan.l"
+sf_push(); return '(';
+	YY_BREAK
+case 162:
+YY_RULE_SETUP
+#line 741 "scan.l"
+sf_pop(); return ')';
+	YY_BREAK
+case 163:
+YY_RULE_SETUP
+#line 743 "scan.l"
 return (unsigned char) yytext[0];
 	YY_BREAK
-case 108:
+case 164:
 YY_RULE_SETUP
-#line 471 "scan.l"
+#line 744 "scan.l"
 RETURNCHAR;
 	YY_BREAK
 
 
-case 109:
+case 165:
+/* rule 165 can match eol */
+YY_RULE_SETUP
+#line 749 "scan.l"
+++linenum;	/* Allow blank lines & continuations */
+	YY_BREAK
+case 166:
 YY_RULE_SETUP
-#line 476 "scan.l"
+#line 750 "scan.l"
 return (unsigned char) yytext[0];
 	YY_BREAK
-case 110:
+case 167:
 YY_RULE_SETUP
-#line 477 "scan.l"
+#line 751 "scan.l"
 BEGIN(SECT2); return '>';
 	YY_BREAK
-case 111:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp = yy_bp + 1;
+case 168:
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
+(yy_c_buf_p) = yy_cp = yy_bp + 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 478 "scan.l"
+#line 752 "scan.l"
 BEGIN(CARETISBOL); return '>';
 	YY_BREAK
-case 112:
+case 169:
 YY_RULE_SETUP
-#line 479 "scan.l"
+#line 753 "scan.l"
 RETURNNAME;
 	YY_BREAK
-case 113:
+case 170:
 YY_RULE_SETUP
-#line 480 "scan.l"
+#line 754 "scan.l"
 {
 			format_synerr( _( "bad <start condition>: %s" ),
 				yytext );
 			}
 	YY_BREAK
 
-case 114:
+case 171:
 YY_RULE_SETUP
-#line 486 "scan.l"
+#line 760 "scan.l"
 BEGIN(SECT2); return '^';
 	YY_BREAK
 
-case 115:
+case 172:
 YY_RULE_SETUP
-#line 490 "scan.l"
+#line 764 "scan.l"
 RETURNCHAR;
 	YY_BREAK
-case 116:
+case 173:
 YY_RULE_SETUP
-#line 491 "scan.l"
+#line 765 "scan.l"
 BEGIN(SECT2); return '"';
 	YY_BREAK
-case 117:
+case 174:
+/* rule 174 can match eol */
 YY_RULE_SETUP
-#line 493 "scan.l"
+#line 767 "scan.l"
 {
 			synerr( _( "missing quote" ) );
 			BEGIN(SECT2);
@@ -2404,50 +3614,100 @@ YY_RULE_SETUP
 	YY_BREAK
 
 
-case 118:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp = yy_bp + 1;
+case 175:
+YY_RULE_SETUP
+#line 776 "scan.l"
+BEGIN(SECT2);
+	YY_BREAK
+case 176:
+YY_RULE_SETUP
+#line 777 "scan.l"
+BEGIN(GROUP_MINUS_PARAMS);
+	YY_BREAK
+case 177:
+YY_RULE_SETUP
+#line 778 "scan.l"
+sf_set_case_ins(1);
+	YY_BREAK
+case 178:
+YY_RULE_SETUP
+#line 779 "scan.l"
+sf_set_dot_all(1);
+	YY_BREAK
+case 179:
+YY_RULE_SETUP
+#line 780 "scan.l"
+sf_set_skip_ws(1);
+	YY_BREAK
+
+
+case 180:
+YY_RULE_SETUP
+#line 783 "scan.l"
+BEGIN(SECT2);
+	YY_BREAK
+case 181:
+YY_RULE_SETUP
+#line 784 "scan.l"
+sf_set_case_ins(0);
+	YY_BREAK
+case 182:
+YY_RULE_SETUP
+#line 785 "scan.l"
+sf_set_dot_all(0);
+	YY_BREAK
+case 183:
+YY_RULE_SETUP
+#line 786 "scan.l"
+sf_set_skip_ws(0);
+	YY_BREAK
+
+
+case 184:
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
+(yy_c_buf_p) = yy_cp = yy_bp + 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 503 "scan.l"
+#line 790 "scan.l"
 BEGIN(CCL); return '^';
 	YY_BREAK
-case 119:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp = yy_bp + 1;
+case 185:
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
+(yy_c_buf_p) = yy_cp = yy_bp + 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 504 "scan.l"
+#line 791 "scan.l"
 return '^';
 	YY_BREAK
-case 120:
+case 186:
 YY_RULE_SETUP
-#line 505 "scan.l"
+#line 792 "scan.l"
 BEGIN(CCL); RETURNCHAR;
 	YY_BREAK
 
 
-case 121:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp = yy_bp + 1;
+case 187:
+*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
+(yy_c_buf_p) = yy_cp = yy_bp + 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 509 "scan.l"
+#line 796 "scan.l"
 return '-';
 	YY_BREAK
-case 122:
+case 188:
 YY_RULE_SETUP
-#line 510 "scan.l"
+#line 797 "scan.l"
 RETURNCHAR;
 	YY_BREAK
-case 123:
+case 189:
 YY_RULE_SETUP
-#line 511 "scan.l"
+#line 798 "scan.l"
 BEGIN(SECT2); return ']';
 	YY_BREAK
-case 124:
+case 190:
+/* rule 190 can match eol */
 YY_RULE_SETUP
-#line 512 "scan.l"
+#line 799 "scan.l"
 {
 			synerr( _( "bad character class" ) );
 			BEGIN(SECT2);
@@ -2456,69 +3716,129 @@ YY_RULE_SETUP
 	YY_BREAK
 
 
-case 125:
+case 191:
 YY_RULE_SETUP
-#line 520 "scan.l"
+#line 807 "scan.l"
 BEGIN(CCL); return CCE_ALNUM;
 	YY_BREAK
-case 126:
+case 192:
 YY_RULE_SETUP
-#line 521 "scan.l"
+#line 808 "scan.l"
 BEGIN(CCL); return CCE_ALPHA;
 	YY_BREAK
-case 127:
+case 193:
 YY_RULE_SETUP
-#line 522 "scan.l"
+#line 809 "scan.l"
 BEGIN(CCL); return CCE_BLANK;
 	YY_BREAK
-case 128:
+case 194:
 YY_RULE_SETUP
-#line 523 "scan.l"
+#line 810 "scan.l"
 BEGIN(CCL); return CCE_CNTRL;
 	YY_BREAK
-case 129:
+case 195:
 YY_RULE_SETUP
-#line 524 "scan.l"
+#line 811 "scan.l"
 BEGIN(CCL); return CCE_DIGIT;
 	YY_BREAK
-case 130:
+case 196:
 YY_RULE_SETUP
-#line 525 "scan.l"
+#line 812 "scan.l"
 BEGIN(CCL); return CCE_GRAPH;
 	YY_BREAK
-case 131:
+case 197:
 YY_RULE_SETUP
-#line 526 "scan.l"
+#line 813 "scan.l"
 BEGIN(CCL); return CCE_LOWER;
 	YY_BREAK
-case 132:
+case 198:
 YY_RULE_SETUP
-#line 527 "scan.l"
+#line 814 "scan.l"
 BEGIN(CCL); return CCE_PRINT;
 	YY_BREAK
-case 133:
+case 199:
 YY_RULE_SETUP
-#line 528 "scan.l"
+#line 815 "scan.l"
 BEGIN(CCL); return CCE_PUNCT;
 	YY_BREAK
-case 134:
+case 200:
 YY_RULE_SETUP
-#line 529 "scan.l"
+#line 816 "scan.l"
 BEGIN(CCL); return CCE_SPACE;
 	YY_BREAK
-case 135:
+case 201:
 YY_RULE_SETUP
-#line 530 "scan.l"
+#line 817 "scan.l"
 BEGIN(CCL); return CCE_UPPER;
 	YY_BREAK
-case 136:
+case 202:
 YY_RULE_SETUP
-#line 531 "scan.l"
+#line 818 "scan.l"
 BEGIN(CCL); return CCE_XDIGIT;
 	YY_BREAK
-case 137:
+case 203:
+YY_RULE_SETUP
+#line 820 "scan.l"
+BEGIN(CCL); return CCE_NEG_ALNUM;
+	YY_BREAK
+case 204:
+YY_RULE_SETUP
+#line 821 "scan.l"
+BEGIN(CCL); return CCE_NEG_ALPHA;
+	YY_BREAK
+case 205:
+YY_RULE_SETUP
+#line 822 "scan.l"
+BEGIN(CCL); return CCE_NEG_BLANK;
+	YY_BREAK
+case 206:
+YY_RULE_SETUP
+#line 823 "scan.l"
+BEGIN(CCL); return CCE_NEG_CNTRL;
+	YY_BREAK
+case 207:
+YY_RULE_SETUP
+#line 824 "scan.l"
+BEGIN(CCL); return CCE_NEG_DIGIT;
+	YY_BREAK
+case 208:
+YY_RULE_SETUP
+#line 825 "scan.l"
+BEGIN(CCL); return CCE_NEG_GRAPH;
+	YY_BREAK
+case 209:
+YY_RULE_SETUP
+#line 826 "scan.l"
+BEGIN(CCL); return CCE_NEG_LOWER;
+	YY_BREAK
+case 210:
+YY_RULE_SETUP
+#line 827 "scan.l"
+BEGIN(CCL); return CCE_NEG_PRINT;
+	YY_BREAK
+case 211:
+YY_RULE_SETUP
+#line 828 "scan.l"
+BEGIN(CCL); return CCE_NEG_PUNCT;
+	YY_BREAK
+case 212:
+YY_RULE_SETUP
+#line 829 "scan.l"
+BEGIN(CCL); return CCE_NEG_SPACE;
+	YY_BREAK
+case 213:
+YY_RULE_SETUP
+#line 830 "scan.l"
+BEGIN(CCL); return CCE_NEG_UPPER;
+	YY_BREAK
+case 214:
+YY_RULE_SETUP
+#line 831 "scan.l"
+BEGIN(CCL); return CCE_NEG_XDIGIT;
+	YY_BREAK
+case 215:
 YY_RULE_SETUP
-#line 532 "scan.l"
+#line 832 "scan.l"
 {
 			format_synerr(
 				_( "bad character class expression: %s" ),
@@ -2528,36 +3848,43 @@ YY_RULE_SETUP
 	YY_BREAK
 
 
-case 138:
+case 216:
 YY_RULE_SETUP
-#line 541 "scan.l"
+#line 841 "scan.l"
 {
 			yylval = myctoi( yytext );
 			return NUMBER;
 			}
 	YY_BREAK
-case 139:
+case 217:
 YY_RULE_SETUP
-#line 546 "scan.l"
+#line 846 "scan.l"
 return ',';
 	YY_BREAK
-case 140:
+case 218:
 YY_RULE_SETUP
-#line 547 "scan.l"
-BEGIN(SECT2); return '}';
+#line 847 "scan.l"
+{
+			BEGIN(SECT2);
+			if ( lex_compat || posix_compat )
+				return END_REPEAT_POSIX;
+			else
+				return END_REPEAT_FLEX;
+			}
 	YY_BREAK
-case 141:
+case 219:
 YY_RULE_SETUP
-#line 549 "scan.l"
+#line 855 "scan.l"
 {
 			synerr( _( "bad character inside {}'s" ) );
 			BEGIN(SECT2);
 			return '}';
 			}
 	YY_BREAK
-case 142:
+case 220:
+/* rule 220 can match eol */
 YY_RULE_SETUP
-#line 555 "scan.l"
+#line 861 "scan.l"
 {
 			synerr( _( "missing }" ) );
 			BEGIN(SECT2);
@@ -2567,42 +3894,53 @@ YY_RULE_SETUP
 	YY_BREAK
 
 
-case 143:
+case 221:
 YY_RULE_SETUP
-#line 565 "scan.l"
+#line 871 "scan.l"
 bracelevel = 0;
 	YY_BREAK
-case 144:
+case 222:
 YY_RULE_SETUP
-#line 567 "scan.l"
+#line 873 "scan.l"
 ACTION_ECHO; yy_push_state( COMMENT );
 	YY_BREAK
 
-case 145:
+case 223:
 YY_RULE_SETUP
-#line 570 "scan.l"
+#line 876 "scan.l"
 {
 			ACTION_ECHO;
 			CHECK_REJECT(yytext);
 			}
 	YY_BREAK
-case 146:
+case 224:
 YY_RULE_SETUP
-#line 574 "scan.l"
+#line 880 "scan.l"
 {
 			ACTION_ECHO;
 			CHECK_YYMORE(yytext);
 			}
 	YY_BREAK
 
-case 147:
+case 225:
+YY_RULE_SETUP
+#line 886 "scan.l"
+ACTION_ECHO_QSTART;
+	YY_BREAK
+case 226:
 YY_RULE_SETUP
-#line 580 "scan.l"
+#line 887 "scan.l"
+ACTION_ECHO_QEND;
+	YY_BREAK
+case 227:
+YY_RULE_SETUP
+#line 888 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 148:
+case 228:
+/* rule 228 can match eol */
 YY_RULE_SETUP
-#line 581 "scan.l"
+#line 889 "scan.l"
 {
 			++linenum;
 			ACTION_ECHO;
@@ -2620,39 +3958,55 @@ YY_RULE_SETUP
 
 /* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
 
-case 149:
+case 229:
 YY_RULE_SETUP
-#line 599 "scan.l"
+#line 907 "scan.l"
 ACTION_ECHO; ++bracelevel;
 	YY_BREAK
-case 150:
+case 230:
 YY_RULE_SETUP
-#line 600 "scan.l"
+#line 908 "scan.l"
 ACTION_ECHO; --bracelevel;
 	YY_BREAK
-case 151:
+case 231:
+YY_RULE_SETUP
+#line 909 "scan.l"
+ACTION_ECHO_QSTART;
+	YY_BREAK
+case 232:
 YY_RULE_SETUP
-#line 601 "scan.l"
+#line 910 "scan.l"
+ACTION_ECHO_QEND;
+	YY_BREAK
+case 233:
+YY_RULE_SETUP
+#line 911 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 152:
+case 234:
 YY_RULE_SETUP
-#line 602 "scan.l"
+#line 912 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 153:
+case 235:
 YY_RULE_SETUP
-#line 603 "scan.l"
+#line 913 "scan.l"
+ACTION_ECHO;
+	YY_BREAK
+case 236:
+YY_RULE_SETUP
+#line 914 "scan.l"
 ACTION_ECHO; /* character constant */
 	YY_BREAK
-case 154:
+case 237:
 YY_RULE_SETUP
-#line 604 "scan.l"
+#line 915 "scan.l"
 ACTION_ECHO; BEGIN(ACTION_STRING);
 	YY_BREAK
-case 155:
+case 238:
+/* rule 238 can match eol */
 YY_RULE_SETUP
-#line 605 "scan.l"
+#line 916 "scan.l"
 {
 			++linenum;
 			ACTION_ECHO;
@@ -2666,51 +4020,62 @@ YY_RULE_SETUP
 				}
 			}
 	YY_BREAK
-case 156:
+case 239:
 YY_RULE_SETUP
-#line 617 "scan.l"
+#line 928 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
 
 
-case 157:
+case 240:
 YY_RULE_SETUP
-#line 621 "scan.l"
+#line 932 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 158:
+case 241:
 YY_RULE_SETUP
-#line 622 "scan.l"
+#line 933 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
-case 159:
+case 242:
+/* rule 242 can match eol */
 YY_RULE_SETUP
-#line 623 "scan.l"
-++linenum; ACTION_ECHO;
+#line 934 "scan.l"
+++linenum; ACTION_ECHO; BEGIN(ACTION);
 	YY_BREAK
-case 160:
+case 243:
 YY_RULE_SETUP
-#line 624 "scan.l"
+#line 935 "scan.l"
 ACTION_ECHO; BEGIN(ACTION);
 	YY_BREAK
-case 161:
+case 244:
 YY_RULE_SETUP
-#line 625 "scan.l"
+#line 936 "scan.l"
 ACTION_ECHO;
 	YY_BREAK
 
 case YY_STATE_EOF(COMMENT):
+case YY_STATE_EOF(COMMENT_DISCARD):
 case YY_STATE_EOF(ACTION):
 case YY_STATE_EOF(ACTION_STRING):
-#line 628 "scan.l"
+#line 939 "scan.l"
 {
 			synerr( _( "EOF encountered inside an action" ) );
 			yyterminate();
 			}
 	YY_BREAK
-case 162:
+case YY_STATE_EOF(EXTENDED_COMMENT):
+case YY_STATE_EOF(GROUP_WITH_PARAMS):
+case YY_STATE_EOF(GROUP_MINUS_PARAMS):
+#line 944 "scan.l"
+{
+			synerr( _( "EOF encountered inside pattern" ) );
+			yyterminate();
+			}
+	YY_BREAK
+case 245:
 YY_RULE_SETUP
-#line 634 "scan.l"
+#line 949 "scan.l"
 {
 			yylval = myesc( (Char *) yytext );
 
@@ -2721,66 +4086,84 @@ YY_RULE_SETUP
 			}
 	YY_BREAK
 
-case 163:
+case 246:
+YY_RULE_SETUP
+#line 960 "scan.l"
+fwrite (escaped_qstart, 1, strlen(escaped_qstart), yyout);
+	YY_BREAK
+case 247:
+YY_RULE_SETUP
+#line 961 "scan.l"
+fwrite (escaped_qend, 1, strlen(escaped_qend), yyout);
+	YY_BREAK
+case 248:
+/* rule 248 can match eol */
 YY_RULE_SETUP
-#line 645 "scan.l"
+#line 962 "scan.l"
+ECHO;
+	YY_BREAK
+case 249:
+/* rule 249 can match eol */
+YY_RULE_SETUP
+#line 963 "scan.l"
 ECHO;
 	YY_BREAK
 case YY_STATE_EOF(SECT3):
-#line 646 "scan.l"
+#line 964 "scan.l"
 sectnum = 0; yyterminate();
 	YY_BREAK
 
-case 164:
+case 250:
+/* rule 250 can match eol */
 YY_RULE_SETUP
-#line 649 "scan.l"
+#line 967 "scan.l"
 format_synerr( _( "bad character: %s" ), yytext );
 	YY_BREAK
-case 165:
+case 251:
 YY_RULE_SETUP
-#line 651 "scan.l"
+#line 969 "scan.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2745 "scan.c"
-case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(SECT2):
-case YY_STATE_EOF(CODEBLOCK):
-case YY_STATE_EOF(PICKUPDEF):
-case YY_STATE_EOF(SC):
-case YY_STATE_EOF(CARETISBOL):
-case YY_STATE_EOF(NUM):
-case YY_STATE_EOF(QUOTE):
-case YY_STATE_EOF(FIRSTCCL):
-case YY_STATE_EOF(CCL):
-case YY_STATE_EOF(RECOVER):
-case YY_STATE_EOF(PERCENT_BRACE_ACTION):
-case YY_STATE_EOF(OPTION):
-case YY_STATE_EOF(LINEDIR):
-	yyterminate();
+#line 4127 "<stdout>"
+			case YY_STATE_EOF(INITIAL):
+			case YY_STATE_EOF(SECT2):
+			case YY_STATE_EOF(CODEBLOCK):
+			case YY_STATE_EOF(PICKUPDEF):
+			case YY_STATE_EOF(SC):
+			case YY_STATE_EOF(CARETISBOL):
+			case YY_STATE_EOF(NUM):
+			case YY_STATE_EOF(QUOTE):
+			case YY_STATE_EOF(FIRSTCCL):
+			case YY_STATE_EOF(CCL):
+			case YY_STATE_EOF(RECOVER):
+			case YY_STATE_EOF(PERCENT_BRACE_ACTION):
+			case YY_STATE_EOF(OPTION):
+			case YY_STATE_EOF(LINEDIR):
+				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;
+		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_cp = (yy_hold_char);
 		YY_RESTORE_YY_MORE_OFFSET
 
-		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+		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 yyin at a new source and called
 			 * yylex().  If so, then we have to assure
-			 * consistency between yy_current_buffer and our
+			 * 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->yy_n_chars;
-			yy_current_buffer->yy_input_file = yyin;
-			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 			}
 
 		/* Note that here we test for yy_c_buf_p "<=" to the position
@@ -2790,13 +4173,13 @@ case YY_STATE_EOF(LINEDIR):
 		 * end-of-buffer state).  Contrast this with the test
 		 * in input().
 		 */
-		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+		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_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
-			yy_current_state = yy_get_previous_state();
+			yy_current_state = yy_get_previous_state(  );
 
 			/* Okay, we're now positioned to make the NUL
 			 * transition.  We couldn't have
@@ -2809,30 +4192,30 @@ case YY_STATE_EOF(LINEDIR):
 
 			yy_next_state = yy_try_NUL_trans( yy_current_state );
 
-			yy_bp = yytext_ptr + YY_MORE_ADJ;
+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
 			if ( yy_next_state )
 				{
 				/* Consume the NUL. */
-				yy_cp = ++yy_c_buf_p;
+				yy_cp = ++(yy_c_buf_p);
 				yy_current_state = yy_next_state;
 				goto yy_match;
 				}
 
 			else
 				{
-				yy_cp = yy_c_buf_p;
+				yy_cp = (yy_c_buf_p);
 				goto yy_find_action;
 				}
 			}
 
-		else switch ( yy_get_next_buffer() )
+		else switch ( yy_get_next_buffer(  ) )
 			{
 			case EOB_ACT_END_OF_FILE:
 				{
-				yy_did_buffer_switch_on_eof = 0;
+				(yy_did_buffer_switch_on_eof) = 0;
 
-				if ( yywrap() )
+				if ( yywrap( ) )
 					{
 					/* Note: because we've taken care in
 					 * yy_get_next_buffer() to have set up
@@ -2843,7 +4226,7 @@ case YY_STATE_EOF(LINEDIR):
 					 * YY_NULL, it'll still work - another
 					 * YY_NULL will get returned.
 					 */
-					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
 					yy_act = YY_STATE_EOF(YY_START);
 					goto do_action;
@@ -2851,30 +4234,30 @@ case YY_STATE_EOF(LINEDIR):
 
 				else
 					{
-					if ( ! yy_did_buffer_switch_on_eof )
+					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_c_buf_p) =
+					(yytext_ptr) + yy_amount_of_matched_text;
 
-				yy_current_state = yy_get_previous_state();
+				yy_current_state = yy_get_previous_state(  );
 
-				yy_cp = yy_c_buf_p;
-				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				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->yy_ch_buf[yy_n_chars];
+				(yy_c_buf_p) =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
-				yy_current_state = yy_get_previous_state();
+				yy_current_state = yy_get_previous_state(  );
 
-				yy_cp = yy_c_buf_p;
-				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 				goto yy_find_action;
 			}
 		break;
@@ -2885,8 +4268,7 @@ case YY_STATE_EOF(LINEDIR):
 			"fatal flex scanner internal error--no action found" );
 	} /* end of action switch */
 		} /* end of scanning one token */
-	} /* end of yylex */
-
+} /* end of yylex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
@@ -2895,25 +4277,20 @@ case YY_STATE_EOF(LINEDIR):
  *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  *	EOB_ACT_END_OF_FILE - end of file
  */
-
-#ifdef YY_USE_PROTOS
-static int yy_get_next_buffer(void)
-#else
-static int yy_get_next_buffer()
-#endif
-	{
-	char *dest = yy_current_buffer->yy_ch_buf;
-	char *source = yytext_ptr;
+static int yy_get_next_buffer (void)
+{
+    	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = (yytext_ptr);
 	int number_to_move, i;
 	int ret_val;
 
-	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+	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->yy_fill_buffer == 0 )
+	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 )
+		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.
@@ -2933,86 +4310,52 @@ static int yy_get_next_buffer()
 	/* Try to read more data. */
 
 	/* First move last chars to start of buffer. */
-	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+	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->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+	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->yy_n_chars = yy_n_chars = 0;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
 	else
 		{
-		int num_to_read =
-			yy_current_buffer->yy_buf_size - number_to_move - 1;
+			yy_size_t 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. */
-#ifdef YY_USES_REJECT
+
 			YY_FATAL_ERROR(
 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
-
-			/* 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. */
-					yy_flex_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->yy_buf_size -
-						number_to_move - 1;
-#endif
 			}
 
 		if ( num_to_read > YY_READ_BUF_SIZE )
 			num_to_read = YY_READ_BUF_SIZE;
 
 		/* Read in more data. */
-		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-			yy_n_chars, num_to_read );
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			(yy_n_chars), num_to_read );
 
-		yy_current_buffer->yy_n_chars = yy_n_chars;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 		}
 
-	if ( yy_n_chars == 0 )
+	if ( (yy_n_chars) == 0 )
 		{
 		if ( number_to_move == YY_MORE_ADJ )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart( yyin );
+			yyrestart(yyin  );
 			}
 
 		else
 			{
 			ret_val = EOB_ACT_LAST_MATCH;
-			yy_current_buffer->yy_buffer_status =
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
 				YY_BUFFER_EOF_PENDING;
 			}
 		}
@@ -3020,162 +4363,143 @@ static int yy_get_next_buffer()
 	else
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
-	yy_n_chars += number_to_move;
-	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+	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 *) yyrealloc((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()" );
+	}
 
-	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+	(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;
 
-	return ret_val;
-	}
+	(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 */
 
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_get_previous_state(void)
-#else
-static yy_state_type yy_get_previous_state()
-#endif
-	{
+    static yy_state_type yy_get_previous_state (void)
+{
 	yy_state_type yy_current_state;
 	char *yy_cp;
-
-	yy_current_state = yy_start;
+    
+	yy_current_state = (yy_start);
 	yy_current_state += YY_AT_BOL();
 
-	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+	(yy_state_ptr) = (yy_state_buf);
+	*(yy_state_ptr)++ = yy_current_state;
+
+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
 		{
 		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 >= 769 )
+			if ( yy_current_state >= 1107 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		*(yy_state_ptr)++ = yy_current_state;
 		}
 
 	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 );
  */
-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
-#else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
-#endif
-	{
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
 	int yy_is_jam;
-	char *yy_cp = yy_c_buf_p;
-
+    
 	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 >= 769 )
+		if ( yy_current_state >= 1107 )
 			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 == 768);
-
-	return yy_is_jam ? 0 : yy_current_state;
-	}
+	yy_is_jam = (yy_current_state == 1106);
+	if ( ! yy_is_jam )
+		*(yy_state_ptr)++ = yy_current_state;
 
+		return yy_is_jam ? 0 : yy_current_state;
+}
 
 #ifndef YY_NO_UNPUT
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, char *yy_bp )
-#else
-static void yyunput( c, yy_bp )
-int c;
-char *yy_bp;
-#endif
-	{
-	char *yy_cp = yy_c_buf_p;
+    static void yyunput (int c, char * yy_bp )
+{
+	char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
 
 	/* undo effects of setting up yytext */
-	*yy_cp = yy_hold_char;
+	*yy_cp = (yy_hold_char);
 
-	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
-		int number_to_move = yy_n_chars + 2;
-		char *dest = &yy_current_buffer->yy_ch_buf[
-					yy_current_buffer->yy_buf_size + 2];
+		yy_size_t number_to_move = (yy_n_chars) + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
 		char *source =
-				&yy_current_buffer->yy_ch_buf[number_to_move];
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
-		while ( source > yy_current_buffer->yy_ch_buf )
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 			*--dest = *--source;
 
 		yy_cp += (int) (dest - source);
 		yy_bp += (int) (dest - source);
-		yy_current_buffer->yy_n_chars =
-			yy_n_chars = yy_current_buffer->yy_buf_size;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
-		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 			YY_FATAL_ERROR( "flex scanner push-back overflow" );
 		}
 
 	*--yy_cp = (char) c;
 
-
-	yytext_ptr = yy_bp;
-	yy_hold_char = *yy_cp;
-	yy_c_buf_p = yy_cp;
-	}
+	(yytext_ptr) = yy_bp;
+	(yy_hold_char) = *yy_cp;
+	(yy_c_buf_p) = yy_cp;
+}
 #endif	/* ifndef YY_NO_UNPUT */
 
-
 #ifndef YY_NO_INPUT
 #ifdef __cplusplus
-static int yyinput()
+    static int yyinput (void)
 #else
-#ifdef YY_USE_PROTOS
-static int input(void)
-#else
-static int input()
-#endif
+    static int input  (void)
 #endif
-	{
-	int c;
 
-	*yy_c_buf_p = yy_hold_char;
+{
+	int c;
+    
+	*(yy_c_buf_p) = (yy_hold_char);
 
-	if ( *yy_c_buf_p == YY_END_OF_BUFFER_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->yy_ch_buf[yy_n_chars] )
+		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';
+			*(yy_c_buf_p) = '\0';
 
 		else
 			{ /* need more input */
-			int offset = yy_c_buf_p - yytext_ptr;
-			++yy_c_buf_p;
+			yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
+			++(yy_c_buf_p);
 
-			switch ( yy_get_next_buffer() )
+			switch ( yy_get_next_buffer(  ) )
 				{
 				case EOB_ACT_LAST_MATCH:
 					/* This happens because yy_g_n_b()
@@ -3189,16 +4513,16 @@ static int input()
 					 */
 
 					/* Reset buffer status. */
-					yyrestart( yyin );
+					yyrestart(yyin );
 
-					/* fall through */
+					/*FALLTHROUGH*/
 
 				case EOB_ACT_END_OF_FILE:
 					{
-					if ( yywrap() )
+					if ( yywrap( ) )
 						return EOF;
 
-					if ( ! yy_did_buffer_switch_on_eof )
+					if ( ! (yy_did_buffer_switch_on_eof) )
 						YY_NEW_FILE;
 #ifdef __cplusplus
 					return yyinput();
@@ -3208,92 +4532,94 @@ static int input()
 					}
 
 				case EOB_ACT_CONTINUE_SCAN:
-					yy_c_buf_p = yytext_ptr + offset;
+					(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 yytext */
-	yy_hold_char = *++yy_c_buf_p;
+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
+	*(yy_c_buf_p) = '\0';	/* preserve yytext */
+	(yy_hold_char) = *++(yy_c_buf_p);
 
-	yy_current_buffer->yy_at_bol = (c == '\n');
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
 
 	return c;
-	}
+}
 #endif	/* ifndef YY_NO_INPUT */
 
-
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
-#else
-void yyrestart( input_file )
-FILE *input_file;
-#endif
-	{
-	if ( ! yy_current_buffer )
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
-
-	yy_init_buffer( yy_current_buffer, input_file );
-	yy_load_buffer_state();
+/** 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 yyrestart  (FILE * input_file )
+{
+    
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer(yyin,YY_BUF_SIZE );
 	}
 
+	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
+	yy_load_buffer_state( );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-	{
-	if ( yy_current_buffer == new_buffer )
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack ();
+	if ( YY_CURRENT_BUFFER == new_buffer )
 		return;
 
-	if ( yy_current_buffer )
+	if ( YY_CURRENT_BUFFER )
 		{
 		/* Flush out information for old buffer. */
-		*yy_c_buf_p = yy_hold_char;
-		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-		yy_current_buffer->yy_n_chars = yy_n_chars;
+		*(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 = new_buffer;
-	yy_load_buffer_state();
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( );
 
 	/* We don't actually know whether we did this switch during
 	 * EOF (yywrap()) processing, but the only time this flag
 	 * is looked at is after yywrap() is called, so it's safe
 	 * to go ahead and always set it.
 	 */
-	yy_did_buffer_switch_on_eof = 1;
-	}
-
+	(yy_did_buffer_switch_on_eof) = 1;
+}
 
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
-#else
-void yy_load_buffer_state()
-#endif
-	{
-	yy_n_chars = yy_current_buffer->yy_n_chars;
-	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-	yyin = yy_current_buffer->yy_input_file;
-	yy_hold_char = *yy_c_buf_p;
-	}
-
-
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-	{
+static void yy_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;
+	yyin = 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 yy_create_buffer  (FILE * file, int  size )
+{
 	YY_BUFFER_STATE b;
-
-	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    
+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
@@ -3302,80 +4628,71 @@ int 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 *) yy_flex_alloc( b->yy_buf_size + 2 );
+	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
 	if ( ! b->yy_ch_buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
 	b->yy_is_our_buffer = 1;
 
-	yy_init_buffer( b, file );
+	yy_init_buffer(b,file );
 
 	return b;
-	}
-
+}
 
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-	{
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * 
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
 	if ( ! b )
 		return;
 
-	if ( b == yy_current_buffer )
-		yy_current_buffer = (YY_BUFFER_STATE) 0;
+	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 )
-		yy_flex_free( (void *) b->yy_ch_buf );
+		yyfree((void *) b->yy_ch_buf  );
 
-	yy_flex_free( (void *) b );
-	}
-
-
-#ifndef YY_ALWAYS_INTERACTIVE
-#ifndef YY_NEVER_INTERACTIVE
-extern int isatty YY_PROTO(( int ));
-#endif
-#endif
-
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
-#else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
-#endif
+	yyfree((void *) b  );
+}
 
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
-	{
-	yy_flush_buffer( b );
+{
+	int oerrno = errno;
+    
+	yy_flush_buffer(b );
 
 	b->yy_input_file = file;
 	b->yy_fill_buffer = 1;
 
-#if YY_ALWAYS_INTERACTIVE
-	b->yy_is_interactive = 1;
-#else
-#if YY_NEVER_INTERACTIVE
-	b->yy_is_interactive = 0;
-#else
-	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-#endif
-#endif
-	}
-
-
-#ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
-#else
-void yy_flush_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-
-	{
-	if ( ! b )
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() 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 yy_flush_buffer (YY_BUFFER_STATE  b )
+{
+    	if ( ! b )
 		return;
 
 	b->yy_n_chars = 0;
@@ -3392,29 +4709,125 @@ YY_BUFFER_STATE b;
 	b->yy_at_bol = 1;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
-	if ( b == yy_current_buffer )
-		yy_load_buffer_state();
+	if ( b == YY_CURRENT_BUFFER )
+		yy_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 yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+    	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack();
+
+	/* This block is copied from yy_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 yy_switch_to_buffer. */
+	yy_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 yypop_buffer_state (void)
+{
+    	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER );
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if ((yy_buffer_stack_top) > 0)
+		--(yy_buffer_stack_top);
+
+	if (YY_CURRENT_BUFFER) {
+		yy_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 yyensure_buffer_stack (void)
+{
+	yy_size_t 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**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_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;
+	}
 
-#ifndef YY_NO_SCAN_BUFFER
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-#else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
-char *base;
-yy_size_t size;
-#endif
-	{
-	YY_BUFFER_STATE b;
+	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**)yyrealloc
+								((yy_buffer_stack),
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_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 yy_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) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
@@ -3428,56 +4841,51 @@ yy_size_t size;
 	b->yy_fill_buffer = 0;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
-	yy_switch_to_buffer( b );
+	yy_switch_to_buffer(b  );
 
 	return b;
-	}
-#endif
-
-
-#ifndef YY_NO_SCAN_STRING
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
-#else
-YY_BUFFER_STATE yy_scan_string( yy_str )
-yyconst char *yy_str;
-#endif
-	{
-	int len;
-	for ( len = 0; yy_str[len]; ++len )
-		;
-
-	return yy_scan_bytes( yy_str, len );
-	}
-#endif
+}
 
-
-#ifndef YY_NO_SCAN_BYTES
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
-#else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
-yyconst char *bytes;
-int len;
-#endif
-	{
+/** Setup the input buffer state to scan a string. The next call to yylex() 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
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
+{
+    
+	return yy_scan_bytes(yystr,strlen(yystr) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() 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 yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
+{
 	YY_BUFFER_STATE b;
 	char *buf;
 	yy_size_t n;
-	int i;
-
+	yy_size_t i;
+    
 	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = len + 2;
-	buf = (char *) yy_flex_alloc( n );
+	n = _yybytes_len + 2;
+	buf = (char *) yyalloc(n  );
 	if ( ! buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
-	for ( i = 0; i < len; ++i )
-		buf[i] = bytes[i];
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
 
-	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-	b = yy_scan_buffer( buf, n );
+	b = yy_scan_buffer(buf,n );
 	if ( ! b )
 		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -3487,86 +4895,49 @@ int len;
 	b->yy_is_our_buffer = 1;
 
 	return b;
-	}
-#endif
+}
 
-
-#ifndef YY_NO_PUSH_STATE
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
-#else
-static void yy_push_state( new_state )
-int new_state;
-#endif
-	{
-	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+    static void yy_push_state (int  new_state )
+{
+    	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
 		{
 		yy_size_t new_size;
 
-		yy_start_stack_depth += YY_START_STACK_INCR;
-		new_size = yy_start_stack_depth * sizeof( int );
+		(yy_start_stack_depth) += YY_START_STACK_INCR;
+		new_size = (yy_start_stack_depth) * sizeof( int );
 
-		if ( ! yy_start_stack )
-			yy_start_stack = (int *) yy_flex_alloc( new_size );
+		if ( ! (yy_start_stack) )
+			(yy_start_stack) = (int *) yyalloc(new_size  );
 
 		else
-			yy_start_stack = (int *) yy_flex_realloc(
-					(void *) yy_start_stack, new_size );
+			(yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack),new_size  );
 
-		if ( ! yy_start_stack )
-			YY_FATAL_ERROR(
-			"out of memory expanding start-condition stack" );
+		if ( ! (yy_start_stack) )
+			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
 		}
 
-	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
 
 	BEGIN(new_state);
-	}
-#endif
-
+}
 
-#ifndef YY_NO_POP_STATE
-#ifdef YY_USE_PROTOS
-static void yy_pop_state(void)
-#else
-static void yy_pop_state()
-#endif
-	{
-	if ( --yy_start_stack_ptr < 0 )
+    static void yy_pop_state  (void)
+{
+    	if ( --(yy_start_stack_ptr) < 0 )
 		YY_FATAL_ERROR( "start-condition stack underflow" );
 
-	BEGIN(yy_start_stack[yy_start_stack_ptr]);
-	}
-#endif
-
-
-#ifndef YY_NO_TOP_STATE
-#ifdef YY_USE_PROTOS
-static int yy_top_state(void)
-#else
-static int yy_top_state()
-#endif
-	{
-	return yy_start_stack[yy_start_stack_ptr - 1];
-	}
-#endif
+	BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
+}
 
 #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2
 #endif
 
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( yyconst char msg[] )
-#else
-static void yy_fatal_error( msg )
-char msg[];
-#endif
-	{
-	(void) fprintf( stderr, "%s\n", msg );
+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. */
 
@@ -3575,68 +4946,193 @@ char msg[];
 	do \
 		{ \
 		/* Undo effects of setting up yytext. */ \
-		yytext[yyleng] = yy_hold_char; \
-		yy_c_buf_p = yytext + n; \
-		yy_hold_char = *yy_c_buf_p; \
-		*yy_c_buf_p = '\0'; \
-		yyleng = n; \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = (yy_hold_char); \
+		(yy_c_buf_p) = yytext + yyless_macro_arg; \
+		(yy_hold_char) = *(yy_c_buf_p); \
+		*(yy_c_buf_p) = '\0'; \
+		yyleng = yyless_macro_arg; \
 		} \
 	while ( 0 )
 
+/* Accessor  methods (get/set functions) to struct members. */
 
-/* Internal utility routines. */
+/** Get the current line number.
+ * 
+ */
+int yyget_lineno  (void)
+{
+        
+    return yylineno;
+}
 
-#ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+/** Get the input stream.
+ * 
+ */
+FILE *yyget_in  (void)
+{
+        return yyin;
+}
+
+/** Get the output stream.
+ * 
+ */
+FILE *yyget_out  (void)
+{
+        return yyout;
+}
+
+/** Get the length of the current token.
+ * 
+ */
+yy_size_t yyget_leng  (void)
+{
+        return yyleng;
+}
+
+/** Get the current token.
+ * 
+ */
+
+char *yyget_text  (void)
+{
+        return yytext;
+}
+
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void yyset_lineno (int  line_number )
+{
+    
+    yylineno = line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  in_str )
+{
+        yyin = in_str ;
+}
+
+void yyset_out (FILE *  out_str )
+{
+        yyout = out_str ;
+}
+
+int yyget_debug  (void)
+{
+        return yy_flex_debug;
+}
+
+void yyset_debug (int  bdebug )
+{
+        yy_flex_debug = bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_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;
+
+    (yy_start_stack_ptr) = 0;
+    (yy_start_stack_depth) = 0;
+    (yy_start_stack) =  NULL;
+
+    (yy_state_buf) = 0;
+    (yy_state_ptr) = 0;
+    (yy_full_match) = 0;
+    (yy_lp) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
 #else
-static void yy_flex_strncpy( s1, s2, n )
-char *s1;
-yyconst char *s2;
-int n;
+    yyin = (FILE *) 0;
+    yyout = (FILE *) 0;
 #endif
-	{
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer(YY_CURRENT_BUFFER  );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state();
+	}
+
+	/* Destroy the stack itself. */
+	yyfree((yy_buffer_stack) );
+	(yy_buffer_stack) = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree((yy_start_stack)  );
+        (yy_start_stack) = NULL;
+
+    yyfree ( (yy_state_buf) );
+    (yy_state_buf)  = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() 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 )
+{
 	int i;
 	for ( i = 0; i < n; ++i )
 		s1[i] = s2[i];
-	}
+}
 #endif
 
 #ifdef YY_NEED_STRLEN
-#ifdef YY_USE_PROTOS
-static int yy_flex_strlen( yyconst char *s )
-#else
-static int yy_flex_strlen( s )
-yyconst char *s;
-#endif
-	{
+static int yy_flex_strlen (yyconst char * s )
+{
 	int n;
 	for ( n = 0; s[n]; ++n )
 		;
 
 	return n;
-	}
+}
 #endif
 
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( yy_size_t size )
-#else
-static void *yy_flex_alloc( size )
-yy_size_t size;
-#endif
-	{
+void *yyalloc (yy_size_t  size )
+{
 	return (void *) malloc( size );
-	}
+}
 
-#ifdef YY_USE_PROTOS
-static void *yy_flex_realloc( void *ptr, yy_size_t size )
-#else
-static void *yy_flex_realloc( ptr, size )
-void *ptr;
-yy_size_t size;
-#endif
-	{
+void *yyrealloc  (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
@@ -3645,26 +5141,17 @@ yy_size_t size;
 	 * as though doing an assignment.
 	 */
 	return (void *) realloc( (char *) ptr, size );
-	}
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
-#else
-static void yy_flex_free( ptr )
-void *ptr;
-#endif
-	{
-	free( ptr );
-	}
+void yyfree (void * ptr )
+{
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 969 "scan.l"
 
-#if YY_MAIN
-int main()
-	{
-	yylex();
-	return 0;
-	}
-#endif
-#line 651 "scan.l"
 
 
 
@@ -3726,3 +5213,4 @@ void *ptr;
 	if ( ptr )
 		free( ptr );
 	}
+
diff --git a/usr.bin/lex/initskel.c b/usr.bin/lex/initskel.c
new file mode 100644
index 000000000000..8b756a30d8cb
--- /dev/null
+++ b/usr.bin/lex/initskel.c
@@ -0,0 +1,3738 @@
+/* $FreeBSD$ */
+/* File created from flex.skl via mkskel.sh */
+
+#include "flexdef.h"
+
+const char *skel[] = {
+  "%# -*-C-*- vi: set ft=c:",
+  "%# This file is processed in several stages.",
+  "%# Here are the stages, as best as I can describe:",
+  "%#",
+  "%#   1. flex.skl is processed through GNU m4 during the",
+  "%#      pre-compilation stage of flex. Only macros starting",
+  "%#      with `m4_' are processed, and quoting is normal.",
+  "%#",
+  "%#   2. The preprocessed skeleton is translated verbatim into a",
+  "%#      C array, saved as \"skel.c\" and compiled into the flex binary.",
+  "%#",
+  "%#   3. At runtime, the skeleton is generated and filtered (again)",
+  "%#      through m4. Macros beginning with `m4_' will be processed.",
+  "%#      The quoting is \"[[\" and \"]]\" so we don't interfere with",
+  "%#      user code.",
+  "%# ",
+  "%# All generate macros for the m4 stage contain the text \"m4\" or \"M4\"",
+  "%# in them. This is to distinguish them from CPP macros.",
+  "%# The exception to this rule is YY_G, which is an m4 macro, ",
+  "%# but it needs to be remain short because it is used everywhere.",
+  "%#",
+  "/* A lexical scanner generated by flex */",
+  "",
+  "%#  Macros for preproc stage.",
+  "",
+  "",
+  "%# Macros for runtime processing stage.",
+  "m4_changecom",
+  "m4_changequote",
+  "m4_changequote([[, ]])",
+  "",
+  "%# ",
+  "%# Lines in this skeleton starting with a \"%\" character are \"control lines\"",
+  "%# and affect the generation of the scanner. The possible control codes are",
+  "%# listed and processed in misc.c.",
+  "%#",
+  "%#   %#  -  A comment. The current line is omitted from the generated scanner.",
+  "%#   %if-c++-only  -  The following lines are printed for C++ scanners ONLY.",
+  "%#   %if-c-only    -  The following lines are NOT printed for C++ scanners.",
+  "%#   %if-c-or-c++  -  The following lines are printed in BOTH C and C++ scanners.",
+  "%#   %if-reentrant     - Print for reentrant scanners.(push)",
+  "%#   %if-not-reentrant - Print for non-reentrant scanners. (push)",
+  "%#   %if-bison-bridge  - Print for bison-bridge. (push)",
+  "%#   %if-not-bison-bridge  - Print for non-bison-bridge. (push)",
+  "%#   %endif        - pop from the previous if code.",
+  "%#   %%  -  A stop-point, where code is inserted by flex.",
+  "%#          Each stop-point is numbered here and also in the code generator.",
+  "%#          (See gen.c, etc. for details.)",
+  "%#   %not-for-header  -  Begin code that should NOT appear in a \".h\" file.",
+  "%#   %ok-for-header   -  %c and %e are used for building a header file.",
+  "%#   %if-tables-serialization",
+  "%#",
+  "%#   All control-lines EXCEPT comment lines (\"%#\") will be inserted into",
+  "%#   the generated scanner as a C-style comment. This is to aid those who",
+  "%#   edit the skeleton.",
+  "%#",
+  "",
+  "%not-for-header",
+  "%if-c-only",
+  "%if-not-reentrant",
+  "m4_ifelse(M4_YY_PREFIX,yy,,",
+  "#define yy_create_buffer M4_YY_PREFIX[[_create_buffer]]",
+  "#define yy_delete_buffer M4_YY_PREFIX[[_delete_buffer]]",
+  "#define yy_flex_debug M4_YY_PREFIX[[_flex_debug]]",
+  "#define yy_init_buffer M4_YY_PREFIX[[_init_buffer]]",
+  "#define yy_flush_buffer M4_YY_PREFIX[[_flush_buffer]]",
+  "#define yy_load_buffer_state M4_YY_PREFIX[[_load_buffer_state]]",
+  "#define yy_switch_to_buffer M4_YY_PREFIX[[_switch_to_buffer]]",
+  "#define yyin M4_YY_PREFIX[[in]]",
+  "#define yyleng M4_YY_PREFIX[[leng]]",
+  "#define yylex M4_YY_PREFIX[[lex]]",
+  "#define yylineno M4_YY_PREFIX[[lineno]]",
+  "#define yyout M4_YY_PREFIX[[out]]",
+  "#define yyrestart M4_YY_PREFIX[[restart]]",
+  "#define yytext M4_YY_PREFIX[[text]]",
+  "#define yywrap M4_YY_PREFIX[[wrap]]",
+  "#define yyalloc M4_YY_PREFIX[[alloc]]",
+  "#define yyrealloc M4_YY_PREFIX[[realloc]]",
+  "#define yyfree M4_YY_PREFIX[[free]]",
+  ")",
+  "%endif",
+  "%endif",
+  "%ok-for-header",
+  "",
+  "#define FLEX_SCANNER",
+  "#define YY_FLEX_MAJOR_VERSION 2",
+  "#define YY_FLEX_MINOR_VERSION 5",
+  "#define YY_FLEX_SUBMINOR_VERSION 37",
+  "#if YY_FLEX_SUBMINOR_VERSION > 0",
+  "#define FLEX_BETA",
+  "#endif",
+  "",
+  "%# Some negated symbols",
+  "m4_ifdef( [[M4_YY_IN_HEADER]], , [[m4_define([[M4_YY_NOT_IN_HEADER]], [[]])]])",
+  "m4_ifdef( [[M4_YY_REENTRANT]], , [[m4_define([[M4_YY_NOT_REENTRANT]], [[]])]])",
+  "",
+  "%# This is the m4 way to say \"(stack_used || is_reentrant)",
+  "m4_ifdef( [[M4_YY_STACK_USED]], [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])",
+  "m4_ifdef( [[M4_YY_REENTRANT]],  [[m4_define([[M4_YY_HAS_START_STACK_VARS]])]])",
+  "",
+  "%# Prefixes.",
+  "%# The complexity here is necessary so that m4 preserves",
+  "%# the argument lists to each C function.",
+  "",
+  "",
+  "m4_ifdef( [[M4_YY_PREFIX]],, [[m4_define([[M4_YY_PREFIX]], [[yy]])]])",
+  "",
+  "",
+  "",
+  "%if-c++-only",
+  "    /* The c++ scanner is a mess. The FlexLexer.h header file relies on the",
+  "     * following macro. This is required in order to pass the c++-multiple-scanners",
+  "     * test in the regression suite. We get reports that it breaks inheritance.",
+  "     * We will address this in a future release of flex, or omit the C++ scanner",
+  "     * altogether.",
+  "     */",
+  "    #define yyFlexLexer M4_YY_PREFIX[[FlexLexer]]",
+  "%endif",
+  "",
+  "%if-c-only",
+  "    m4_define(yy[[_create_buffer]], [[M4_YY_PREFIX[[_create_buffer]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_delete_buffer]], [[M4_YY_PREFIX[[_delete_buffer]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_scan_buffer]], [[M4_YY_PREFIX[[_scan_buffer]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_scan_string]], [[M4_YY_PREFIX[[_scan_string]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_scan_bytes]], [[M4_YY_PREFIX[[_scan_bytes]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_init_buffer]], [[M4_YY_PREFIX[[_init_buffer]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_flush_buffer]], [[M4_YY_PREFIX[[_flush_buffer]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_load_buffer_state]], [[M4_YY_PREFIX[[_load_buffer_state]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_switch_to_buffer]], [[M4_YY_PREFIX[[_switch_to_buffer]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[push_buffer_state]], [[M4_YY_PREFIX[[push_buffer_state]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[pop_buffer_state]], [[M4_YY_PREFIX[[pop_buffer_state]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[ensure_buffer_stack]], [[M4_YY_PREFIX[[ensure_buffer_stack]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[lex]], [[M4_YY_PREFIX[[lex]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[restart]], [[M4_YY_PREFIX[[restart]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[lex_init]], [[M4_YY_PREFIX[[lex_init]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[lex_init_extra]], [[M4_YY_PREFIX[[lex_init_extra]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[lex_destroy]], [[M4_YY_PREFIX[[lex_destroy]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_debug]], [[M4_YY_PREFIX[[get_debug]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_debug]], [[M4_YY_PREFIX[[set_debug]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_extra]], [[M4_YY_PREFIX[[get_extra]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_extra]], [[M4_YY_PREFIX[[set_extra]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_in]], [[M4_YY_PREFIX[[get_in]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_in]], [[M4_YY_PREFIX[[set_in]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_out]], [[M4_YY_PREFIX[[get_out]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_out]], [[M4_YY_PREFIX[[set_out]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_leng]], [[M4_YY_PREFIX[[get_leng]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_text]], [[M4_YY_PREFIX[[get_text]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[get_lineno]], [[M4_YY_PREFIX[[get_lineno]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_lineno]], [[M4_YY_PREFIX[[set_lineno]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_ifdef( [[M4_YY_REENTRANT]],",
+  "    [[",
+  "        m4_define(yy[[get_column]], [[M4_YY_PREFIX[[get_column]]m4_ifelse($#,0,,[[($@)]])]])",
+  "        m4_define(yy[[set_column]], [[M4_YY_PREFIX[[set_column]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    ]])",
+  "    m4_define(yy[[wrap]], [[M4_YY_PREFIX[[wrap]]m4_ifelse($#,0,,[[($@)]])]])",
+  "%endif",
+  "",
+  "m4_ifdef( [[M4_YY_BISON_LVAL]],",
+  "[[",
+  "    m4_define(yy[[get_lval]], [[M4_YY_PREFIX[[get_lval]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_lval]], [[M4_YY_PREFIX[[set_lval]]m4_ifelse($#,0,,[[($@)]])]])",
+  "]])",
+  "",
+  "m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "[[",
+  "    m4_define(yy[[get_lloc]], [[M4_YY_PREFIX[[get_lloc]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[set_lloc]], [[M4_YY_PREFIX[[set_lloc]]m4_ifelse($#,0,,[[($@)]])]])",
+  "]])",
+  "",
+  "",
+  "    m4_define(yy[[alloc]], [[M4_YY_PREFIX[[alloc]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[realloc]], [[M4_YY_PREFIX[[realloc]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[free]], [[M4_YY_PREFIX[[free]]m4_ifelse($#,0,,[[($@)]])]])",
+  "",
+  "%if-c-only",
+  "m4_ifdef( [[M4_YY_NOT_REENTRANT]],",
+  "[[",
+  "    m4_define(yy[[text]], [[M4_YY_PREFIX[[text]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[leng]], [[M4_YY_PREFIX[[leng]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[in]], [[M4_YY_PREFIX[[in]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[out]], [[M4_YY_PREFIX[[out]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[_flex_debug]], [[M4_YY_PREFIX[[_flex_debug]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[lineno]], [[M4_YY_PREFIX[[lineno]]m4_ifelse($#,0,,[[($@)]])]])",
+  "]])",
+  "%endif",
+  "",
+  "",
+  "m4_ifdef( [[M4_YY_TABLES_EXTERNAL]],",
+  "[[",
+  "    m4_define(yy[[tables_fload]], [[M4_YY_PREFIX[[tables_fload]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[tables_destroy]], [[M4_YY_PREFIX[[tables_destroy]]m4_ifelse($#,0,,[[($@)]])]])",
+  "    m4_define(yy[[TABLES_NAME]], [[M4_YY_PREFIX[[TABLES_NAME]]m4_ifelse($#,0,,[[($@)]])]])",
+  "]])",
+  "",
+  "/* First, we deal with  platform-specific or compiler-specific issues. */",
+  "",
+  "#if defined(__FreeBSD__)",
+  "#ifndef __STDC_LIMIT_MACROS",
+  "#define	__STDC_LIMIT_MACROS",
+  "#endif",
+  "#include <sys/cdefs.h>",
+  "#include <stdint.h>",
+  "#else",
+  "#define	__dead2",
+  "#endif",
+  "",
+  "/* begin standard C headers. */",
+  "%if-c-only",
+  "#include <stdio.h>",
+  "#include <string.h>",
+  "#include <errno.h>",
+  "#include <stdlib.h>",
+  "%endif",
+  "",
+  "%if-tables-serialization",
+  "#include <sys/types.h>",
+  "#include <netinet/in.h>",
+  "%endif",
+  "/* end standard C headers. */",
+  "",
+  "%if-c-or-c++",
+  "/* flex integer type definitions */",
+  "",
+  "#ifndef FLEXINT_H",
+  "#define FLEXINT_H",
+  "",
+  "/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */",
+  "",
+  "#if defined(__FreeBSD__) || \\",
+  "    (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 */",
+  "",
+  "%endif",
+  "",
+  "%if-c++-only",
+  "/* begin standard C++ headers. */",
+  "#include <iostream> ",
+  "#include <errno.h>",
+  "#include <cstdlib>",
+  "#include <cstdio>",
+  "#include <cstring>",
+  "/* end standard C++ headers. */",
+  "%endif",
+  "",
+  "#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",
+  "",
+  "%# For compilers that can not handle prototypes.",
+  "%# e.g.,",
+  "%# The function prototype",
+  "%#    int foo(int x, char* y);",
+  "%# ",
+  "%# ...should be written as",
+  "%#    int foo M4_YY_PARAMS(int x, char* y);",
+  "%# ",
+  "%# ...which could possibly generate",
+  "%#    int foo ();",
+  "%# ",
+  "m4_ifdef( [[M4_YY_NO_ANSI_FUNC_PROTOS]],",
+  "[[",
+  "    m4_define( [[M4_YY_PARAMS]], [[()]])",
+  "]],",
+  "[[",
+  "    m4_define( [[M4_YY_PARAMS]], [[($*)]])",
+  "]])",
+  "",
+  "%not-for-header",
+  "/* Returned upon end-of-file. */",
+  "#define YY_NULL 0",
+  "%ok-for-header",
+  "",
+  "%not-for-header",
+  "/* 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)",
+  "%ok-for-header",
+  "",
+  "",
+  "",
+  "%if-reentrant",
+  "",
+  "/* An opaque pointer. */",
+  "#ifndef YY_TYPEDEF_YY_SCANNER_T",
+  "#define YY_TYPEDEF_YY_SCANNER_T",
+  "typedef void* yyscan_t;",
+  "#endif",
+  "",
+  "%# Declare yyguts variable",
+  "m4_define( [[M4_YY_DECL_GUTS_VAR]], [[struct yyguts_t * yyg = (struct yyguts_t*)yyscanner]])",
+  "%# Perform a noop access on yyguts to prevent unused variable complains",
+  "m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[(void)yyg]])",
+  "%# For use wherever a Global is accessed or assigned.",
+  "m4_define( [[YY_G]], [[yyg->$1]])",
+  "",
+  "%# For use in function prototypes to append the additional argument.",
+  "m4_define( [[M4_YY_PROTO_LAST_ARG]],  [[, yyscan_t yyscanner]])",
+  "m4_define( [[M4_YY_PROTO_ONLY_ARG]],  [[yyscan_t yyscanner]])",
+  "",
+  "%# For use in function definitions to append the additional argument.",
+  "m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],",
+  "[[",
+  "    m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscanner]])",
+  "    m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscanner]])",
+  "]],",
+  "[[",
+  "    m4_define( [[M4_YY_DEF_LAST_ARG]],  [[, yyscan_t yyscanner]])",
+  "    m4_define( [[M4_YY_DEF_ONLY_ARG]],  [[yyscan_t yyscanner]])",
+  "]])",
+  "m4_define( [[M4_YY_DECL_LAST_ARG]],  [[yyscan_t yyscanner;]])",
+  "",
+  "%# For use in function calls to pass the additional argument.",
+  "m4_define( [[M4_YY_CALL_LAST_ARG]], [[, yyscanner]])",
+  "m4_define( [[M4_YY_CALL_ONLY_ARG]], [[yyscanner]])",
+  "",
+  "%# For use in function documentation to adjust for additional argument.",
+  "m4_define( [[M4_YY_DOC_PARAM]], [[@param yyscanner The scanner object.]])",
+  "",
+  "/* For convenience, these vars (plus the bison vars far below)",
+  "   are macros in the reentrant scanner. */",
+  "#define yyin YY_G(yyin_r)",
+  "#define yyout YY_G(yyout_r)",
+  "#define yyextra YY_G(yyextra_r)",
+  "#define yyleng YY_G(yyleng_r)",
+  "#define yytext YY_G(yytext_r)",
+  "#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)",
+  "#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)",
+  "#define yy_flex_debug YY_G(yy_flex_debug_r)",
+  "",
+  "m4_define( [[M4_YY_INCR_LINENO]],",
+  "[[   ",
+  "    do{ yylineno++;",
+  "        yycolumn=0;",
+  "    }while(0)",
+  "]])",
+  "",
+  "%endif",
+  "",
+  "",
+  "",
+  "%if-not-reentrant",
+  "",
+  "m4_define( [[M4_YY_INCR_LINENO]],",
+  "[[   ",
+  "    yylineno++;",
+  "]])",
+  "",
+  "%# Define these macros to be no-ops.",
+  "m4_define( [[M4_YY_DECL_GUTS_VAR]], [[m4_dnl]])",
+  "m4_define( [[M4_YY_NOOP_GUTS_VAR]], [[m4_dnl]])",
+  "m4_define( [[YY_G]], [[($1)]])",
+  "m4_define( [[M4_YY_PROTO_LAST_ARG]])",
+  "m4_define( [[M4_YY_PROTO_ONLY_ARG]],  [[void]])",
+  "m4_define( [[M4_YY_DEF_LAST_ARG]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],",
+  "[[",
+  "    m4_define( [[M4_YY_DEF_ONLY_ARG]])",
+  "]],",
+  "[[",
+  "    m4_define( [[M4_YY_DEF_ONLY_ARG]],  [[void]])",
+  "]])",
+  "m4_define([[M4_YY_DECL_LAST_ARG]])",
+  "m4_define([[M4_YY_CALL_LAST_ARG]])",
+  "m4_define([[M4_YY_CALL_ONLY_ARG]])",
+  "m4_define( [[M4_YY_DOC_PARAM]], [[]])",
+  "",
+  "%endif",
+  "",
+  "",
+  "m4_ifdef( [[M4_YY_NO_ANSI_FUNC_DEFS]],",
+  "[[",
+  "%# For compilers that need traditional function definitions.",
+  "%# e.g.,",
+  "%# The function prototype taking 2 arguments",
+  "%#    int foo (int x, char* y)",
+  "%#",
+  "%# ...should be written as",
+  "%#    int foo YYFARGS2(int,x, char*,y)",
+  "%#",
+  "%# ...which could possibly generate",
+  "%#    int foo (x,y,yyscanner)",
+  "%#        int x;",
+  "%#        char * y;",
+  "%#        yyscan_t yyscanner;",
+  "%#",
+  "%# Generate traditional function defs",
+  "    m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG) [[\\]]",
+  "        M4_YY_DECL_LAST_ARG]])",
+  "    m4_define( [[YYFARGS1]], [[($2 M4_YY_DEF_LAST_ARG) [[\\]]",
+  "        $1 $2; [[\\]]",
+  "        M4_YY_DECL_LAST_ARG]])",
+  "    m4_define( [[YYFARGS2]], [[($2,$4 M4_YY_DEF_LAST_ARG) [[\\]]",
+  "        $1 $2; [[\\]]",
+  "        $3 $4; [[\\]]",
+  "        M4_YY_DECL_LAST_ARG]])",
+  "    m4_define( [[YYFARGS3]], [[($2,$4,$6 M4_YY_DEF_LAST_ARG) [[\\]]",
+  "        $1 $2; [[\\]]",
+  "        $3 $4; [[\\]]",
+  "        $5 $6; [[\\]]",
+  "        M4_YY_DECL_LAST_ARG]])",
+  "]],",
+  "[[",
+  "%# Generate C99 function defs.",
+  "    m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG)]])",
+  "    m4_define( [[YYFARGS1]], [[($1 $2 M4_YY_DEF_LAST_ARG)]])",
+  "    m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 M4_YY_DEF_LAST_ARG)]])",
+  "    m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 M4_YY_DEF_LAST_ARG)]])",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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_G(yy_start) = 1 + 2 *",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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_G(yy_start) - 1) / 2)",
+  "#define YYSTATE YY_START",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Action number for EOF rule of a given start state. */",
+  "#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Special action meaning \"start processing a new file\". */",
+  "#define YY_NEW_FILE yyrestart( yyin M4_YY_CALL_LAST_ARG )",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define YY_END_OF_BUFFER_CHAR 0",
+  "]])",
+  "",
+  "/* Size of default input buffer. */",
+  "#ifndef YY_BUF_SIZE",
+  "#define YY_BUF_SIZE 16384",
+  "#endif",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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",
+  "",
+  "#ifndef YY_TYPEDEF_YY_SIZE_T",
+  "#define YY_TYPEDEF_YY_SIZE_T",
+  "typedef size_t yy_size_t;",
+  "#endif",
+  "",
+  "%if-not-reentrant",
+  "extern yy_size_t yyleng;",
+  "%endif",
+  "",
+  "%if-c-only",
+  "%if-not-reentrant",
+  "extern FILE *yyin, *yyout;",
+  "%endif",
+  "%endif",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define EOB_ACT_CONTINUE_SCAN 0",
+  "#define EOB_ACT_END_OF_FILE 1",
+  "#define EOB_ACT_LAST_MATCH 2",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "    m4_ifdef( [[M4_YY_USE_LINENO]],",
+  "    [[",
+  "    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires",
+  "     *       access to the local variable yy_act. Since yyless() is a macro, it would break",
+  "     *       existing scanners that call yyless() from OUTSIDE yylex. ",
+  "     *       One obvious solution it to make yy_act a global. I tried that, and saw",
+  "     *       a 5% performance hit in a non-yylineno scanner, because yy_act is",
+  "     *       normally declared as a register variable-- so it is not worth it.",
+  "     */",
+  "    #define  YY_LESS_LINENO(n) \\",
+  "            do { \\",
+  "                int yyl;\\",
+  "                for ( yyl = n; yyl < yyleng; ++yyl )\\",
+  "                    if ( yytext[yyl] == '\\n' )\\",
+  "                        --yylineno;\\",
+  "            }while(0)",
+  "    ]],",
+  "    [[",
+  "    #define YY_LESS_LINENO(n)",
+  "    ]])",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Return all but the first \"n\" matched characters back to the input stream. */",
+  "#define yyless(n) \\",
+  "	do \\",
+  "		{ \\",
+  "		/* Undo effects of setting up yytext. */ \\",
+  "        int yyless_macro_arg = (n); \\",
+  "        YY_LESS_LINENO(yyless_macro_arg);\\",
+  "		*yy_cp = YY_G(yy_hold_char); \\",
+  "		YY_RESTORE_YY_MORE_OFFSET \\",
+  "		YY_G(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \\",
+  "		YY_DO_BEFORE_ACTION; /* set up yytext again */ \\",
+  "		} \\",
+  "	while ( 0 )",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define unput(c) yyunput( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG )",
+  "]])",
+  "",
+  "#ifndef YY_STRUCT_YY_BUFFER_STATE",
+  "#define YY_STRUCT_YY_BUFFER_STATE",
+  "struct yy_buffer_state",
+  "	{",
+  "%if-c-only",
+  "	FILE *yy_input_file;",
+  "%endif",
+  "",
+  "%if-c++-only",
+  "	std::istream* yy_input_file;",
+  "%endif",
+  "",
+  "",
+  "	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.",
+  "	 */",
+  "	yy_size_t 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;",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#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 yyrestart()), so that the user can continue scanning by",
+  "	 * just pointing yyin at a new input file.",
+  "	 */",
+  "#define YY_BUFFER_EOF_PENDING 2",
+  "]])",
+  "	};",
+  "#endif /* !YY_STRUCT_YY_BUFFER_STATE */",
+  "",
+  "%if-c-only Standard (non-C++) definition",
+  "%not-for-header",
+  "%if-not-reentrant",
+  "",
+  "/* 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. */",
+  "%endif",
+  "%ok-for-header",
+  "%endif",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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_G(yy_buffer_stack) \\",
+  "                          ? YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)] \\",
+  "                          : NULL)",
+  "#define yy_current_buffer YY_CURRENT_BUFFER",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)]",
+  "]])",
+  "",
+  "%if-c-only Standard (non-C++) definition",
+  "",
+  "%if-not-reentrant",
+  "%not-for-header",
+  "/* yy_hold_char holds the character lost when yytext is formed. */",
+  "static char yy_hold_char;",
+  "static yy_size_t yy_n_chars;		/* number of characters read into yy_ch_buf */",
+  "yy_size_t yyleng;",
+  "",
+  "/* 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 yywrap()'s to do buffer switches",
+  " * instead of setting up a fresh yyin.  A bit of a hack ...",
+  " */",
+  "static int yy_did_buffer_switch_on_eof;",
+  "%ok-for-header",
+  "%endif",
+  "",
+  "void yyrestart M4_YY_PARAMS( FILE *input_file M4_YY_PROTO_LAST_ARG );",
+  "void yy_switch_to_buffer M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG );",
+  "YY_BUFFER_STATE yy_create_buffer M4_YY_PARAMS( FILE *file, int size M4_YY_PROTO_LAST_ARG );",
+  "void yy_delete_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG );",
+  "void yy_flush_buffer M4_YY_PARAMS( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG );",
+  "void yypush_buffer_state M4_YY_PARAMS( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG );",
+  "void yypop_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "static void yyensure_buffer_stack M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "static void yy_load_buffer_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "static void yy_init_buffer M4_YY_PARAMS( YY_BUFFER_STATE b, FILE *file M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG)",
+  "]])",
+  "",
+  "YY_BUFFER_STATE yy_scan_buffer M4_YY_PARAMS( char *base, yy_size_t size M4_YY_PROTO_LAST_ARG );",
+  "YY_BUFFER_STATE yy_scan_string M4_YY_PARAMS( yyconst char *yy_str M4_YY_PROTO_LAST_ARG );",
+  "YY_BUFFER_STATE yy_scan_bytes M4_YY_PARAMS( yyconst char *bytes, yy_size_t len M4_YY_PROTO_LAST_ARG );",
+  "",
+  "%endif",
+  "",
+  "void *yyalloc M4_YY_PARAMS( yy_size_t M4_YY_PROTO_LAST_ARG );",
+  "void *yyrealloc M4_YY_PARAMS( void *, yy_size_t M4_YY_PROTO_LAST_ARG );",
+  "void yyfree M4_YY_PARAMS( void * M4_YY_PROTO_LAST_ARG );",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define yy_new_buffer yy_create_buffer",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define yy_set_interactive(is_interactive) \\",
+  "	{ \\",
+  "	if ( ! YY_CURRENT_BUFFER ){ \\",
+  "        yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \\",
+  "		YY_CURRENT_BUFFER_LVALUE =    \\",
+  "            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \\",
+  "	} \\",
+  "	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \\",
+  "	}",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define yy_set_bol(at_bol) \\",
+  "	{ \\",
+  "	if ( ! YY_CURRENT_BUFFER ){\\",
+  "        yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \\",
+  "		YY_CURRENT_BUFFER_LVALUE =    \\",
+  "            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \\",
+  "	} \\",
+  "	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \\",
+  "	}",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)",
+  "]])",
+  "",
+  "%% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "%% [1.5] DFA",
+  "]])",
+  "",
+  "%if-c-only Standard (non-C++) definition",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "static yy_state_type yy_get_previous_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "static yy_state_type yy_try_NUL_trans M4_YY_PARAMS( yy_state_type current_state  M4_YY_PROTO_LAST_ARG);",
+  "static int yy_get_next_buffer M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "static void yy_fatal_error M4_YY_PARAMS( yyconst char msg[] M4_YY_PROTO_LAST_ARG ) __dead2;",
+  "]])",
+  "",
+  "%endif",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Done after the current pattern has been matched and before the",
+  " * corresponding action - sets up yytext.",
+  " */",
+  "#define YY_DO_BEFORE_ACTION \\",
+  "	YY_G(yytext_ptr) = yy_bp; \\",
+  "%% [2.0] code to fiddle yytext and yyleng for yymore() goes here \\",
+  "	YY_G(yy_hold_char) = *yy_cp; \\",
+  "	*yy_cp = '\\0'; \\",
+  "%% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \\",
+  "	YY_G(yy_c_buf_p) = yy_cp;",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "%% [4.0] data tables for the DFA and the user's section 1 definitions go here",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_IN_HEADER]], [[#ifdef YY_HEADER_EXPORT_START_CONDITIONS]])",
+  "M4_YY_SC_DEFS",
+  "m4_ifdef( [[M4_YY_IN_HEADER]], [[#endif]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_UNISTD_H]],,",
+  "[[",
+  "#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.",
+  " */",
+  "%if-c-only",
+  "#include <unistd.h>",
+  "%endif",
+  "%if-c++-only",
+  "#include <unistd.h>",
+  "%endif",
+  "#endif",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_EXTRA_TYPE_DEFS]],",
+  "[[",
+  "#define YY_EXTRA_TYPE M4_EXTRA_TYPE_DEFS",
+  "]],",
+  "[[",
+  "#ifndef YY_EXTRA_TYPE",
+  "#define YY_EXTRA_TYPE void *",
+  "#endif",
+  "]]",
+  ")",
+  "",
+  "%if-c-only Reentrant structure and macros (non-C++).",
+  "%if-reentrant",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Holds the entire state of the reentrant scanner. */",
+  "struct yyguts_t",
+  "    {",
+  "",
+  "    /* User-defined. Not touched by flex. */",
+  "    YY_EXTRA_TYPE yyextra_r;",
+  "",
+  "    /* The rest are the same as the globals declared in the non-reentrant scanner. */",
+  "    FILE *yyin_r, *yyout_r;",
+  "    size_t yy_buffer_stack_top; /**< index of top of stack. */",
+  "    size_t yy_buffer_stack_max; /**< capacity of stack. */",
+  "    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */",
+  "    char yy_hold_char;",
+  "    yy_size_t yy_n_chars;",
+  "    yy_size_t yyleng_r;",
+  "    char *yy_c_buf_p;",
+  "    int yy_init;",
+  "    int yy_start;",
+  "    int yy_did_buffer_switch_on_eof;",
+  "    int yy_start_stack_ptr;",
+  "    int yy_start_stack_depth;",
+  "    int *yy_start_stack;",
+  "    yy_state_type yy_last_accepting_state;",
+  "    char* yy_last_accepting_cpos;",
+  "",
+  "    int yylineno_r;",
+  "    int yy_flex_debug_r;",
+  "",
+  "m4_ifdef( [[M4_YY_USES_REJECT]],",
+  "[[",
+  "    yy_state_type *yy_state_buf;",
+  "    yy_state_type *yy_state_ptr;",
+  "    char *yy_full_match;",
+  "    int yy_lp;",
+  "",
+  "    /* These are only needed for trailing context rules,",
+  "     * but there's no conditional variable for that yet. */",
+  "    int yy_looking_for_trail_begin;",
+  "    int yy_full_lp;",
+  "    int *yy_full_state;",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_TEXT_IS_ARRAY]],",
+  "[[",
+  "    char yytext_r[YYLMAX];",
+  "    char *yytext_ptr;",
+  "    int yy_more_offset;",
+  "    int yy_prev_more_offset;",
+  "]],",
+  "[[",
+  "    char *yytext_r;",
+  "    int yy_more_flag;",
+  "    int yy_more_len;",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_BISON_LVAL]],",
+  "[[",
+  "    YYSTYPE * yylval_r;",
+  "]])",
+  "",
+  "m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "[[",
+  "    YYLTYPE * yylloc_r;",
+  "]])",
+  "",
+  "    }; /* end struct yyguts_t */",
+  "]])",
+  "",
+  "",
+  "%if-c-only",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "static int yy_init_globals M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "%endif",
+  "",
+  "%if-reentrant",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "    m4_ifdef( [[M4_YY_BISON_LVAL]],",
+  "    [[",
+  "    /* This must go here because YYSTYPE and YYLTYPE are included",
+  "     * from bison output in section 1.*/",
+  "    #    define yylval YY_G(yylval_r)",
+  "    ]])",
+  "",
+  "    m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "    [[",
+  "    #    define yylloc YY_G(yylloc_r)",
+  "    ]])",
+  "]])",
+  "",
+  "int yylex_init M4_YY_PARAMS(yyscan_t* scanner);",
+  "",
+  "int yylex_init_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);",
+  "",
+  "%endif",
+  "",
+  "%endif End reentrant structures and macros.",
+  "",
+  "/* Accessor methods to globals.",
+  "   These are made visible to non-reentrant scanners for convenience. */",
+  "",
+  "m4_ifdef( [[M4_YY_NO_DESTROY]],,",
+  "[[",
+  "int yylex_destroy M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_DEBUG]],,",
+  "[[",
+  "int yyget_debug M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_SET_DEBUG]],,",
+  "[[",
+  "void yyset_debug M4_YY_PARAMS( int debug_flag M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_EXTRA]],,",
+  "[[",
+  "YY_EXTRA_TYPE yyget_extra M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_SET_EXTRA]],,",
+  "[[",
+  "void yyset_extra M4_YY_PARAMS( YY_EXTRA_TYPE user_defined M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_IN]],,",
+  "[[",
+  "FILE *yyget_in M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_SET_IN]],,",
+  "[[",
+  "void yyset_in  M4_YY_PARAMS( FILE * in_str M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_OUT]],,",
+  "[[",
+  "FILE *yyget_out M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_SET_OUT]],,",
+  "[[",
+  "void yyset_out  M4_YY_PARAMS( FILE * out_str M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_LENG]],,",
+  "[[",
+  "yy_size_t yyget_leng M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_TEXT]],,",
+  "[[",
+  "char *yyget_text M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_GET_LINENO]],,",
+  "[[",
+  "int yyget_lineno M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NO_SET_LINENO]],,",
+  "[[",
+  "void yyset_lineno M4_YY_PARAMS( int line_number M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_REENTRANT]],",
+  "[[",
+  "m4_ifdef( [[M4_YY_NO_GET_COLUMN]],,",
+  "[[",
+  "int yyget_column  M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_REENTRANT]],",
+  "[[",
+  "m4_ifdef( [[M4_YY_NO_SET_COLUMN]],,",
+  "[[",
+  "void yyset_column M4_YY_PARAMS( int column_no M4_YY_PROTO_LAST_ARG );",
+  "]])",
+  "]])",
+  "",
+  "%if-bison-bridge",
+  "m4_ifdef( [[M4_YY_NO_GET_LVAL]],,",
+  "[[",
+  "YYSTYPE * yyget_lval M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "]])",
+  "",
+  "void yyset_lval M4_YY_PARAMS( YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG );",
+  "",
+  "m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "[[",
+  "    m4_ifdef( [[M4_YY_NO_GET_LLOC]],,",
+  "    [[",
+  "       YYLTYPE *yyget_lloc M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "    ]])",
+  "",
+  "    m4_ifdef( [[M4_YY_NO_SET_LLOC]],,",
+  "    [[",
+  "        void yyset_lloc M4_YY_PARAMS( YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG );",
+  "    ]])",
+  "]])",
+  "%endif",
+  "",
+  "/* Macros after this point can all be overridden by user definitions in",
+  " * section 1.",
+  " */",
+  "",
+  "#ifndef YY_SKIP_YYWRAP",
+  "#ifdef __cplusplus",
+  "extern \"C\" int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "#else",
+  "extern int yywrap M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "#endif",
+  "#endif",
+  "",
+  "%not-for-header",
+  "    m4_ifdef( [[M4_YY_NO_UNPUT]],,",
+  "    [[",
+  "#ifndef YY_NO_UNPUT",
+  "    static void yyunput M4_YY_PARAMS( int c, char *buf_ptr  M4_YY_PROTO_LAST_ARG);",
+  "#endif",
+  "    ]])",
+  "%ok-for-header",
+  "%endif",
+  "",
+  "#ifndef yytext_ptr",
+  "static void yy_flex_strncpy M4_YY_PARAMS( char *, yyconst char *, int M4_YY_PROTO_LAST_ARG);",
+  "#endif",
+  "",
+  "#ifdef YY_NEED_STRLEN",
+  "static int yy_flex_strlen M4_YY_PARAMS( yyconst char * M4_YY_PROTO_LAST_ARG);",
+  "#endif",
+  "",
+  "#ifndef YY_NO_INPUT",
+  "%if-c-only Standard (non-C++) definition",
+  "%not-for-header",
+  "#ifdef __cplusplus",
+  "static int yyinput M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "#else",
+  "static int input M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "#endif",
+  "%ok-for-header",
+  "%endif",
+  "#endif",
+  "",
+  "",
+  "%if-c-only",
+  "%# TODO: This is messy.",
+  "m4_ifdef( [[M4_YY_STACK_USED]],",
+  "[[",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_REENTRANT]],",
+  "[[",
+  "    m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "    [[",
+  "        static int yy_start_stack_ptr = 0;",
+  "        static int yy_start_stack_depth = 0;",
+  "        static int *yy_start_stack = NULL;",
+  "    ]])",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "    m4_ifdef( [[M4_YY_NO_PUSH_STATE]],,",
+  "    [[",
+  "    static void yy_push_state M4_YY_PARAMS( int new_state M4_YY_PROTO_LAST_ARG);",
+  "    ]])",
+  "    m4_ifdef( [[M4_YY_NO_POP_STATE]],,",
+  "    [[",
+  "    static void yy_pop_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "    ]])",
+  "    m4_ifdef( [[M4_YY_NO_TOP_STATE]],,",
+  "    [[",
+  "    static int yy_top_state M4_YY_PARAMS( M4_YY_PROTO_ONLY_ARG );",
+  "    ]])",
+  "]])",
+  "",
+  "]],",
+  "[[",
+  "m4_define( [[M4_YY_NO_PUSH_STATE]])",
+  "m4_define( [[M4_YY_NO_POP_STATE]])",
+  "m4_define( [[M4_YY_NO_TOP_STATE]])",
+  "]])",
+  "%endif",
+  "",
+  "/* Amount of stuff to slurp up with each read. */",
+  "#ifndef YY_READ_BUF_SIZE",
+  "#define YY_READ_BUF_SIZE 8192",
+  "#endif",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Copy whatever the last rule matched to the standard output. */",
+  "#ifndef ECHO",
+  "%if-c-only Standard (non-C++) definition",
+  "/* This used to be an fputs(), but since the string might contain NUL's,",
+  " * we now use fwrite().",
+  " */",
+  "#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)",
+  "%endif",
+  "%if-c++-only C++ definition",
+  "#define ECHO LexerOutput( yytext, yyleng )",
+  "%endif",
+  "#endif",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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) \\",
+  "%% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \\",
+  "\\",
+  "%if-c++-only C++ definition \\",
+  "	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \\",
+  "		YY_FATAL_ERROR( \"input in flex scanner failed\" );",
+  "%endif",
+  "",
+  "#endif",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Report a fatal error. */",
+  "#ifndef YY_FATAL_ERROR",
+  "%if-c-only",
+  "#define YY_FATAL_ERROR(msg) yy_fatal_error( msg M4_YY_CALL_LAST_ARG)",
+  "%endif",
+  "%if-c++-only",
+  "#define YY_FATAL_ERROR(msg) LexerError( msg )",
+  "%endif",
+  "#endif",
+  "]])",
+  "",
+  "%if-tables-serialization structures and prototypes",
+  "#ifdef FLEX_SCANNER",
+  "/*",
+  "dnl  tables_shared.h - tables serialization header",
+  "dnl",
+  "dnl  Copyright (c) 1990 The Regents of the University of California.",
+  "dnl  All rights reserved.",
+  "dnl",
+  "dnl  This code is derived from software contributed to Berkeley by",
+  "dnl  Vern Paxson.",
+  "dnl",
+  "dnl  The United States Government has rights in this work pursuant",
+  "dnl  to contract no. DE-AC03-76SF00098 between the United States",
+  "dnl  Department of Energy and the University of California.",
+  "dnl",
+  "dnl  This file is part of flex.",
+  "dnl",
+  "dnl  Redistribution and use in source and binary forms, with or without",
+  "dnl  modification, are permitted provided that the following conditions",
+  "dnl  are met:",
+  "dnl",
+  "dnl  1. Redistributions of source code must retain the above copyright",
+  "dnl     notice, this list of conditions and the following disclaimer.",
+  "dnl  2. Redistributions in binary form must reproduce the above copyright",
+  "dnl     notice, this list of conditions and the following disclaimer in the",
+  "dnl     documentation and/or other materials provided with the distribution.",
+  "dnl",
+  "dnl  Neither the name of the University nor the names of its contributors",
+  "dnl  may be used to endorse or promote products derived from this software",
+  "dnl  without specific prior written permission.",
+  "dnl",
+  "dnl  THIS SOFTWARE IS PROVIDED `AS IS' AND WITHOUT ANY EXPRESS OR",
+  "dnl  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED",
+  "dnl  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR",
+  "dnl  PURPOSE.",
+  "",
+  "dnl",
+  "dnl  This file is meant to be included in both the skeleton and the actual",
+  "dnl  flex code (hence the name \"_shared\").",
+  "*/",
+  "#ifndef yyskel_static",
+  "#define yyskel_static static",
+  "#endif",
+  "#else",
+  "#ifndef yyskel_static",
+  "#define yyskel_static",
+  "#endif",
+  "#endif",
+  "",
+  "/* Structures and prototypes for serializing flex tables.  The",
+  " * binary format is documented in the manual.",
+  " *",
+  " * Design considerations:",
+  " *",
+  " *  -  The format allows many tables per file.",
+  " *  -  The tables can be streamed.",
+  " *  -  All data is stored in network byte order.",
+  " *  -  We do not hinder future unicode support.",
+  " *  -  We can lookup tables by name.",
+  " */",
+  "",
+  "/** Magic number for serialized format. */",
+  "#ifndef YYTBL_MAGIC",
+  "#define YYTBL_MAGIC 0xF13C57B1",
+  "#endif",
+  "",
+  "/** Calculate (0-7) = number bytes needed to pad n to next 64-bit boundary. */",
+  "#ifndef yypad64",
+  "#define yypad64(n) ((8-((n)%8))%8)",
+  "#endif",
+  "",
+  "",
+  "#ifndef YYTABLES_TYPES",
+  "#define YYTABLES_TYPES",
+  "/** Possible values for td_id field. Each one corresponds to a",
+  " *  scanner table of the same name.",
+  " */",
+  "enum yytbl_id {",
+  "	YYTD_ID_ACCEPT = 0x01,		/**< 1-dim ints */",
+  "	YYTD_ID_BASE = 0x02,		/**< 1-dim ints */",
+  "	YYTD_ID_CHK = 0x03,		/**< 1-dim ints */",
+  "	YYTD_ID_DEF = 0x04,		/**< 1-dim ints */",
+  "	YYTD_ID_EC = 0x05,		/**< 1-dim ints */",
+  "	YYTD_ID_META = 0x06,		/**< 1-dim ints */",
+  "	YYTD_ID_NUL_TRANS = 0x07,	/**< 1-dim ints, maybe indices */",
+  "	YYTD_ID_NXT = 0x08,		/**< may be 2 dimensional ints */",
+  "	YYTD_ID_RULE_CAN_MATCH_EOL = 0x09, /**< 1-dim ints */",
+  "	YYTD_ID_START_STATE_LIST = 0x0A,	/**< 1-dim indices into trans tbl  */",
+  "	YYTD_ID_TRANSITION = 0x0B,	/**< structs */",
+  "	YYTD_ID_ACCLIST = 0x0C		/**< 1-dim ints */",
+  "};",
+  "",
+  "/** bit flags for t_flags field of struct yytbl_data */",
+  "enum yytbl_flags {",
+  "	/* These first three are mutually exclusive */",
+  "	YYTD_DATA8 = 0x01,   /**< data is an array of type flex_int8_t */",
+  "	YYTD_DATA16 = 0x02,  /**< data is an array of type flex_int16_t */",
+  "	YYTD_DATA32 = 0x04,  /**< data is an array of type flex_int32_t */",
+  "",
+  "	/* These two are mutually exclusive. */",
+  "	YYTD_PTRANS = 0x08,  /**< data is a list of indexes of entries",
+  "                                 into the expanded yy_transition",
+  "                                 array. See notes in manual. */",
+  "	YYTD_STRUCT = 0x10  /**< data consists of yy_trans_info structs */",
+  "};",
+  "",
+  "/* The serialized tables header. */",
+  "struct yytbl_hdr {",
+  "	flex_uint32_t th_magic;  /**< Must be 0xF13C57B1 (comes from \"Flex Table\") */",
+  "	flex_uint32_t th_hsize;  /**< Size of this header in bytes. */",
+  "	flex_uint32_t th_ssize;  /**< Size of this dataset, in bytes, including header. */",
+  "	flex_uint16_t th_flags;  /**< Currently unused, must be 0 */",
+  "	char   *th_version; /**< Flex version string. NUL terminated. */",
+  "	char   *th_name;    /**< The name of this table set. NUL terminated. */",
+  "};",
+  "",
+  "/** A single serialized table */",
+  "struct yytbl_data {",
+  "	flex_uint16_t td_id;      /**< enum yytbl_id table identifier */",
+  "	flex_uint16_t td_flags;   /**< how to interpret this data */",
+  "	flex_uint32_t td_hilen;   /**< num elements in highest dimension array */",
+  "	flex_uint32_t td_lolen;   /**< num elements in lowest dimension array */",
+  "	void   *td_data;     /**< table data */",
+  "};",
+  "#endif",
+  "",
+  "/** Extract corresponding data size_t from td_flags */",
+  "#ifndef YYTDFLAGS2BYTES",
+  "#define YYTDFLAGS2BYTES(td_flags)\\",
+  "        (((td_flags) & YYTD_DATA8)\\",
+  "            ? sizeof(flex_int8_t)\\",
+  "            :(((td_flags) & YYTD_DATA16)\\",
+  "                ? sizeof(flex_int16_t)\\",
+  "                :sizeof(flex_int32_t)))",
+  "#endif",
+  "",
+  "#ifdef FLEX_SCANNER",
+  "%not-for-header",
+  "#endif",
+  "yyskel_static flex_int32_t yytbl_calc_total_len (const struct yytbl_data *tbl);",
+  "#ifdef FLEX_SCANNER",
+  "%ok-for-header",
+  "#endif",
+  "",
+  "/* vim:set noexpandtab cindent tabstop=8 softtabstop=0 shiftwidth=8 textwidth=0: */",
+  "",
+  "",
+  "/* Load the DFA tables from the given stream.  */",
+  "int yytables_fload M4_YY_PARAMS(FILE * fp M4_YY_PROTO_LAST_ARG);",
+  "",
+  "/* Unload the tables from memory. */",
+  "int yytables_destroy M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG);",
+  "%not-for-header",
+  "",
+  "/** Describes a mapping from a serialized table id to its deserialized state in",
+  " * this scanner.  This is the bridge between our \"generic\" deserialization code",
+  " * and the specifics of this scanner. ",
+  " */",
+  "struct yytbl_dmap {",
+  "	enum yytbl_id dm_id;/**< table identifier */",
+  "	void  **dm_arr;		/**< address of pointer to store the deserialized table. */",
+  "	size_t  dm_sz;		/**< local sizeof() each element in table. */",
+  "};",
+  "",
+  "/** A {0,0,0}-terminated list of structs, forming the map */",
+  "static struct yytbl_dmap yydmap[] =",
+  "{",
+  "%tables-yydmap generated elements",
+  "    {0,0,0}",
+  "};",
+  "",
+  "/** A tables-reader object to maintain some state in the read. */",
+  "struct yytbl_reader {",
+  "    FILE * fp; /**< input stream */",
+  "    flex_uint32_t bread; /**< bytes read since beginning of current tableset */",
+  "};",
+  "",
+  "%endif",
+  "/* end tables serialization structures and prototypes */",
+  "",
+  "%ok-for-header",
+  "",
+  "/* Default declaration of generated scanner - a define so the user can",
+  " * easily add parameters.",
+  " */",
+  "#ifndef YY_DECL",
+  "#define YY_DECL_IS_OURS 1",
+  "%if-c-only Standard (non-C++) definition",
+  "",
+  "",
+  "m4_define( [[M4_YY_LEX_PROTO]], [[M4_YY_PARAMS(M4_YY_PROTO_ONLY_ARG)]])",
+  "m4_define( [[M4_YY_LEX_DECLARATION]], [[YYFARGS0(void)]])",
+  "",
+  "m4_ifdef( [[M4_YY_BISON_LVAL]],",
+  "[[",
+  "    m4_dnl  The bison pure parser is used. Redefine yylex to",
+  "    m4_dnl  accept the lval parameter.",
+  "",
+  "    m4_define( [[M4_YY_LEX_PROTO]], [[\\]]",
+  "               [[M4_YY_PARAMS(YYSTYPE * yylval_param M4_YY_PROTO_LAST_ARG)]])",
+  "    m4_define( [[M4_YY_LEX_DECLARATION]], [[\\]]",
+  "               [[YYFARGS1(YYSTYPE *,yylval_param)]])",
+  "]])",
+  "",
+  "m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "[[",
+  "    m4_dnl  Locations are used. yylex should also accept the ylloc parameter.",
+  "",
+  "    m4_define( [[M4_YY_LEX_PROTO]], [[\\]]",
+  "               [[M4_YY_PARAMS(YYSTYPE * yylval_param, YYLTYPE * yylloc_param M4_YY_PROTO_LAST_ARG)]])",
+  "    m4_define( [[M4_YY_LEX_DECLARATION]], [[\\]]",
+  "               [[YYFARGS2(YYSTYPE *,yylval_param, YYLTYPE *,yylloc_param)]])",
+  "]])",
+  "",
+  "extern int yylex M4_YY_LEX_PROTO;",
+  "",
+  "#define YY_DECL int yylex M4_YY_LEX_DECLARATION",
+  "%endif",
+  "%if-c++-only C++ definition",
+  "#define YY_DECL int yyFlexLexer::yylex()",
+  "%endif",
+  "#endif /* !YY_DECL */",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Code executed at the beginning of each rule, after yytext and yyleng",
+  " * have been set up.",
+  " */",
+  "#ifndef YY_USER_ACTION",
+  "#define YY_USER_ACTION",
+  "#endif",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* Code executed at the end of each rule. */",
+  "#ifndef YY_BREAK",
+  "#define YY_BREAK break;",
+  "#endif",
+  "]])",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "%% [6.0] YY_RULE_SETUP definition goes here",
+  "]])",
+  "",
+  "%not-for-header",
+  "/** The main scanner function which does all the work.",
+  " */",
+  "YY_DECL",
+  "{",
+  "	yy_state_type yy_current_state;",
+  "	char *yy_cp, *yy_bp;",
+  "	int yy_act;",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_REENTRANT]],",
+  "[[",
+  "    m4_ifdef( [[M4_YY_BISON_LVAL]],",
+  "    [[",
+  "        YYSTYPE * yylval;",
+  "    ]])",
+  "    m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "    [[",
+  "        YYLTYPE * yylloc;",
+  "    ]])",
+  "]])",
+  "",
+  "%% [7.0] user's declarations go here",
+  "",
+  "m4_ifdef( [[M4_YY_BISON_LVAL]],",
+  "[[",
+  "    yylval = yylval_param;",
+  "]])",
+  "",
+  "m4_ifdef( [[<M4_YY_BISON_LLOC>]],",
+  "[[",
+  "    yylloc = yylloc_param;",
+  "]])",
+  "",
+  "	if ( !YY_G(yy_init) )",
+  "		{",
+  "		YY_G(yy_init) = 1;",
+  "",
+  "#ifdef YY_USER_INIT",
+  "		YY_USER_INIT;",
+  "#endif",
+  "",
+  "m4_ifdef( [[M4_YY_USES_REJECT]],",
+  "[[",
+  "        /* Create the reject buffer large enough to save one state per allowed character. */",
+  "        if ( ! YY_G(yy_state_buf) )",
+  "            YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  M4_YY_CALL_LAST_ARG);",
+  "            if ( ! YY_G(yy_state_buf) )",
+  "                YY_FATAL_ERROR( \"out of dynamic memory in yylex()\" );",
+  "]])",
+  "",
+  "		if ( ! YY_G(yy_start) )",
+  "			YY_G(yy_start) = 1;	/* first start state */",
+  "",
+  "		if ( ! yyin )",
+  "%if-c-only",
+  "			yyin = stdin;",
+  "%endif",
+  "%if-c++-only",
+  "			yyin = & std::cin;",
+  "%endif",
+  "",
+  "		if ( ! yyout )",
+  "%if-c-only",
+  "			yyout = stdout;",
+  "%endif",
+  "%if-c++-only",
+  "			yyout = & std::cout;",
+  "%endif",
+  "",
+  "		if ( ! YY_CURRENT_BUFFER ) {",
+  "			yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);",
+  "			YY_CURRENT_BUFFER_LVALUE =",
+  "				yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);",
+  "		}",
+  "",
+  "		yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );",
+  "		}",
+  "",
+  "	while ( 1 )		/* loops until end-of-file is reached */",
+  "		{",
+  "%% [8.0] yymore()-related code goes here",
+  "		yy_cp = YY_G(yy_c_buf_p);",
+  "",
+  "		/* Support of yytext. */",
+  "		*yy_cp = YY_G(yy_hold_char);",
+  "",
+  "		/* yy_bp points to the position in yy_ch_buf of the start of",
+  "		 * the current run.",
+  "		 */",
+  "		yy_bp = yy_cp;",
+  "",
+  "%% [9.0] code to set up and find next match goes here",
+  "",
+  "yy_find_action:",
+  "%% [10.0] code to find the action number goes here",
+  "",
+  "		YY_DO_BEFORE_ACTION;",
+  "",
+  "%% [11.0] code for yylineno update goes here",
+  "",
+  "do_action:	/* This label is used only to access EOF actions. */",
+  "",
+  "%% [12.0] debug code goes here",
+  "",
+  "		switch ( yy_act )",
+  "	{ /* beginning of action switch */",
+  "%% [13.0] actions go here",
+  "",
+  "	case YY_END_OF_BUFFER:",
+  "		{",
+  "		/* Amount of text matched not including the EOB char. */",
+  "		int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;",
+  "",
+  "		/* Undo the effects of YY_DO_BEFORE_ACTION. */",
+  "		*yy_cp = YY_G(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 yyin at a new source and called",
+  "			 * yylex().  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_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;",
+  "			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;",
+  "			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_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )",
+  "			{ /* This was really a NUL. */",
+  "			yy_state_type yy_next_state;",
+  "",
+  "			YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;",
+  "",
+  "			yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );",
+  "",
+  "			/* 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 M4_YY_CALL_LAST_ARG);",
+  "",
+  "			yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;",
+  "",
+  "			if ( yy_next_state )",
+  "				{",
+  "				/* Consume the NUL. */",
+  "				yy_cp = ++YY_G(yy_c_buf_p);",
+  "				yy_current_state = yy_next_state;",
+  "				goto yy_match;",
+  "				}",
+  "",
+  "			else",
+  "				{",
+  "%% [14.0] code to do back-up for compressed tables and set up yy_cp goes here",
+  "				goto yy_find_action;",
+  "				}",
+  "			}",
+  "",
+  "		else switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )",
+  "			{",
+  "			case EOB_ACT_END_OF_FILE:",
+  "				{",
+  "				YY_G(yy_did_buffer_switch_on_eof) = 0;",
+  "",
+  "				if ( yywrap( M4_YY_CALL_ONLY_ARG ) )",
+  "					{",
+  "					/* Note: because we've taken care in",
+  "					 * yy_get_next_buffer() to have set up",
+  "					 * yytext, 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_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;",
+  "",
+  "					yy_act = YY_STATE_EOF(YY_START);",
+  "					goto do_action;",
+  "					}",
+  "",
+  "				else",
+  "					{",
+  "					if ( ! YY_G(yy_did_buffer_switch_on_eof) )",
+  "						YY_NEW_FILE;",
+  "					}",
+  "				break;",
+  "				}",
+  "",
+  "			case EOB_ACT_CONTINUE_SCAN:",
+  "				YY_G(yy_c_buf_p) =",
+  "					YY_G(yytext_ptr) + yy_amount_of_matched_text;",
+  "",
+  "				yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );",
+  "",
+  "				yy_cp = YY_G(yy_c_buf_p);",
+  "				yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;",
+  "				goto yy_match;",
+  "",
+  "			case EOB_ACT_LAST_MATCH:",
+  "				YY_G(yy_c_buf_p) =",
+  "				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)];",
+  "",
+  "				yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG );",
+  "",
+  "				yy_cp = YY_G(yy_c_buf_p);",
+  "				yy_bp = YY_G(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 yylex */",
+  "%ok-for-header",
+  "",
+  "%if-c++-only",
+  "%not-for-header",
+  "/* The contents of this function are C++ specific, so the YY_G macro is not used.",
+  " */",
+  "yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )",
+  "{",
+  "	yyin = arg_yyin;",
+  "	yyout = arg_yyout;",
+  "	yy_c_buf_p = 0;",
+  "	yy_init = 0;",
+  "	yy_start = 0;",
+  "	yy_flex_debug = 0;",
+  "	yylineno = 1;	// this will only get updated if %option yylineno",
+  "",
+  "	yy_did_buffer_switch_on_eof = 0;",
+  "",
+  "	yy_looking_for_trail_begin = 0;",
+  "	yy_more_flag = 0;",
+  "	yy_more_len = 0;",
+  "	yy_more_offset = yy_prev_more_offset = 0;",
+  "",
+  "	yy_start_stack_ptr = yy_start_stack_depth = 0;",
+  "	yy_start_stack = NULL;",
+  "",
+  "	yy_buffer_stack = 0;",
+  "	yy_buffer_stack_top = 0;",
+  "	yy_buffer_stack_max = 0;",
+  "",
+  "",
+  "m4_ifdef( [[M4_YY_USES_REJECT]],",
+  "[[",
+  "	yy_state_buf = new yy_state_type[YY_STATE_BUF_SIZE];",
+  "]],",
+  "[[",
+  "	yy_state_buf = 0;",
+  "]])",
+  "}",
+  "",
+  "/* The contents of this function are C++ specific, so the YY_G macro is not used.",
+  " */",
+  "yyFlexLexer::~yyFlexLexer()",
+  "{",
+  "	delete [] yy_state_buf;",
+  "	yyfree( yy_start_stack M4_YY_CALL_LAST_ARG );",
+  "	yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);",
+  "	yyfree( yy_buffer_stack M4_YY_CALL_LAST_ARG );",
+  "}",
+  "",
+  "/* The contents of this function are C++ specific, so the YY_G macro is not used.",
+  " */",
+  "void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )",
+  "{",
+  "	if ( new_in )",
+  "		{",
+  "		yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG);",
+  "		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  M4_YY_CALL_LAST_ARG) M4_YY_CALL_LAST_ARG);",
+  "		}",
+  "",
+  "	if ( new_out )",
+  "		yyout = new_out;",
+  "}",
+  "",
+  "#ifdef YY_INTERACTIVE",
+  "int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )",
+  "#else",
+  "int yyFlexLexer::LexerInput( char* buf, int max_size )",
+  "#endif",
+  "{",
+  "	if ( yyin->eof() || yyin->fail() )",
+  "		return 0;",
+  "",
+  "#ifdef YY_INTERACTIVE",
+  "	yyin->get( buf[0] );",
+  "",
+  "	if ( yyin->eof() )",
+  "		return 0;",
+  "",
+  "	if ( yyin->bad() )",
+  "		return -1;",
+  "",
+  "	return 1;",
+  "",
+  "#else",
+  "	(void) yyin->read( buf, max_size );",
+  "",
+  "	if ( yyin->bad() )",
+  "		return -1;",
+  "	else",
+  "		return yyin->gcount();",
+  "#endif",
+  "}",
+  "",
+  "void yyFlexLexer::LexerOutput( const char* buf, int size )",
+  "{",
+  "	(void) yyout->write( buf, size );",
+  "}",
+  "%ok-for-header",
+  "%endif",
+  "",
+  "m4_ifdef( [[M4_YY_NOT_IN_HEADER]],",
+  "[[",
+  "/* 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",
+  " */",
+  "%if-c-only",
+  "static int yy_get_next_buffer YYFARGS0(void)",
+  "%endif",
+  "%if-c++-only",
+  "int yyFlexLexer::yy_get_next_buffer()",
+  "%endif",
+  "{",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;",
+  "	char *source = YY_G(yytext_ptr);",
+  "	int number_to_move, i;",
+  "	int ret_val;",
+  "",
+  "	if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(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_G(yy_c_buf_p) - YY_G(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_G(yy_c_buf_p) - YY_G(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_G(yy_n_chars) = 0;",
+  "",
+  "	else",
+  "		{",
+  "			yy_size_t 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. */",
+  "m4_ifdef( [[M4_YY_USES_REJECT]],",
+  "[[",
+  "			YY_FATAL_ERROR(",
+  "\"input buffer overflow, can't enlarge buffer because scanner uses REJECT\" );",
+  "]],",
+  "[[",
+  "			/* just a shorter name for the current buffer */",
+  "			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;",
+  "",
+  "			int yy_c_buf_p_offset =",
+  "				(int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);",
+  "",
+  "			if ( b->yy_is_our_buffer )",
+  "				{",
+  "				yy_size_t 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. */",
+  "					yyrealloc( (void *) b->yy_ch_buf,",
+  "							 b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );",
+  "				}",
+  "			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_G(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_G(yy_n_chars), num_to_read );",
+  "",
+  "		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);",
+  "		}",
+  "",
+  "	if ( YY_G(yy_n_chars) == 0 )",
+  "		{",
+  "		if ( number_to_move == YY_MORE_ADJ )",
+  "			{",
+  "			ret_val = EOB_ACT_END_OF_FILE;",
+  "			yyrestart( yyin  M4_YY_CALL_LAST_ARG);",
+  "			}",
+  "",
+  "		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_G(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_G(yy_n_chars) + number_to_move + (YY_G(yy_n_chars) >> 1);",
+  "		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(",
+  "			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size M4_YY_CALL_LAST_ARG );",
+  "		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )",
+  "			YY_FATAL_ERROR( \"out of dynamic memory in yy_get_next_buffer()\" );",
+  "	}",
+  "",
+  "	YY_G(yy_n_chars) += number_to_move;",
+  "	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;",
+  "	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;",
+  "",
+  "	YY_G(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 */",
+  "",
+  "%if-c-only",
+  "%not-for-header",
+  "    static yy_state_type yy_get_previous_state YYFARGS0(void)",
+  "%endif",
+  "%if-c++-only",
+  "    yy_state_type yyFlexLexer::yy_get_previous_state()",
+  "%endif",
+  "{",
+  "	yy_state_type yy_current_state;",
+  "	char *yy_cp;",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "",
+  "%% [15.0] code to get the start state into yy_current_state goes here",
+  "",
+  "	for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )",
+  "		{",
+  "%% [16.0] code to find the next state goes here",
+  "		}",
+  "",
+  "	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 );",
+  " */",
+  "%if-c-only",
+  "    static yy_state_type yy_try_NUL_trans  YYFARGS1( yy_state_type, yy_current_state)",
+  "%endif",
+  "%if-c++-only",
+  "    yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )",
+  "%endif",
+  "{",
+  "	int yy_is_jam;",
+  "    M4_YY_DECL_GUTS_VAR(); /* This var may be unused depending upon options. */",
+  "%% [17.0] code to find the next state, and perhaps do backing up, goes here",
+  "",
+  "	M4_YY_NOOP_GUTS_VAR();",
+  "	return yy_is_jam ? 0 : yy_current_state;",
+  "}",
+  "",
+  "",
+  "%if-c-only",
+  "m4_ifdef( [[M4_YY_NO_UNPUT]],,",
+  "[[",
+  "#ifndef YY_NO_UNPUT",
+  "    static void yyunput YYFARGS2( int,c, char *,yy_bp)",
+  "%endif",
+  "%if-c++-only",
+  "#ifndef YY_NO_UNPUT",
+  "    void yyFlexLexer::yyunput( int c, char* yy_bp)",
+  "%endif",
+  "{",
+  "	char *yy_cp;",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "",
+  "    yy_cp = YY_G(yy_c_buf_p);",
+  "",
+  "	/* undo effects of setting up yytext */",
+  "	*yy_cp = YY_G(yy_hold_char);",
+  "",
+  "	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )",
+  "		{ /* need to shift things up to make room */",
+  "		/* +2 for EOB chars. */",
+  "		yy_size_t number_to_move = YY_G(yy_n_chars) + 2;",
+  "		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[",
+  "					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];",
+  "		char *source =",
+  "				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];",
+  "",
+  "		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )",
+  "			*--dest = *--source;",
+  "",
+  "		yy_cp += (int) (dest - source);",
+  "		yy_bp += (int) (dest - source);",
+  "		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =",
+  "			YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;",
+  "",
+  "		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )",
+  "			YY_FATAL_ERROR( \"flex scanner push-back overflow\" );",
+  "		}",
+  "",
+  "	*--yy_cp = (char) c;",
+  "",
+  "%% [18.0] update yylineno here",
+  "m4_ifdef( [[M4_YY_USE_LINENO]],",
+  "[[",
+  "    if ( c == '\\n' ){",
+  "        --yylineno;",
+  "    }",
+  "]])",
+  "",
+  "	YY_G(yytext_ptr) = yy_bp;",
+  "	YY_G(yy_hold_char) = *yy_cp;",
+  "	YY_G(yy_c_buf_p) = yy_cp;",
+  "}",
+  "#endif	/* ifndef YY_NO_UNPUT */",
+  "%if-c-only",
+  "]])",
+  "%endif",
+  "",
+  "%if-c-only",
+  "#ifndef YY_NO_INPUT",
+  "#ifdef __cplusplus",
+  "    static int yyinput YYFARGS0(void)",
+  "#else",
+  "    static int input  YYFARGS0(void)",
+  "#endif",
+  "",
+  "%endif",
+  "%if-c++-only",
+  "    int yyFlexLexer::yyinput()",
+  "%endif",
+  "{",
+  "	int c;",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "",
+  "	*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);",
+  "",
+  "	if ( *YY_G(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_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )",
+  "			/* This was really a NUL. */",
+  "			*YY_G(yy_c_buf_p) = '\\0';",
+  "",
+  "		else",
+  "			{ /* need more input */",
+  "			yy_size_t offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);",
+  "			++YY_G(yy_c_buf_p);",
+  "",
+  "			switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) )",
+  "				{",
+  "				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. */",
+  "					yyrestart( yyin M4_YY_CALL_LAST_ARG);",
+  "",
+  "					/*FALLTHROUGH*/",
+  "",
+  "				case EOB_ACT_END_OF_FILE:",
+  "					{",
+  "					if ( yywrap( M4_YY_CALL_ONLY_ARG ) )",
+  "						return EOF;",
+  "",
+  "					if ( ! YY_G(yy_did_buffer_switch_on_eof) )",
+  "						YY_NEW_FILE;",
+  "#ifdef __cplusplus",
+  "					return yyinput(M4_YY_CALL_ONLY_ARG);",
+  "#else",
+  "					return input(M4_YY_CALL_ONLY_ARG);",
+  "#endif",
+  "					}",
+  "",
+  "				case EOB_ACT_CONTINUE_SCAN:",
+  "					YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;",
+  "					break;",
+  "				}",
+  "			}",
+  "		}",
+  "",
+  "	c = *(unsigned char *) YY_G(yy_c_buf_p);	/* cast for 8-bit char's */",
+  "	*YY_G(yy_c_buf_p) = '\\0';	/* preserve yytext */",
+  "	YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);",
+  "",
+  "%% [19.0] update BOL and yylineno",
+  "",
+  "	return c;",
+  "}",
+  "%if-c-only",
+  "#endif	/* ifndef YY_NO_INPUT */",
+  "%endif",
+  "",
+  "/** Immediately switch to a different input stream.",
+  " * @param input_file A readable stream.",
+  " * M4_YY_DOC_PARAM",
+  " * @note This function does not reset the start condition to @c INITIAL .",
+  " */",
+  "%if-c-only",
+  "    void yyrestart  YYFARGS1( FILE *,input_file)",
+  "%endif",
+  "%if-c++-only",
+  "    void yyFlexLexer::yyrestart( std::istream* input_file )",
+  "%endif",
+  "{",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "",
+  "	if ( ! YY_CURRENT_BUFFER ){",
+  "        yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);",
+  "		YY_CURRENT_BUFFER_LVALUE =",
+  "            yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG);",
+  "	}",
+  "",
+  "	yy_init_buffer( YY_CURRENT_BUFFER, input_file M4_YY_CALL_LAST_ARG);",
+  "	yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );",
+  "}",
+  "",
+  "/** Switch to a different input buffer.",
+  " * @param new_buffer The new input buffer.",
+  " * M4_YY_DOC_PARAM",
+  " */",
+  "%if-c-only",
+  "    void yy_switch_to_buffer  YYFARGS1( YY_BUFFER_STATE ,new_buffer)",
+  "%endif",
+  "%if-c++-only",
+  "    void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
+  "%endif",
+  "{",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "",
+  "	/* TODO. We should be able to replace this entire function body",
+  "	 * with",
+  "	 *		yypop_buffer_state();",
+  "	 *		yypush_buffer_state(new_buffer);",
+  "     */",
+  "	yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG);",
+  "	if ( YY_CURRENT_BUFFER == new_buffer )",
+  "		return;",
+  "",
+  "	if ( YY_CURRENT_BUFFER )",
+  "		{",
+  "		/* Flush out information for old buffer. */",
+  "		*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);",
+  "		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);",
+  "		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);",
+  "		}",
+  "",
+  "	YY_CURRENT_BUFFER_LVALUE = new_buffer;",
+  "	yy_load_buffer_state( M4_YY_CALL_ONLY_ARG );",
+  "",
+  "	/* We don't actually know whether we did this switch during",
+  "	 * EOF (yywrap()) processing, but the only time this flag",
+  "	 * is looked at is after yywrap() is called, so it's safe",
+  "	 * to go ahead and always set it.",
+  "	 */",
+  "	YY_G(yy_did_buffer_switch_on_eof) = 1;",
+  "}",
+  "",
+  "",
+  "%if-c-only",
+  "static void yy_load_buffer_state  YYFARGS0(void)",
+  "%endif",
+  "%if-c++-only",
+  "    void yyFlexLexer::yy_load_buffer_state()",
+  "%endif",
+  "{",
+  "    M4_YY_DECL_GUTS_VAR();",
+  "	YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;",
+  "	YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;",
+  "	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;",
+  "	YY_G(yy_hold_char) = *YY_G(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.",
+  " * M4_YY_DOC_PARAM",
+  " * @return the allocated buffer state.",
+  " */",
+  "%if-c-only",
+  "    YY_BUFFER_STATE yy_create_buffer  YYFARGS2( FILE *,file, int ,size)",
+  "%endif",
+  "%if-c++-only",
+  "    YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )",
+  "%endif",
+  "{",
+  "	YY_BUFFER_STATE b;",
+  "    m4_dnl M4_YY_DECL_GUTS_VAR();",
+  "",
+  "	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG );",
+  "	if ( ! b )",
+  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_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 *) yyalloc( b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG );",
+  "	if ( ! b->yy_ch_buf )",
+  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
+  "",
+  "	b->yy_is_our_buffer = 1;",
+  "",
+  "	yy_init_buffer( b, file M4_YY_CALL_LAST_ARG);",
+  "",