"%% 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",  " */",  "",  "%-",  "static int yy_get_next_buffer()",  "%+",  "int yyFlexLexer::yy_get_next_buffer()",  "%*",  "	{",  "	register char *dest = yy_current_buffer->yy_ch_buf;",  "	register char *source = yytext_ptr;",  "	register int number_to_move, i;",  "	int ret_val;",  "",  "	if ( yy_c_buf_p > &yy_current_buffer->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 */",  "",  "%-",  "static yy_state_type yy_get_previous_state()",  "%+",  "yy_state_type yyFlexLexer::yy_get_previous_state()",  "%*",  "	{",  "	register yy_state_type yy_current_state;",  "	register 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 )",  "%*",  "	{",  "	register 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, register char *yy_bp )",  "#else",  "static void yyunput( c, yy_bp )",  "int c;",  "register char *yy_bp;",  "#endif",  "%+",  "void yyFlexLexer::yyunput( int c, register char* yy_bp )",  "%*",  "	{",  "	register 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. */",  "		register int number_to_move = yy_n_chars + 2;",  "		register char *dest = &yy_current_buffer->yy_ch_buf[",  "					yy_current_buffer->yy_buf_size + 2];",  "		register 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 */",  "%*",  "",  "",  "%-",  "#ifdef __cplusplus",  "static int yyinput()",  "#else",  "static int input()",  "#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();",