Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/RenderSystems/GL/src/nvparse/_rc1.0_lexer.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 18 years ago

File size: 64.2 KB

Rev	Line
[1]	1	#define yy_create_buffer rc10__create_buffer
	2	#define yy_delete_buffer rc10__delete_buffer
	3	#define yy_scan_buffer rc10__scan_buffer
	4	#define yy_scan_string rc10__scan_string
	5	#define yy_scan_bytes rc10__scan_bytes
	6	#define yy_flex_debug rc10__flex_debug
	7	#define yy_init_buffer rc10__init_buffer
	8	#define yy_flush_buffer rc10__flush_buffer
	9	#define yy_load_buffer_state rc10__load_buffer_state
	10	#define yy_switch_to_buffer rc10__switch_to_buffer
	11	#define yyin rc10_in
	12	#define yyleng rc10_leng
	13	#define yylex rc10_lex
	14	#define yyout rc10_out
	15	#define yyrestart rc10_restart
	16	#define yytext rc10_text
	17	#define yywrap rc10_wrap
	18
	19	#line 20 "_rc1.0_lexer.cpp"
	20	/* A lexical scanner generated by flex */
	21
	22	/* Scanner skeleton version:
	23	* $Header: /cvsroot/ogre/ogrenew/RenderSystems/GL/src/nvparse/_rc1.0_lexer.cpp,v 1.5 2005/07/08 16:51:23 miathan6 Exp $
	24	*/
	25
	26	#define FLEX_SCANNER
	27	#define YY_FLEX_MAJOR_VERSION 2
	28	#define YY_FLEX_MINOR_VERSION 5
	29
	30	#include <stdio.h>
	31	#include <unistd.h>
	32
	33
	34	/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
	35	#ifdef c_plusplus
	36	#ifndef __cplusplus
	37	#define __cplusplus
	38	#endif
	39	#endif
	40
	41
	42	#ifdef __cplusplus
	43
	44	#include <stdlib.h>
	45
	46	/* Use prototypes in function declarations. */
	47	#define YY_USE_PROTOS
	48
	49	/* The "const" storage-class-modifier is valid. */
	50	#define YY_USE_CONST
	51
	52	#else /* ! __cplusplus */
	53
	54	#if __STDC__
	55
	56	#define YY_USE_PROTOS
	57	#define YY_USE_CONST
	58
	59	#endif /* __STDC__ */
	60	#endif /* ! __cplusplus */
	61
	62	#ifdef __TURBOC__
	63	#pragma warn -rch
	64	#pragma warn -use
	65	#include <io.h>
	66	#include <stdlib.h>
	67	#define YY_USE_CONST
	68	#define YY_USE_PROTOS
	69	#endif
	70
	71	#ifdef YY_USE_CONST
	72	#define yyconst const
	73	#else
	74	#define yyconst
	75	#endif
	76
	77
	78	#ifdef YY_USE_PROTOS
	79	#define YY_PROTO(proto) proto
	80	#else
	81	#define YY_PROTO(proto) ()
	82	#endif
	83
	84	/* Returned upon end-of-file. */
	85	#define YY_NULL 0
	86
	87	/* Promotes a possibly negative, possibly signed char to an unsigned
	88	* integer for use as an array index. If the signed char is negative,
	89	* we want to instead treat it as an 8-bit unsigned char, hence the
	90	* double cast.
	91	*/
	92	#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
	93
	94	/* Enter a start condition. This macro really ought to take a parameter,
	95	* but we do it the disgusting crufty way forced on us by the ()-less
	96	* definition of BEGIN.
	97	*/
	98	#define BEGIN yy_start = 1 + 2 *
	99
	100	/* Translate the current start state into a value that can be later handed
	101	* to BEGIN to return to the state. The YYSTATE alias is for lex
	102	* compatibility.
	103	*/
	104	#define YY_START ((yy_start - 1) / 2)
	105	#define YYSTATE YY_START
	106
	107	/* Action number for EOF rule of a given start state. */
	108	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
	109
	110	/* Special action meaning "start processing a new file". */
	111	#define YY_NEW_FILE yyrestart( yyin )
	112
	113	#define YY_END_OF_BUFFER_CHAR 0
	114
	115	/* Size of default input buffer. */
	116	#define YY_BUF_SIZE 16384
	117
	118	typedef struct yy_buffer_state *YY_BUFFER_STATE;
	119
	120	extern int yyleng;
	121	extern FILE yyin, yyout;
	122
	123	#define EOB_ACT_CONTINUE_SCAN 0
	124	#define EOB_ACT_END_OF_FILE 1
	125	#define EOB_ACT_LAST_MATCH 2
	126
	127	/* The funky do-while in the following #define is used to turn the definition
	128	* int a single C statement (which needs a semi-colon terminator). This
	129	* avoids problems with code like:
	130	*
	131	* if ( condition_holds )
	132	* yyless( 5 );
	133	* else
	134	* do_something_else();
	135	*
	136	* Prior to using the do-while the compiler would get upset at the
	137	* "else" because it interpreted the "if" statement as being all
	138	* done when it reached the ';' after the yyless() call.
	139	*/
	140
	141	/* Return all but the first 'n' matched characters back to the input stream. */
	142
	143	#define yyless(n) \
	144	do \
	145	{ \
	146	/* Undo effects of setting up yytext. */ \
	147	*yy_cp = yy_hold_char; \
	148	YY_RESTORE_YY_MORE_OFFSET \
	149	yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
	150	YY_DO_BEFORE_ACTION; /* set up yytext again */ \
	151	} \
	152	while ( 0 )
	153
	154	#define unput(c) yyunput( c, yytext_ptr )
	155
	156	/* The following is because we cannot portably get our hands on size_t
	157	* (without autoconf's help, which isn't available because we want
	158	* flex-generated scanners to compile on their own).
	159	*/
	160	typedef unsigned int yy_size_t;
	161
	162
	163	struct yy_buffer_state
	164	{
	165	FILE *yy_input_file;
	166
	167	char yy_ch_buf; / input buffer */
	168	char yy_buf_pos; / current position in input buffer */
	169
	170	/* Size of input buffer in bytes, not including room for EOB
	171	* characters.
	172	*/
	173	yy_size_t yy_buf_size;
	174
	175	/* Number of characters read into yy_ch_buf, not including EOB
	176	* characters.
	177	*/
	178	int yy_n_chars;
	179
	180	/* Whether we "own" the buffer - i.e., we know we created it,
	181	* and can realloc() it to grow it, and should free() it to
	182	* delete it.
	183	*/
	184	int yy_is_our_buffer;
	185
	186	/* Whether this is an "interactive" input source; if so, and
	187	* if we're using stdio for input, then we want to use getc()
	188	* instead of fread(), to make sure we stop fetching input after
	189	* each newline.
	190	*/
	191	int yy_is_interactive;
	192
	193	/* Whether we're considered to be at the beginning of a line.
	194	* If so, '^' rules will be active on the next match, otherwise
	195	* not.
	196	*/
	197	int yy_at_bol;
	198
	199	/* Whether to try to fill the input buffer when we reach the
	200	* end of it.
	201	*/
	202	int yy_fill_buffer;
	203
	204	int yy_buffer_status;
	205	#define YY_BUFFER_NEW 0
	206	#define YY_BUFFER_NORMAL 1
	207	/* When an EOF's been seen but there's still some text to process
	208	* then we mark the buffer as YY_EOF_PENDING, to indicate that we
	209	* shouldn't try reading from the input source any more. We might
	210	* still have a bunch of tokens to match, though, because of
	211	* possible backing-up.
	212	*
	213	* When we actually see the EOF, we change the status to "new"
	214	* (via yyrestart()), so that the user can continue scanning by
	215	* just pointing yyin at a new input file.
	216	*/
	217	#define YY_BUFFER_EOF_PENDING 2
	218	};
	219
	220	static YY_BUFFER_STATE yy_current_buffer = 0;
	221
	222	/* We provide macros for accessing buffer states in case in the
	223	* future we want to put the buffer states in a more general
	224	* "scanner state".
	225	*/
	226	#define YY_CURRENT_BUFFER yy_current_buffer
	227
	228
	229	/* yy_hold_char holds the character lost when yytext is formed. */
	230	static char yy_hold_char;
	231
	232	static int yy_n_chars; /* number of characters read into yy_ch_buf */
	233
	234
	235	int yyleng;
	236
	237	/* Points to current character in buffer. */
	238	static char yy_c_buf_p = (char ) 0;
	239	static int yy_init = 1; /* whether we need to initialize */
	240	static int yy_start = 0; /* start state number */
	241
	242	/* Flag which is used to allow yywrap()'s to do buffer switches
	243	* instead of setting up a fresh yyin. A bit of a hack ...
	244	*/
	245	static int yy_did_buffer_switch_on_eof;
	246
	247	void yyrestart YY_PROTO(( FILE *input_file ));
	248
	249	void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
	250	void yy_load_buffer_state YY_PROTO(( void ));
	251	YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
	252	void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
	253	void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
	254	void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
	255	#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
	256
	257	YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
	258	YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
	259	YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
	260
	261	static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
	262	static void yy_flex_realloc YY_PROTO(( void , yy_size_t ));
	263	static void yy_flex_free YY_PROTO(( void * ));
	264
	265	#define yy_new_buffer yy_create_buffer
	266
	267	#define yy_set_interactive(is_interactive) \
	268	{ \
	269	if ( ! yy_current_buffer ) \
	270	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
	271	yy_current_buffer->yy_is_interactive = is_interactive; \
	272	}
	273
	274	#define yy_set_bol(at_bol) \
	275	{ \
	276	if ( ! yy_current_buffer ) \
	277	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
	278	yy_current_buffer->yy_at_bol = at_bol; \
	279	}
	280
	281	#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
	282
	283	typedef unsigned char YY_CHAR;
	284	FILE yyin = (FILE ) 0, yyout = (FILE ) 0;
	285	typedef int yy_state_type;
	286	extern char *yytext;
	287	#define yytext_ptr yytext
	288
	289	static yy_state_type yy_get_previous_state YY_PROTO(( void ));
	290	static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
	291	static int yy_get_next_buffer YY_PROTO(( void ));
	292	static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
	293
	294	/* Done after the current pattern has been matched and before the
	295	* corresponding action - sets up yytext.
	296	*/
	297	#define YY_DO_BEFORE_ACTION \
	298	yytext_ptr = yy_bp; \
	299	yyleng = (int) (yy_cp - yy_bp); \
	300	yy_hold_char = *yy_cp; \
	301	*yy_cp = '\0'; \
	302	yy_c_buf_p = yy_cp;
	303
	304	#define YY_NUM_RULES 94
	305	#define YY_END_OF_BUFFER 95
	306	static yyconst short int yy_accept[309] =
	307	{ 0,
	308	0, 0, 95, 94, 92, 91, 94, 94, 3, 82,
	309	83, 87, 89, 85, 88, 86, 94, 79, 84, 90,
	310	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
	311	93, 93, 93, 93, 93, 93, 80, 81, 92, 91,
	312	0, 0, 0, 79, 78, 1, 2, 77, 79, 93,
	313	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
	314	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
	315	0, 77, 93, 93, 93, 93, 93, 93, 93, 93,
	316	8, 93, 93, 66, 56, 93, 68, 93, 93, 67,
	317	93, 93, 93, 0, 93, 93, 93, 12, 16, 93,
	318
	319	93, 93, 93, 93, 0, 93, 71, 0, 0, 93,
	320	93, 28, 32, 36, 40, 93, 52, 0, 69, 93,
	321	93, 0, 0, 93, 93, 93, 93, 93, 6, 7,
	322	0, 93, 54, 55, 0, 59, 0, 93, 93, 0,
	323	0, 0, 0, 93, 0, 0, 93, 93, 10, 11,
	324	0, 14, 15, 0, 93, 44, 48, 93, 62, 93,
	325	0, 93, 0, 0, 93, 20, 24, 26, 27, 0,
	326	30, 31, 0, 34, 35, 0, 38, 39, 0, 93,
	327	50, 51, 0, 4, 93, 93, 0, 0, 93, 0,
	328	0, 57, 93, 5, 93, 53, 58, 93, 0, 0,
	329
	330	0, 0, 0, 0, 93, 0, 93, 93, 9, 13,
	331	93, 42, 43, 0, 46, 47, 0, 93, 93, 93,
	332	18, 19, 0, 22, 23, 0, 25, 29, 33, 37,
	333	64, 49, 93, 93, 61, 0, 0, 93, 63, 93,
	334	0, 0, 93, 93, 93, 41, 45, 93, 93, 93,
	335	93, 17, 21, 93, 93, 93, 93, 93, 93, 93,
	336	93, 93, 93, 93, 93, 93, 75, 93, 93, 93,
	337	60, 76, 93, 93, 93, 93, 93, 93, 93, 70,
	338	93, 65, 93, 93, 93, 74, 93, 93, 93, 93,
	339	93, 93, 93, 73, 93, 93, 93, 93, 93, 93,
	340
	341	93, 93, 93, 93, 93, 93, 72, 0
	342	} ;
	343
	344	static yyconst int yy_ec[256] =
	345	{ 0,
	346	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
	347	1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
	348	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	349	1, 2, 5, 1, 6, 1, 1, 1, 1, 7,
	350	8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	351	18, 19, 19, 19, 19, 19, 19, 1, 20, 1,
	352	21, 1, 1, 1, 22, 22, 23, 22, 22, 22,
	353	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
	354	22, 24, 22, 22, 22, 22, 22, 22, 22, 22,
	355	1, 1, 1, 1, 25, 1, 26, 27, 28, 29,
	356
	357	30, 31, 32, 33, 34, 22, 22, 35, 36, 37,
	358	38, 39, 22, 40, 41, 42, 43, 44, 45, 46,
	359	47, 48, 49, 1, 50, 1, 1, 1, 1, 1,
	360	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	361	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	362	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	363	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	364	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	365	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	366	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	367
	368	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	369	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	370	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	371	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	372	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	373	1, 1, 1, 1, 1
	374	} ;
	375
	376	static yyconst int yy_meta[51] =
	377	{ 0,
	378	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	379	1, 1, 2, 1, 2, 2, 2, 2, 2, 1,
	380	1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	381	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	382	2, 2, 2, 2, 2, 2, 2, 2, 1, 1
	383	} ;
	384
	385	static yyconst short int yy_base[310] =
	386	{ 0,
	387	0, 0, 543, 544, 540, 544, 48, 536, 544, 544,
	388	544, 544, 40, 544, 47, 52, 63, 63, 544, 544,
	389	527, 48, 41, 60, 71, 61, 72, 73, 74, 75,
	390	76, 77, 83, 78, 79, 84, 544, 544, 537, 544,
	391	90, 514, 112, 119, 124, 544, 544, 129, 136, 524,
	392	111, 89, 99, 143, 120, 144, 145, 88, 146, 147,
	393	149, 87, 150, 152, 151, 158, 153, 154, 155, 157,
	394	513, 157, 90, 172, 173, 178, 177, 175, 185, 186,
	395	522, 188, 189, 521, 520, 519, 518, 191, 192, 517,
	396	207, 193, 195, 513, 204, 216, 197, 515, 514, 194,
	397
	398	201, 218, 202, 222, 211, 227, 513, 219, 216, 234,
	399	235, 512, 511, 510, 509, 236, 508, 507, 506, 240,
	400	237, 234, 243, 241, 260, 242, 250, 259, 544, 544,
	401	486, 258, 544, 544, 485, 544, 484, 264, 265, 260,
	402	264, 266, 268, 275, 270, 500, 285, 286, 544, 544,
	403	482, 544, 544, 481, 288, 499, 498, 289, 497, 292,
	404	482, 290, 481, 480, 294, 493, 492, 544, 544, 472,
	405	544, 544, 471, 544, 544, 470, 544, 544, 469, 296,
	406	544, 544, 468, 544, 298, 300, 472, 471, 302, 290,
	407	293, 484, 309, 544, 314, 544, 544, 312, 308, 310,
	408
	409	469, 465, 464, 463, 315, 461, 326, 329, 544, 544,
	410	330, 544, 544, 455, 544, 544, 454, 333, 328, 340,
	411	544, 544, 453, 544, 544, 452, 544, 544, 544, 544,
	412	342, 544, 338, 334, 470, 455, 454, 341, 467, 343,
	413	452, 451, 339, 344, 347, 544, 544, 345, 348, 362,
	414	349, 544, 544, 364, 365, 367, 369, 366, 370, 376,
	415	371, 377, 380, 382, 383, 385, 464, 390, 391, 389,
	416	463, 460, 393, 394, 392, 395, 403, 398, 400, 457,
	417	404, 245, 420, 415, 399, 208, 405, 414, 422, 425,
	418	428, 430, 435, 436, 409, 439, 438, 440, 442, 443,
	419
	420	444, 446, 449, 447, 450, 456, 156, 544, 119
	421	} ;
	422
	423	static yyconst short int yy_def[310] =
	424	{ 0,
	425	308, 1, 308, 308, 308, 308, 308, 308, 308, 308,
	426	308, 308, 308, 308, 308, 308, 308, 309, 308, 308,
	427	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	428	309, 309, 309, 309, 309, 309, 308, 308, 308, 308,
	429	308, 308, 308, 308, 308, 308, 308, 308, 309, 309,
	430	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	431	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	432	308, 308, 309, 309, 309, 309, 309, 309, 309, 309,
	433	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	434	309, 309, 309, 308, 309, 309, 309, 309, 309, 309,
	435
	436	309, 309, 309, 309, 308, 309, 309, 308, 308, 309,
	437	309, 309, 309, 309, 309, 309, 309, 308, 309, 309,
	438	309, 308, 308, 309, 309, 309, 309, 309, 308, 308,
	439	308, 309, 308, 308, 308, 308, 308, 309, 309, 308,
	440	308, 308, 308, 309, 308, 308, 309, 309, 308, 308,
	441	308, 308, 308, 308, 309, 309, 309, 309, 309, 309,
	442	308, 309, 308, 308, 309, 309, 309, 308, 308, 308,
	443	308, 308, 308, 308, 308, 308, 308, 308, 308, 309,
	444	308, 308, 308, 308, 309, 309, 308, 308, 309, 308,
	445	308, 309, 309, 308, 309, 308, 308, 309, 308, 308,
	446
	447	308, 308, 308, 308, 309, 308, 309, 309, 308, 308,
	448	309, 308, 308, 308, 308, 308, 308, 309, 309, 309,
	449	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	450	309, 308, 309, 309, 309, 308, 308, 309, 309, 309,
	451	308, 308, 309, 309, 309, 308, 308, 309, 309, 309,
	452	309, 308, 308, 309, 309, 309, 309, 309, 309, 309,
	453	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	454	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	455	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	456	309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
	457
	458	309, 309, 309, 309, 309, 309, 309, 0, 308
	459	} ;
	460
	461	static yyconst short int yy_nxt[595] =
	462	{ 0,
	463	4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	464	14, 15, 16, 17, 18, 18, 18, 18, 18, 19,
	465	20, 21, 21, 21, 21, 22, 23, 24, 25, 26,
	466	27, 21, 28, 21, 29, 30, 21, 31, 21, 32,
	467	33, 34, 35, 21, 21, 21, 21, 36, 37, 38,
	468	40, 41, 43, 308, 44, 44, 44, 44, 44, 43,
	469	308, 44, 44, 44, 44, 44, 45, 45, 45, 45,
	470	45, 46, 308, 308, 52, 48, 47, 49, 49, 49,
	471	49, 49, 51, 308, 308, 308, 308, 308, 308, 308,
	472	308, 308, 40, 41, 53, 308, 308, 54, 59, 308,
	473
	474	308, 308, 308, 60, 55, 57, 56, 68, 64, 58,
	475	65, 308, 62, 70, 74, 69, 85, 61, 63, 81,
	476	50, 66, 95, 308, 75, 67, 45, 45, 45, 45,
	477	45, 48, 308, 44, 44, 44, 44, 44, 45, 45,
	478	45, 45, 45, 72, 72, 72, 72, 72, 48, 73,
	479	49, 49, 49, 49, 49, 308, 308, 308, 308, 308,
	480	78, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	481	308, 72, 72, 72, 72, 72, 88, 76, 87, 77,
	482	82, 80, 79, 89, 308, 308, 83, 308, 90, 308,
	483	308, 86, 98, 99, 84, 92, 93, 308, 308, 91,
	484
	485	308, 308, 102, 308, 308, 308, 308, 308, 97, 308,
	486	103, 104, 96, 308, 308, 100, 308, 101, 106, 308,
	487	308, 112, 113, 114, 115, 110, 116, 107, 308, 119,
	488	308, 111, 117, 124, 308, 121, 129, 130, 127, 308,
	489	120, 136, 125, 126, 133, 134, 308, 308, 308, 308,
	490	131, 132, 308, 308, 308, 137, 128, 308, 135, 149,
	491	150, 148, 308, 138, 139, 155, 147, 144, 152, 153,
	492	308, 308, 308, 151, 156, 157, 308, 308, 159, 166,
	493	167, 158, 154, 160, 162, 168, 169, 308, 165, 171,
	494	172, 174, 175, 177, 178, 181, 182, 308, 308, 170,
	495
	496	308, 308, 308, 173, 308, 176, 308, 179, 308, 183,
	497	308, 180, 308, 186, 308, 212, 213, 192, 215, 216,
	498	198, 308, 207, 195, 308, 205, 308, 308, 189, 214,
	499	193, 185, 217, 221, 222, 224, 225, 208, 308, 219,
	500	308, 308, 308, 231, 211, 308, 308, 223, 218, 226,
	501	308, 308, 308, 308, 308, 308, 308, 308, 220, 308,
	502	308, 308, 233, 234, 240, 235, 243, 244, 239, 248,
	503	238, 245, 254, 249, 308, 255, 308, 308, 308, 308,
	504	250, 308, 308, 308, 251, 258, 256, 257, 308, 308,
	505	262, 263, 308, 260, 308, 308, 264, 308, 259, 266,
	506
	507	261, 308, 308, 308, 308, 308, 308, 308, 265, 273,
	508	308, 308, 308, 267, 268, 308, 308, 308, 269, 274,
	509	270, 308, 272, 271, 275, 277, 308, 308, 281, 283,
	510	280, 276, 308, 278, 308, 279, 287, 308, 284, 282,
	511	308, 288, 308, 289, 285, 286, 290, 308, 308, 296,
	512	308, 308, 308, 292, 308, 308, 308, 291, 308, 308,
	513	295, 308, 308, 298, 293, 294, 297, 301, 308, 308,
	514	302, 300, 308, 304, 299, 308, 308, 253, 252, 308,
	515	247, 246, 308, 242, 241, 237, 236, 232, 305, 230,
	516	229, 228, 303, 307, 306, 227, 308, 210, 209, 206,
	517
	518	204, 203, 202, 201, 200, 199, 197, 196, 194, 308,
	519	191, 190, 188, 187, 184, 164, 163, 161, 308, 146,
	520	145, 143, 142, 141, 140, 308, 123, 122, 118, 308,
	521	308, 109, 108, 308, 105, 94, 308, 71, 39, 308,
	522	42, 39, 308, 3, 308, 308, 308, 308, 308, 308,
	523	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	524	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	525	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	526	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	527	308, 308, 308, 308
	528
	529	} ;
	530
	531	static yyconst short int yy_chk[595] =
	532	{ 0,
	533	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	534	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	535	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	536	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	537	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	538	7, 7, 13, 23, 13, 13, 13, 13, 13, 15,
	539	22, 15, 15, 15, 15, 15, 16, 16, 16, 16,
	540	16, 17, 24, 26, 23, 18, 17, 18, 18, 18,
	541	18, 18, 22, 25, 27, 28, 29, 30, 31, 32,
	542	34, 35, 41, 41, 24, 33, 36, 24, 28, 62,
	543
	544	58, 52, 73, 29, 25, 27, 26, 34, 32, 27,
	545	33, 53, 31, 36, 52, 35, 62, 30, 31, 58,
	546	309, 33, 73, 51, 53, 33, 43, 43, 43, 43,
	547	43, 44, 55, 44, 44, 44, 44, 44, 45, 45,
	548	45, 45, 45, 48, 48, 48, 48, 48, 49, 51,
	549	49, 49, 49, 49, 49, 54, 56, 57, 59, 60,
	550	55, 61, 63, 65, 64, 67, 68, 69, 307, 70,
	551	66, 72, 72, 72, 72, 72, 65, 54, 64, 54,
	552	59, 57, 56, 66, 74, 75, 60, 78, 67, 77,
	553	76, 63, 76, 76, 61, 69, 70, 79, 80, 68,
	554
	555	82, 83, 78, 88, 89, 92, 100, 93, 75, 97,
	556	79, 80, 74, 101, 103, 76, 95, 77, 82, 91,
	557	286, 91, 91, 91, 91, 88, 92, 83, 96, 95,
	558	102, 89, 93, 100, 104, 97, 105, 105, 103, 106,
	559	96, 109, 101, 102, 108, 108, 110, 111, 116, 121,
	560	105, 106, 120, 124, 126, 109, 104, 282, 108, 122,
	561	122, 121, 127, 110, 111, 124, 120, 116, 123, 123,
	562	132, 128, 125, 122, 125, 125, 138, 139, 127, 139,
	563	139, 126, 123, 128, 132, 140, 140, 144, 138, 141,
	564	141, 142, 142, 143, 143, 145, 145, 147, 148, 140,
	565
	566	155, 158, 162, 141, 160, 142, 165, 143, 180, 145,
	567	185, 144, 186, 148, 189, 190, 190, 158, 191, 191,
	568	165, 193, 185, 162, 198, 180, 195, 205, 155, 190,
	569	160, 147, 191, 199, 199, 200, 200, 186, 207, 195,
	570	219, 208, 211, 205, 189, 218, 234, 199, 193, 200,
	571	233, 243, 220, 238, 231, 240, 244, 248, 198, 245,
	572	249, 251, 207, 208, 220, 211, 231, 233, 219, 238,
	573	218, 234, 243, 240, 250, 244, 254, 255, 258, 256,
	574	240, 257, 259, 261, 240, 249, 245, 248, 260, 262,
	575	255, 256, 263, 251, 264, 265, 257, 266, 250, 259,
	576
	577	254, 270, 268, 269, 275, 273, 274, 276, 258, 266,
	578	278, 285, 279, 260, 261, 277, 281, 287, 262, 268,
	579	263, 295, 265, 264, 269, 273, 288, 284, 277, 279,
	580	276, 270, 283, 274, 289, 275, 285, 290, 281, 278,
	581	291, 287, 292, 288, 283, 284, 289, 293, 294, 295,
	582	297, 296, 298, 291, 299, 300, 301, 290, 302, 304,
	583	294, 303, 305, 297, 292, 293, 296, 300, 306, 280,
	584	301, 299, 272, 303, 298, 271, 267, 242, 241, 239,
	585	237, 236, 235, 226, 223, 217, 214, 206, 304, 204,
	586	203, 202, 302, 306, 305, 201, 192, 188, 187, 183,
	587
	588	179, 176, 173, 170, 167, 166, 164, 163, 161, 159,
	589	157, 156, 154, 151, 146, 137, 135, 131, 119, 118,
	590	117, 115, 114, 113, 112, 107, 99, 98, 94, 90,
	591	87, 86, 85, 84, 81, 71, 50, 42, 39, 21,
	592	8, 5, 3, 308, 308, 308, 308, 308, 308, 308,
	593	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	594	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	595	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	596	308, 308, 308, 308, 308, 308, 308, 308, 308, 308,
	597	308, 308, 308, 308
	598
	599	} ;
	600
	601	static yy_state_type yy_last_accepting_state;
	602	static char *yy_last_accepting_cpos;
	603
	604	/* The intent behind this definition is that it'll catch
	605	* any uses of REJECT which flex missed.
	606	*/
	607	#define REJECT reject_used_but_not_detected
	608	#define yymore() yymore_used_but_not_detected
	609	#define YY_MORE_ADJ 0
	610	#define YY_RESTORE_YY_MORE_OFFSET
	611	char *yytext;
	612	#line 1 "rc1.0_tokens.l"
	613	#define INITIAL 0
	614	/* definitions */
	615	#line 8 "rc1.0_tokens.l"
	616
	617	#include <stdlib.h>
	618	#include "rc1.0_combiners.h"
	619	#include "_rc1.0_parser.h"
	620
	621	#include "nvparse_errors.h"
	622	#include "nvparse_externs.h"
	623
	624	#define YY_INPUT(buf,result,max_size) \
	625	{ \
	626	result = 0; \
	627	while (*myin && result < max_size) \
	628	buf[result++] = *myin++; \
	629	}
	630
	631	#define YY_ALWAYS_INTERACTIVE 1
	632
	633	/* end of definitions */
	634	#line 635 "_rc1.0_lexer.cpp"
	635
	636	/* Macros after this point can all be overridden by user definitions in
	637	* section 1.
	638	*/
	639
	640	#ifndef YY_SKIP_YYWRAP
	641	#ifdef __cplusplus
	642	extern "C" int yywrap YY_PROTO(( void ));
	643	#else
	644	extern int yywrap YY_PROTO(( void ));
	645	#endif
	646	#endif
	647
	648	#ifndef YY_NO_UNPUT
	649	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
	650	#endif
	651
	652	#ifndef yytext_ptr
	653	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
	654	#endif
	655
	656	#ifdef YY_NEED_STRLEN
	657	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
	658	#endif
	659
	660	#ifndef YY_NO_INPUT
	661	#ifdef __cplusplus
	662	static int yyinput YY_PROTO(( void ));
	663	#else
	664	static int input YY_PROTO(( void ));
	665	#endif
	666	#endif
	667
	668	#if YY_STACK_USED
	669	static int yy_start_stack_ptr = 0;
	670	static int yy_start_stack_depth = 0;
	671	static int *yy_start_stack = 0;
	672	#ifndef YY_NO_PUSH_STATE
	673	static void yy_push_state YY_PROTO(( int new_state ));
	674	#endif
	675	#ifndef YY_NO_POP_STATE
	676	static void yy_pop_state YY_PROTO(( void ));
	677	#endif
	678	#ifndef YY_NO_TOP_STATE
	679	static int yy_top_state YY_PROTO(( void ));
	680	#endif
	681
	682	#else
	683	#define YY_NO_PUSH_STATE 1
	684	#define YY_NO_POP_STATE 1
	685	#define YY_NO_TOP_STATE 1
	686	#endif
	687
	688	#ifdef YY_MALLOC_DECL
	689	YY_MALLOC_DECL
	690	#else
	691	#if __STDC__
	692	#ifndef __cplusplus
	693	#include <stdlib.h>
	694	#endif
	695	#else
	696	/* Just try to get by without declaring the routines. This will fail
	697	* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
	698	* or sizeof(void*) != sizeof(int).
	699	*/
	700	#endif
	701	#endif
	702
	703	/* Amount of stuff to slurp up with each read. */
	704	#ifndef YY_READ_BUF_SIZE
	705	#define YY_READ_BUF_SIZE 8192
	706	#endif
	707
	708	/* Copy whatever the last rule matched to the standard output. */
	709
	710	#ifndef ECHO
	711	/* This used to be an fputs(), but since the string might contain NUL's,
	712	* we now use fwrite().
	713	*/
	714	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
	715	#endif
	716
	717	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
	718	* is returned in "result".
	719	*/
	720	#ifndef YY_INPUT
	721	#define YY_INPUT(buf,result,max_size) \
	722	if ( yy_current_buffer->yy_is_interactive ) \
	723	{ \
	724	int c = '*', n; \
	725	for ( n = 0; n < max_size && \
	726	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
	727	buf[n] = (char) c; \
	728	if ( c == '\n' ) \
	729	buf[n++] = (char) c; \
	730	if ( c == EOF && ferror( yyin ) ) \
	731	YY_FATAL_ERROR( "input in flex scanner failed" ); \
	732	result = n; \
	733	} \
	734	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
	735	&& ferror( yyin ) ) \
	736	YY_FATAL_ERROR( "input in flex scanner failed" );
	737	#endif
	738
	739	/* No semi-colon after return; correct usage is to write "yyterminate();" -
	740	* we don't want an extra ';' after the "return" because that will cause
	741	* some compilers to complain about unreachable statements.
	742	*/
	743	#ifndef yyterminate
	744	#define yyterminate() return YY_NULL
	745	#endif
	746
	747	/* Number of entries by which start-condition stack grows. */
	748	#ifndef YY_START_STACK_INCR
	749	#define YY_START_STACK_INCR 25
	750	#endif
	751
	752	/* Report a fatal error. */
	753	#ifndef YY_FATAL_ERROR
	754	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
	755	#endif
	756
	757	/* Default declaration of generated scanner - a define so the user can
	758	* easily add parameters.
	759	*/
	760	#ifndef YY_DECL
	761	#define YY_DECL int yylex YY_PROTO(( void ))
	762	#endif
	763
	764	/* Code executed at the beginning of each rule, after yytext and yyleng
	765	* have been set up.
	766	*/
	767	#ifndef YY_USER_ACTION
	768	#define YY_USER_ACTION
	769	#endif
	770
	771	/* Code executed at the end of each rule. */
	772	#ifndef YY_BREAK
	773	#define YY_BREAK break;
	774	#endif
	775
	776	#define YY_RULE_SETUP \
	777	YY_USER_ACTION
	778
	779	YY_DECL
	780	{
	781	register yy_state_type yy_current_state;
	782	register char yy_cp = NULL, yy_bp = NULL;
	783	register int yy_act;
	784
	785	#line 27 "rc1.0_tokens.l"
	786
	787
	788	#line 789 "_rc1.0_lexer.cpp"
	789
	790	if ( yy_init )
	791	{
	792	yy_init = 0;
	793
	794	#ifdef YY_USER_INIT
	795	YY_USER_INIT;
	796	#endif
	797
	798	if ( ! yy_start )
	799	yy_start = 1; /* first start state */
	800
	801	if ( ! yyin )
	802	yyin = stdin;
	803
	804	if ( ! yyout )
	805	yyout = stdout;
	806
	807	if ( ! yy_current_buffer )
	808	yy_current_buffer =
	809	yy_create_buffer( yyin, YY_BUF_SIZE );
	810
	811	yy_load_buffer_state();
	812	}
	813
	814	while ( 1 ) /* loops until end-of-file is reached */
	815	{
	816	yy_cp = yy_c_buf_p;
	817
	818	/* Support of yytext. */
	819	*yy_cp = yy_hold_char;
	820
	821	/* yy_bp points to the position in yy_ch_buf of the start of
	822	* the current run.
	823	*/
	824	yy_bp = yy_cp;
	825
	826	yy_current_state = yy_start;
	827	yy_match:
	828	do
	829	{
	830	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
	831	if ( yy_accept[yy_current_state] )
	832	{
	833	yy_last_accepting_state = yy_current_state;
	834	yy_last_accepting_cpos = yy_cp;
	835	}
	836	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
	837	{
	838	yy_current_state = (int) yy_def[yy_current_state];
	839	if ( yy_current_state >= 309 )
	840	yy_c = yy_meta[(unsigned int) yy_c];
	841	}
	842	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
	843	++yy_cp;
	844	}
	845	while ( yy_base[yy_current_state] != 544 );
	846
	847	yy_find_action:
	848	yy_act = yy_accept[yy_current_state];
	849	if ( yy_act == 0 )
	850	{ /* have to back up */
	851	yy_cp = yy_last_accepting_cpos;
	852	yy_current_state = yy_last_accepting_state;
	853	yy_act = yy_accept[yy_current_state];
	854	}
	855
	856	YY_DO_BEFORE_ACTION;
	857
	858
	859	do_action: /* This label is used only to access EOF actions. */
	860
	861
	862	switch ( yy_act )
	863	{ /* beginning of action switch */
	864	case 0: /* must back up */
	865	/* undo the effects of YY_DO_BEFORE_ACTION */
	866	*yy_cp = yy_hold_char;
	867	yy_cp = yy_last_accepting_cpos;
	868	yy_current_state = yy_last_accepting_state;
	869	goto yy_find_action;
	870
	871	case 1:
	872	YY_RULE_SETUP
	873	#line 29 "rc1.0_tokens.l"
	874	{
	875	A:
	876	switch (yyinput()) {
	877	case '*': goto B;
	878	case 0: errors.set("end-of-file in comment", line_number); break;
	879	case '\n': line_number++;
	880	default: goto A;
	881	}
	882	B:
	883	switch (yyinput()) {
	884	case '*': goto B;
	885	case '/': break;
	886	case 0: errors.set("end-of-file in comment", line_number); break;
	887	case '\n': line_number++;
	888	default: goto A;
	889	}
	890	}
	891	YY_BREAK
	892	case 2:
	893	YY_RULE_SETUP
	894	#line 47 "rc1.0_tokens.l"
	895	{
	896	char ch;
	897	while ((ch = yyinput()) != '\n');
	898	if (ch == '\n') line_number++;
	899	}
	900	YY_BREAK
	901	case 3:
	902	YY_RULE_SETUP
	903	#line 53 "rc1.0_tokens.l"
	904	{
	905	char ch;
	906	while ((ch = yyinput()) != '\n');
	907	if (ch == '\n') line_number++;
	908	}
	909	YY_BREAK
	910	case 4:
	911	YY_RULE_SETUP
	912	#line 59 "rc1.0_tokens.l"
	913	{ /* eat header */ }
	914	YY_BREAK
	915	case 5:
	916	YY_RULE_SETUP
	917	#line 61 "rc1.0_tokens.l"
	918	{
	919	rc10_lval.registerEnum.word = RCP_FOG_RGB;
	920	return(regVariable);
	921	}
	922	YY_BREAK
	923	case 6:
	924	YY_RULE_SETUP
	925	#line 65 "rc1.0_tokens.l"
	926	{
	927	rc10_lval.registerEnum.word = RCP_FOG_ALPHA;
	928	return(regVariable);
	929	}
	930	YY_BREAK
	931	case 7:
	932	YY_RULE_SETUP
	933	#line 69 "rc1.0_tokens.l"
	934	{
	935	rc10_lval.registerEnum.word = RCP_FOG_BLUE;
	936	return(regVariable);
	937	}
	938	YY_BREAK
	939	case 8:
	940	YY_RULE_SETUP
	941	#line 73 "rc1.0_tokens.l"
	942	{
	943	rc10_lval.registerEnum.word = RCP_FOG;
	944	return(regVariable);
	945	}
	946	YY_BREAK
	947	case 9:
	948	YY_RULE_SETUP
	949	#line 78 "rc1.0_tokens.l"
	950	{
	951	rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR_RGB;
	952	return(regVariable);
	953	}
	954	YY_BREAK
	955	case 10:
	956	YY_RULE_SETUP
	957	#line 82 "rc1.0_tokens.l"
	958	{
	959	rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR_ALPHA;
	960	return(regVariable);
	961	}
	962	YY_BREAK
	963	case 11:
	964	YY_RULE_SETUP
	965	#line 86 "rc1.0_tokens.l"
	966	{
	967	rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR_BLUE;
	968	return(regVariable);
	969	}
	970	YY_BREAK
	971	case 12:
	972	YY_RULE_SETUP
	973	#line 90 "rc1.0_tokens.l"
	974	{
	975	rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR;
	976	return(regVariable);
	977	}
	978	YY_BREAK
	979	case 13:
	980	YY_RULE_SETUP
	981	#line 95 "rc1.0_tokens.l"
	982	{
	983	rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR_RGB;
	984	return(regVariable);
	985	}
	986	YY_BREAK
	987	case 14:
	988	YY_RULE_SETUP
	989	#line 99 "rc1.0_tokens.l"
	990	{
	991	rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR_ALPHA;
	992	return(regVariable);
	993	}
	994	YY_BREAK
	995	case 15:
	996	YY_RULE_SETUP
	997	#line 103 "rc1.0_tokens.l"
	998	{
	999	rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR_BLUE;
	1000	return(regVariable);
	1001	}
	1002	YY_BREAK
	1003	case 16:
	1004	YY_RULE_SETUP
	1005	#line 107 "rc1.0_tokens.l"
	1006	{
	1007	rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR;
	1008	return(regVariable);
	1009	}
	1010	YY_BREAK
	1011	case 17:
	1012	YY_RULE_SETUP
	1013	#line 112 "rc1.0_tokens.l"
	1014	{
	1015	rc10_lval.registerEnum.word = RCP_SPARE0_RGB;
	1016	return(regVariable);
	1017	}
	1018	YY_BREAK
	1019	case 18:
	1020	YY_RULE_SETUP
	1021	#line 116 "rc1.0_tokens.l"
	1022	{
	1023	rc10_lval.registerEnum.word = RCP_SPARE0_ALPHA;
	1024	return(regVariable);
	1025	}
	1026	YY_BREAK
	1027	case 19:
	1028	YY_RULE_SETUP
	1029	#line 120 "rc1.0_tokens.l"
	1030	{
	1031	rc10_lval.registerEnum.word = RCP_SPARE0_BLUE;
	1032	return(regVariable);
	1033	}
	1034	YY_BREAK
	1035	case 20:
	1036	YY_RULE_SETUP
	1037	#line 124 "rc1.0_tokens.l"
	1038	{
	1039	rc10_lval.registerEnum.word = RCP_SPARE0;
	1040	return(regVariable);
	1041	}
	1042	YY_BREAK
	1043	case 21:
	1044	YY_RULE_SETUP
	1045	#line 129 "rc1.0_tokens.l"
	1046	{
	1047	rc10_lval.registerEnum.word = RCP_SPARE1_RGB;
	1048	return(regVariable);
	1049	}
	1050	YY_BREAK
	1051	case 22:
	1052	YY_RULE_SETUP
	1053	#line 133 "rc1.0_tokens.l"
	1054	{
	1055	rc10_lval.registerEnum.word = RCP_SPARE1_ALPHA;
	1056	return(regVariable);
	1057	}
	1058	YY_BREAK
	1059	case 23:
	1060	YY_RULE_SETUP
	1061	#line 137 "rc1.0_tokens.l"
	1062	{
	1063	rc10_lval.registerEnum.word = RCP_SPARE1_BLUE;
	1064	return(regVariable);
	1065	}
	1066	YY_BREAK
	1067	case 24:
	1068	YY_RULE_SETUP
	1069	#line 141 "rc1.0_tokens.l"
	1070	{
	1071	rc10_lval.registerEnum.word = RCP_SPARE1;
	1072	return(regVariable);
	1073	}
	1074	YY_BREAK
	1075	case 25:
	1076	YY_RULE_SETUP
	1077	#line 146 "rc1.0_tokens.l"
	1078	{
	1079	rc10_lval.registerEnum.word = RCP_TEXTURE0_RGB;
	1080	return(regVariable);
	1081	}
	1082	YY_BREAK
	1083	case 26:
	1084	YY_RULE_SETUP
	1085	#line 150 "rc1.0_tokens.l"
	1086	{
	1087	rc10_lval.registerEnum.word = RCP_TEXTURE0_ALPHA;
	1088	return(regVariable);
	1089	}
	1090	YY_BREAK
	1091	case 27:
	1092	YY_RULE_SETUP
	1093	#line 154 "rc1.0_tokens.l"
	1094	{
	1095	rc10_lval.registerEnum.word = RCP_TEXTURE0_BLUE;
	1096	return(regVariable);
	1097	}
	1098	YY_BREAK
	1099	case 28:
	1100	YY_RULE_SETUP
	1101	#line 158 "rc1.0_tokens.l"
	1102	{
	1103	rc10_lval.registerEnum.word = RCP_TEXTURE0;
	1104	return(regVariable);
	1105	}
	1106	YY_BREAK
	1107	case 29:
	1108	YY_RULE_SETUP
	1109	#line 163 "rc1.0_tokens.l"
	1110	{
	1111	rc10_lval.registerEnum.word = RCP_TEXTURE1_RGB;
	1112	return(regVariable);
	1113	}
	1114	YY_BREAK
	1115	case 30:
	1116	YY_RULE_SETUP
	1117	#line 167 "rc1.0_tokens.l"
	1118	{
	1119	rc10_lval.registerEnum.word = RCP_TEXTURE1_ALPHA;
	1120	return(regVariable);
	1121	}
	1122	YY_BREAK
	1123	case 31:
	1124	YY_RULE_SETUP
	1125	#line 171 "rc1.0_tokens.l"
	1126	{
	1127	rc10_lval.registerEnum.word = RCP_TEXTURE1_BLUE;
	1128	return(regVariable);
	1129	}
	1130	YY_BREAK
	1131	case 32:
	1132	YY_RULE_SETUP
	1133	#line 175 "rc1.0_tokens.l"
	1134	{
	1135	rc10_lval.registerEnum.word = RCP_TEXTURE1;
	1136	return(regVariable);
	1137	}
	1138	YY_BREAK
	1139	case 33:
	1140	YY_RULE_SETUP
	1141	#line 180 "rc1.0_tokens.l"
	1142	{
	1143	rc10_lval.registerEnum.word = RCP_TEXTURE2_RGB;
	1144	return(regVariable);
	1145	}
	1146	YY_BREAK
	1147	case 34:
	1148	YY_RULE_SETUP
	1149	#line 184 "rc1.0_tokens.l"
	1150	{
	1151	rc10_lval.registerEnum.word = RCP_TEXTURE2_ALPHA;
	1152	return(regVariable);
	1153	}
	1154	YY_BREAK
	1155	case 35:
	1156	YY_RULE_SETUP
	1157	#line 188 "rc1.0_tokens.l"
	1158	{
	1159	rc10_lval.registerEnum.word = RCP_TEXTURE2_BLUE;
	1160	return(regVariable);
	1161	}
	1162	YY_BREAK
	1163	case 36:
	1164	YY_RULE_SETUP
	1165	#line 192 "rc1.0_tokens.l"
	1166	{
	1167	rc10_lval.registerEnum.word = RCP_TEXTURE2;
	1168	return(regVariable);
	1169	}
	1170	YY_BREAK
	1171	case 37:
	1172	YY_RULE_SETUP
	1173	#line 197 "rc1.0_tokens.l"
	1174	{
	1175	rc10_lval.registerEnum.word = RCP_TEXTURE3_RGB;
	1176	return(regVariable);
	1177	}
	1178	YY_BREAK
	1179	case 38:
	1180	YY_RULE_SETUP
	1181	#line 201 "rc1.0_tokens.l"
	1182	{
	1183	rc10_lval.registerEnum.word = RCP_TEXTURE3_ALPHA;
	1184	return(regVariable);
	1185	}
	1186	YY_BREAK
	1187	case 39:
	1188	YY_RULE_SETUP
	1189	#line 205 "rc1.0_tokens.l"
	1190	{
	1191	rc10_lval.registerEnum.word = RCP_TEXTURE3_BLUE;
	1192	return(regVariable);
	1193	}
	1194	YY_BREAK
	1195	case 40:
	1196	YY_RULE_SETUP
	1197	#line 209 "rc1.0_tokens.l"
	1198	{
	1199	rc10_lval.registerEnum.word = RCP_TEXTURE3;
	1200	return(regVariable);
	1201	}
	1202	YY_BREAK
	1203	case 41:
	1204	YY_RULE_SETUP
	1205	#line 214 "rc1.0_tokens.l"
	1206	{
	1207	rc10_lval.registerEnum.word = RCP_CONST_COLOR0_RGB;
	1208	return(regVariable);
	1209	}
	1210	YY_BREAK
	1211	case 42:
	1212	YY_RULE_SETUP
	1213	#line 218 "rc1.0_tokens.l"
	1214	{
	1215	rc10_lval.registerEnum.word = RCP_CONST_COLOR0_ALPHA;
	1216	return(regVariable);
	1217	}
	1218	YY_BREAK
	1219	case 43:
	1220	YY_RULE_SETUP
	1221	#line 222 "rc1.0_tokens.l"
	1222	{
	1223	rc10_lval.registerEnum.word = RCP_CONST_COLOR0_BLUE;
	1224	return(regVariable);
	1225	}
	1226	YY_BREAK
	1227	case 44:
	1228	YY_RULE_SETUP
	1229	#line 226 "rc1.0_tokens.l"
	1230	{
	1231	rc10_lval.registerEnum.word = RCP_CONST_COLOR0;
	1232	return(constVariable);
	1233	}
	1234	YY_BREAK
	1235	case 45:
	1236	YY_RULE_SETUP
	1237	#line 231 "rc1.0_tokens.l"
	1238	{
	1239	rc10_lval.registerEnum.word = RCP_CONST_COLOR1_RGB;
	1240	return(regVariable);
	1241	}
	1242	YY_BREAK
	1243	case 46:
	1244	YY_RULE_SETUP
	1245	#line 235 "rc1.0_tokens.l"
	1246	{
	1247	rc10_lval.registerEnum.word = RCP_CONST_COLOR1_ALPHA;
	1248	return(regVariable);
	1249	}
	1250	YY_BREAK
	1251	case 47:
	1252	YY_RULE_SETUP
	1253	#line 239 "rc1.0_tokens.l"
	1254	{
	1255	rc10_lval.registerEnum.word = RCP_CONST_COLOR1_BLUE;
	1256	return(regVariable);
	1257	}
	1258	YY_BREAK
	1259	case 48:
	1260	YY_RULE_SETUP
	1261	#line 243 "rc1.0_tokens.l"
	1262	{
	1263	rc10_lval.registerEnum.word = RCP_CONST_COLOR1;
	1264	return(constVariable);
	1265	}
	1266	YY_BREAK
	1267	case 49:
	1268	YY_RULE_SETUP
	1269	#line 248 "rc1.0_tokens.l"
	1270	{
	1271	rc10_lval.registerEnum.word = RCP_ZERO_RGB;
	1272	return(regVariable);
	1273	}
	1274	YY_BREAK
	1275	case 50:
	1276	YY_RULE_SETUP
	1277	#line 252 "rc1.0_tokens.l"
	1278	{
	1279	rc10_lval.registerEnum.word = RCP_ZERO_ALPHA;
	1280	return(regVariable);
	1281	}
	1282	YY_BREAK
	1283	case 51:
	1284	YY_RULE_SETUP
	1285	#line 256 "rc1.0_tokens.l"
	1286	{
	1287	rc10_lval.registerEnum.word = RCP_ZERO_BLUE;
	1288	return(regVariable);
	1289	}
	1290	YY_BREAK
	1291	case 52:
	1292	YY_RULE_SETUP
	1293	#line 260 "rc1.0_tokens.l"
	1294	{
	1295	rc10_lval.registerEnum.word = RCP_ZERO;
	1296	return(regVariable);
	1297	}
	1298	YY_BREAK
	1299	case 53:
	1300	YY_RULE_SETUP
	1301	#line 265 "rc1.0_tokens.l"
	1302	{
	1303	rc10_lval.registerEnum.word = RCP_ONE_RGB;
	1304	return(regVariable);
	1305	}
	1306	YY_BREAK
	1307	case 54:
	1308	YY_RULE_SETUP
	1309	#line 269 "rc1.0_tokens.l"
	1310	{
	1311	rc10_lval.registerEnum.word = RCP_ONE_ALPHA;
	1312	return(regVariable);
	1313	}
	1314	YY_BREAK
	1315	case 55:
	1316	YY_RULE_SETUP
	1317	#line 273 "rc1.0_tokens.l"
	1318	{
	1319	rc10_lval.registerEnum.word = RCP_ONE_BLUE;
	1320	return(regVariable);
	1321	}
	1322	YY_BREAK
	1323	case 56:
	1324	YY_RULE_SETUP
	1325	#line 277 "rc1.0_tokens.l"
	1326	{
	1327	rc10_lval.registerEnum.word = RCP_ONE;
	1328	return(regVariable);
	1329	}
	1330	YY_BREAK
	1331	case 57:
	1332	YY_RULE_SETUP
	1333	#line 282 "rc1.0_tokens.l"
	1334	{
	1335	rc10_lval.registerEnum.word = RCP_DISCARD;
	1336	return(regVariable);
	1337	}
	1338	YY_BREAK
	1339	case 58:
	1340	YY_RULE_SETUP
	1341	#line 287 "rc1.0_tokens.l"
	1342	return(fragment_rgb);
	1343	YY_BREAK
	1344	case 59:
	1345	YY_RULE_SETUP
	1346	#line 288 "rc1.0_tokens.l"
	1347	return(fragment_alpha);
	1348	YY_BREAK
	1349	case 60:
	1350	YY_RULE_SETUP
	1351	#line 290 "rc1.0_tokens.l"
	1352	{
	1353	rc10_lval.registerEnum.word = RCP_FINAL_PRODUCT;
	1354	return(final_product);
	1355	}
	1356	YY_BREAK
	1357	case 61:
	1358	YY_RULE_SETUP
	1359	#line 295 "rc1.0_tokens.l"
	1360	{
	1361	rc10_lval.registerEnum.word = RCP_COLOR_SUM;
	1362	return(color_sum);
	1363	}
	1364	YY_BREAK
	1365	case 62:
	1366	YY_RULE_SETUP
	1367	#line 300 "rc1.0_tokens.l"
	1368	return(expandString);
	1369	YY_BREAK
	1370	case 63:
	1371	YY_RULE_SETUP
	1372	#line 301 "rc1.0_tokens.l"
	1373	return(halfBiasString);
	1374	YY_BREAK
	1375	case 64:
	1376	YY_RULE_SETUP
	1377	#line 302 "rc1.0_tokens.l"
	1378	return(unsignedString);
	1379	YY_BREAK
	1380	case 65:
	1381	YY_RULE_SETUP
	1382	#line 303 "rc1.0_tokens.l"
	1383	return(unsignedInvertString);
	1384	YY_BREAK
	1385	case 66:
	1386	YY_RULE_SETUP
	1387	#line 304 "rc1.0_tokens.l"
	1388	{
	1389	rc10_lval.ival = GL_TRUE;
	1390	return(muxString);
	1391	}
	1392	YY_BREAK
	1393	case 67:
	1394	YY_RULE_SETUP
	1395	#line 309 "rc1.0_tokens.l"
	1396	{
	1397	rc10_lval.ival = GL_FALSE;
	1398	return(sumString);
	1399	}
	1400	YY_BREAK
	1401	case 68:
	1402	YY_RULE_SETUP
	1403	#line 314 "rc1.0_tokens.l"
	1404	{
	1405	rc10_lval.ival = RCP_RGB;
	1406	return(rgb_portion);
	1407	}
	1408	YY_BREAK
	1409	case 69:
	1410	YY_RULE_SETUP
	1411	#line 318 "rc1.0_tokens.l"
	1412	{
	1413	rc10_lval.ival = RCP_ALPHA;
	1414	return(alpha_portion);
	1415	}
	1416	YY_BREAK
	1417	case 70:
	1418	YY_RULE_SETUP
	1419	#line 323 "rc1.0_tokens.l"
	1420	{
	1421	rc10_lval.ival = true;
	1422	return(clamp_color_sum);
	1423	}
	1424	YY_BREAK
	1425	case 71:
	1426	YY_RULE_SETUP
	1427	#line 327 "rc1.0_tokens.l"
	1428	return(lerp);
	1429	YY_BREAK
	1430	case 72:
	1431	YY_RULE_SETUP
	1432	#line 330 "rc1.0_tokens.l"
	1433	{
	1434	rc10_lval.biasScaleEnum.word = RCP_BIAS_BY_NEGATIVE_ONE_HALF_SCALE_BY_TWO;
	1435	return(bias_by_negative_one_half_scale_by_two);
	1436	}
	1437	YY_BREAK
	1438	case 73:
	1439	YY_RULE_SETUP
	1440	#line 334 "rc1.0_tokens.l"
	1441	{
	1442	rc10_lval.biasScaleEnum.word = RCP_BIAS_BY_NEGATIVE_ONE_HALF;
	1443	return(bias_by_negative_one_half);
	1444	}
	1445	YY_BREAK
	1446	case 74:
	1447	YY_RULE_SETUP
	1448	#line 338 "rc1.0_tokens.l"
	1449	{
	1450	rc10_lval.biasScaleEnum.word = RCP_SCALE_BY_ONE_HALF;
	1451	return(scale_by_one_half);
	1452	}
	1453	YY_BREAK
	1454	case 75:
	1455	YY_RULE_SETUP
	1456	#line 342 "rc1.0_tokens.l"
	1457	{
	1458	rc10_lval.biasScaleEnum.word = RCP_SCALE_BY_TWO;
	1459	return(scale_by_two);
	1460	}
	1461	YY_BREAK
	1462	case 76:
	1463	YY_RULE_SETUP
	1464	#line 346 "rc1.0_tokens.l"
	1465	{
	1466	rc10_lval.biasScaleEnum.word = RCP_SCALE_BY_FOUR;
	1467	return(scale_by_four);
	1468	}
	1469	YY_BREAK
	1470	case 77:
	1471	YY_RULE_SETUP
	1472	#line 351 "rc1.0_tokens.l"
	1473	{
	1474	rc10_lval.fval = (float)atof(yytext);
	1475	return(floatValue);
	1476	}
	1477	YY_BREAK
	1478	case 78:
	1479	YY_RULE_SETUP
	1480	#line 356 "rc1.0_tokens.l"
	1481	{
	1482	rc10_lval.fval = (float)atof(yytext);
	1483	return(floatValue);
	1484	}
	1485	YY_BREAK
	1486	case 79:
	1487	YY_RULE_SETUP
	1488	#line 361 "rc1.0_tokens.l"
	1489	{
	1490	rc10_lval.fval = (float)atof(yytext);
	1491	return(floatValue);
	1492	}
	1493	YY_BREAK
	1494	case 80:
	1495	YY_RULE_SETUP
	1496	#line 366 "rc1.0_tokens.l"
	1497	return(openBracket);
	1498	YY_BREAK
	1499	case 81:
	1500	YY_RULE_SETUP
	1501	#line 367 "rc1.0_tokens.l"
	1502	return(closeBracket);
	1503	YY_BREAK
	1504	case 82:
	1505	YY_RULE_SETUP
	1506	#line 368 "rc1.0_tokens.l"
	1507	return(openParen);
	1508	YY_BREAK
	1509	case 83:
	1510	YY_RULE_SETUP
	1511	#line 369 "rc1.0_tokens.l"
	1512	return(closeParen);
	1513	YY_BREAK
	1514	case 84:
	1515	YY_RULE_SETUP
	1516	#line 370 "rc1.0_tokens.l"
	1517	return(semicolon);
	1518	YY_BREAK
	1519	case 85:
	1520	YY_RULE_SETUP
	1521	#line 371 "rc1.0_tokens.l"
	1522	return(comma);
	1523	YY_BREAK
	1524	case 86:
	1525	YY_RULE_SETUP
	1526	#line 372 "rc1.0_tokens.l"
	1527	return(dot);
	1528	YY_BREAK
	1529	case 87:
	1530	YY_RULE_SETUP
	1531	#line 373 "rc1.0_tokens.l"
	1532	return(times);
	1533	YY_BREAK
	1534	case 88:
	1535	YY_RULE_SETUP
	1536	#line 374 "rc1.0_tokens.l"
	1537	return(minus);
	1538	YY_BREAK
	1539	case 89:
	1540	YY_RULE_SETUP
	1541	#line 375 "rc1.0_tokens.l"
	1542	return(plus);
	1543	YY_BREAK
	1544	case 90:
	1545	YY_RULE_SETUP
	1546	#line 376 "rc1.0_tokens.l"
	1547	return(equals);
	1548	YY_BREAK
	1549	case 91:
	1550	YY_RULE_SETUP
	1551	#line 378 "rc1.0_tokens.l"
	1552	{
	1553	line_number++;
	1554	}
	1555	YY_BREAK
	1556	case 92:
	1557	YY_RULE_SETUP
	1558	#line 382 "rc1.0_tokens.l"
	1559	{}
	1560	YY_BREAK
	1561	case 93:
	1562	YY_RULE_SETUP
	1563	#line 384 "rc1.0_tokens.l"
	1564	{
	1565	errors.set("unrecognized token", line_number);
	1566	}
	1567	YY_BREAK
	1568	case 94:
	1569	YY_RULE_SETUP
	1570	#line 389 "rc1.0_tokens.l"
	1571	ECHO;
	1572	YY_BREAK
	1573	#line 1574 "_rc1.0_lexer.cpp"
	1574	case YY_STATE_EOF(INITIAL):
	1575	yyterminate();
	1576
	1577	case YY_END_OF_BUFFER:
	1578	{
	1579	/* Amount of text matched not including the EOB char. */
	1580	int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
	1581
	1582	/* Undo the effects of YY_DO_BEFORE_ACTION. */
	1583	*yy_cp = yy_hold_char;
	1584	YY_RESTORE_YY_MORE_OFFSET
	1585
	1586	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
	1587	{
	1588	/* We're scanning a new file or input source. It's
	1589	* possible that this happened because the user
	1590	* just pointed yyin at a new source and called
	1591	* yylex(). If so, then we have to assure
	1592	* consistency between yy_current_buffer and our
	1593	* globals. Here is the right place to do so, because
	1594	* this is the first action (other than possibly a
	1595	* back-up) that will match for the new input source.
	1596	*/
	1597	yy_n_chars = yy_current_buffer->yy_n_chars;
	1598	yy_current_buffer->yy_input_file = yyin;
	1599	yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
	1600	}
	1601
	1602	/* Note that here we test for yy_c_buf_p "<=" to the position
	1603	* of the first EOB in the buffer, since yy_c_buf_p will
	1604	* already have been incremented past the NUL character
	1605	* (since all states make transitions on EOB to the
	1606	* end-of-buffer state). Contrast this with the test
	1607	* in input().
	1608	*/
	1609	if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
	1610	{ /* This was really a NUL. */
	1611	yy_state_type yy_next_state;
	1612
	1613	yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
	1614
	1615	yy_current_state = yy_get_previous_state();
	1616
	1617	/* Okay, we're now positioned to make the NUL
	1618	* transition. We couldn't have
	1619	* yy_get_previous_state() go ahead and do it
	1620	* for us because it doesn't know how to deal
	1621	* with the possibility of jamming (and we don't
	1622	* want to build jamming into it because then it
	1623	* will run more slowly).
	1624	*/
	1625
	1626	yy_next_state = yy_try_NUL_trans( yy_current_state );
	1627
	1628	yy_bp = yytext_ptr + YY_MORE_ADJ;
	1629
	1630	if ( yy_next_state )
	1631	{
	1632	/* Consume the NUL. */
	1633	yy_cp = ++yy_c_buf_p;
	1634	yy_current_state = yy_next_state;
	1635	goto yy_match;
	1636	}
	1637
	1638	else
	1639	{
	1640	yy_cp = yy_c_buf_p;
	1641	goto yy_find_action;
	1642	}
	1643	}
	1644
	1645	else switch ( yy_get_next_buffer() )
	1646	{
	1647	case EOB_ACT_END_OF_FILE:
	1648	{
	1649	yy_did_buffer_switch_on_eof = 0;
	1650
	1651	if ( yywrap() )
	1652	{
	1653	/* Note: because we've taken care in
	1654	* yy_get_next_buffer() to have set up
	1655	* yytext, we can now set up
	1656	* yy_c_buf_p so that if some total
	1657	* hoser (like flex itself) wants to
	1658	* call the scanner after we return the
	1659	* YY_NULL, it'll still work - another
	1660	* YY_NULL will get returned.
	1661	*/
	1662	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
	1663
	1664	yy_act = YY_STATE_EOF(YY_START);
	1665	goto do_action;
	1666	}
	1667
	1668	else
	1669	{
	1670	if ( ! yy_did_buffer_switch_on_eof )
	1671	YY_NEW_FILE;
	1672	}
	1673	break;
	1674	}
	1675
	1676	case EOB_ACT_CONTINUE_SCAN:
	1677	yy_c_buf_p =
	1678	yytext_ptr + yy_amount_of_matched_text;
	1679
	1680	yy_current_state = yy_get_previous_state();
	1681
	1682	yy_cp = yy_c_buf_p;
	1683	yy_bp = yytext_ptr + YY_MORE_ADJ;
	1684	goto yy_match;
	1685
	1686	case EOB_ACT_LAST_MATCH:
	1687	yy_c_buf_p =
	1688	&yy_current_buffer->yy_ch_buf[yy_n_chars];
	1689
	1690	yy_current_state = yy_get_previous_state();
	1691
	1692	yy_cp = yy_c_buf_p;
	1693	yy_bp = yytext_ptr + YY_MORE_ADJ;
	1694	goto yy_find_action;
	1695	}
	1696	break;
	1697	}
	1698
	1699	default:
	1700	YY_FATAL_ERROR(
	1701	"fatal flex scanner internal error--no action found" );
	1702	} /* end of action switch */
	1703	} /* end of scanning one token */
	1704	} /* end of yylex */
	1705
	1706
	1707	/* yy_get_next_buffer - try to read in a new buffer
	1708	*
	1709	* Returns a code representing an action:
	1710	* EOB_ACT_LAST_MATCH -
	1711	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
	1712	* EOB_ACT_END_OF_FILE - end of file
	1713	*/
	1714
	1715	static int yy_get_next_buffer()
	1716	{
	1717	register char *dest = yy_current_buffer->yy_ch_buf;
	1718	register char *source = yytext_ptr;
	1719	register int number_to_move, i;
	1720	int ret_val;
	1721
	1722	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
	1723	YY_FATAL_ERROR(
	1724	"fatal flex scanner internal error--end of buffer missed" );
	1725
	1726	if ( yy_current_buffer->yy_fill_buffer == 0 )
	1727	{ /* Don't try to fill the buffer, so this is an EOF. */
	1728	if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
	1729	{
	1730	/* We matched a single character, the EOB, so
	1731	* treat this as a final EOF.
	1732	*/
	1733	return EOB_ACT_END_OF_FILE;
	1734	}
	1735
	1736	else
	1737	{
	1738	/* We matched some text prior to the EOB, first
	1739	* process it.
	1740	*/
	1741	return EOB_ACT_LAST_MATCH;
	1742	}
	1743	}
	1744
	1745	/* Try to read more data. */
	1746
	1747	/* First move last chars to start of buffer. */
	1748	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
	1749
	1750	for ( i = 0; i < number_to_move; ++i )
	1751	(dest++) = (source++);
	1752
	1753	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
	1754	/* don't do the read, it's not guaranteed to return an EOF,
	1755	* just force an EOF
	1756	*/
	1757	yy_current_buffer->yy_n_chars = yy_n_chars = 0;
	1758
	1759	else
	1760	{
	1761	int num_to_read =
	1762	yy_current_buffer->yy_buf_size - number_to_move - 1;
	1763
	1764	while ( num_to_read <= 0 )
	1765	{ /* Not enough room in the buffer - grow it. */
	1766	#ifdef YY_USES_REJECT
	1767	YY_FATAL_ERROR(
	1768	"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
	1769	#else
	1770
	1771	/* just a shorter name for the current buffer */
	1772	YY_BUFFER_STATE b = yy_current_buffer;
	1773
	1774	int yy_c_buf_p_offset =
	1775	(int) (yy_c_buf_p - b->yy_ch_buf);
	1776
	1777	if ( b->yy_is_our_buffer )
	1778	{
	1779	int new_size = b->yy_buf_size * 2;
	1780
	1781	if ( new_size <= 0 )
	1782	b->yy_buf_size += b->yy_buf_size / 8;
	1783	else
	1784	b->yy_buf_size *= 2;
	1785
	1786	b->yy_ch_buf = (char *)
	1787	/* Include room in for 2 EOB chars. */
	1788	yy_flex_realloc( (void *) b->yy_ch_buf,
	1789	b->yy_buf_size + 2 );
	1790	}
	1791	else
	1792	/* Can't grow it, we don't own it. */
	1793	b->yy_ch_buf = 0;
	1794
	1795	if ( ! b->yy_ch_buf )
	1796	YY_FATAL_ERROR(
	1797	"fatal error - scanner input buffer overflow" );
	1798
	1799	yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
	1800
	1801	num_to_read = yy_current_buffer->yy_buf_size -
	1802	number_to_move - 1;
	1803	#endif
	1804	}
	1805
	1806	if ( num_to_read > YY_READ_BUF_SIZE )
	1807	num_to_read = YY_READ_BUF_SIZE;
	1808
	1809	/* Read in more data. */
	1810	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
	1811	yy_n_chars, num_to_read );
	1812
	1813	yy_current_buffer->yy_n_chars = yy_n_chars;
	1814	}
	1815
	1816	if ( yy_n_chars == 0 )
	1817	{
	1818	if ( number_to_move == YY_MORE_ADJ )
	1819	{
	1820	ret_val = EOB_ACT_END_OF_FILE;
	1821	yyrestart( yyin );
	1822	}
	1823
	1824	else
	1825	{
	1826	ret_val = EOB_ACT_LAST_MATCH;
	1827	yy_current_buffer->yy_buffer_status =
	1828	YY_BUFFER_EOF_PENDING;
	1829	}
	1830	}
	1831
	1832	else
	1833	ret_val = EOB_ACT_CONTINUE_SCAN;
	1834
	1835	yy_n_chars += number_to_move;
	1836	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	1837	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
	1838
	1839	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
	1840
	1841	return ret_val;
	1842	}
	1843
	1844
	1845	/* yy_get_previous_state - get the state just before the EOB char was reached */
	1846
	1847	static yy_state_type yy_get_previous_state()
	1848	{
	1849	register yy_state_type yy_current_state;
	1850	register char *yy_cp;
	1851
	1852	yy_current_state = yy_start;
	1853
	1854	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
	1855	{
	1856	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
	1857	if ( yy_accept[yy_current_state] )
	1858	{
	1859	yy_last_accepting_state = yy_current_state;
	1860	yy_last_accepting_cpos = yy_cp;
	1861	}
	1862	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
	1863	{
	1864	yy_current_state = (int) yy_def[yy_current_state];
	1865	if ( yy_current_state >= 309 )
	1866	yy_c = yy_meta[(unsigned int) yy_c];
	1867	}
	1868	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
	1869	}
	1870
	1871	return yy_current_state;
	1872	}
	1873
	1874
	1875	/* yy_try_NUL_trans - try to make a transition on the NUL character
	1876	*
	1877	* synopsis
	1878	* next_state = yy_try_NUL_trans( current_state );
	1879	*/
	1880
	1881	#ifdef YY_USE_PROTOS
	1882	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
	1883	#else
	1884	static yy_state_type yy_try_NUL_trans( yy_current_state )
	1885	yy_state_type yy_current_state;
	1886	#endif
	1887	{
	1888	register int yy_is_jam;
	1889	register char *yy_cp = yy_c_buf_p;
	1890
	1891	register YY_CHAR yy_c = 1;
	1892	if ( yy_accept[yy_current_state] )
	1893	{
	1894	yy_last_accepting_state = yy_current_state;
	1895	yy_last_accepting_cpos = yy_cp;
	1896	}
	1897	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
	1898	{
	1899	yy_current_state = (int) yy_def[yy_current_state];
	1900	if ( yy_current_state >= 309 )
	1901	yy_c = yy_meta[(unsigned int) yy_c];
	1902	}
	1903	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
	1904	yy_is_jam = (yy_current_state == 308);
	1905
	1906	return yy_is_jam ? 0 : yy_current_state;
	1907	}
	1908
	1909
	1910	#ifndef YY_NO_UNPUT
	1911	#ifdef YY_USE_PROTOS
	1912	static void yyunput( int c, register char *yy_bp )
	1913	#else
	1914	static void yyunput( c, yy_bp )
	1915	int c;
	1916	register char *yy_bp;
	1917	#endif
	1918	{
	1919	register char *yy_cp = yy_c_buf_p;
	1920
	1921	/* undo effects of setting up yytext */
	1922	*yy_cp = yy_hold_char;
	1923
	1924	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
	1925	{ /* need to shift things up to make room */
	1926	/* +2 for EOB chars. */
	1927	register int number_to_move = yy_n_chars + 2;
	1928	register char *dest = &yy_current_buffer->yy_ch_buf[
	1929	yy_current_buffer->yy_buf_size + 2];
	1930	register char *source =
	1931	&yy_current_buffer->yy_ch_buf[number_to_move];
	1932
	1933	while ( source > yy_current_buffer->yy_ch_buf )
	1934	--dest = --source;
	1935
	1936	yy_cp += (int) (dest - source);
	1937	yy_bp += (int) (dest - source);
	1938	yy_current_buffer->yy_n_chars =
	1939	yy_n_chars = yy_current_buffer->yy_buf_size;
	1940
	1941	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
	1942	YY_FATAL_ERROR( "flex scanner push-back overflow" );
	1943	}
	1944
	1945	*--yy_cp = (char) c;
	1946
	1947
	1948	yytext_ptr = yy_bp;
	1949	yy_hold_char = *yy_cp;
	1950	yy_c_buf_p = yy_cp;
	1951	}
	1952	#endif /* ifndef YY_NO_UNPUT */
	1953
	1954
	1955	#ifdef __cplusplus
	1956	static int yyinput()
	1957	#else
	1958	static int input()
	1959	#endif
	1960	{
	1961	int c;
	1962
	1963	*yy_c_buf_p = yy_hold_char;
	1964
	1965	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
	1966	{
	1967	/* yy_c_buf_p now points to the character we want to return.
	1968	* If this occurs before the EOB characters, then it's a
	1969	* valid NUL; if not, then we've hit the end of the buffer.
	1970	*/
	1971	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
	1972	/* This was really a NUL. */
	1973	*yy_c_buf_p = '\0';
	1974
	1975	else
	1976	{ /* need more input */
	1977	int offset = yy_c_buf_p - yytext_ptr;
	1978	++yy_c_buf_p;
	1979
	1980	switch ( yy_get_next_buffer() )
	1981	{
	1982	case EOB_ACT_LAST_MATCH:
	1983	/* This happens because yy_g_n_b()
	1984	* sees that we've accumulated a
	1985	* token and flags that we need to
	1986	* try matching the token before
	1987	* proceeding. But for input(),
	1988	* there's no matching to consider.
	1989	* So convert the EOB_ACT_LAST_MATCH
	1990	* to EOB_ACT_END_OF_FILE.
	1991	*/
	1992
	1993	/* Reset buffer status. */
	1994	yyrestart( yyin );
	1995
	1996	/* fall through */
	1997
	1998	case EOB_ACT_END_OF_FILE:
	1999	{
	2000	if ( yywrap() )
	2001	return EOF;
	2002
	2003	if ( ! yy_did_buffer_switch_on_eof )
	2004	YY_NEW_FILE;
	2005	#ifdef __cplusplus
	2006	return yyinput();
	2007	#else
	2008	return input();
	2009	#endif
	2010	}
	2011
	2012	case EOB_ACT_CONTINUE_SCAN:
	2013	yy_c_buf_p = yytext_ptr + offset;
	2014	break;
	2015	}
	2016	}
	2017	}
	2018
	2019	c = (unsigned char ) yy_c_buf_p; /* cast for 8-bit char's */
	2020	yy_c_buf_p = '\0'; / preserve yytext */
	2021	yy_hold_char = *++yy_c_buf_p;
	2022
	2023
	2024	return c;
	2025	}
	2026
	2027
	2028	#ifdef YY_USE_PROTOS
	2029	void yyrestart( FILE *input_file )
	2030	#else
	2031	void yyrestart( input_file )
	2032	FILE *input_file;
	2033	#endif
	2034	{
	2035	if ( ! yy_current_buffer )
	2036	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
	2037
	2038	yy_init_buffer( yy_current_buffer, input_file );
	2039	yy_load_buffer_state();
	2040	}
	2041
	2042
	2043	#ifdef YY_USE_PROTOS
	2044	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
	2045	#else
	2046	void yy_switch_to_buffer( new_buffer )
	2047	YY_BUFFER_STATE new_buffer;
	2048	#endif
	2049	{
	2050	if ( yy_current_buffer == new_buffer )
	2051	return;
	2052
	2053	if ( yy_current_buffer )
	2054	{
	2055	/* Flush out information for old buffer. */
	2056	*yy_c_buf_p = yy_hold_char;
	2057	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
	2058	yy_current_buffer->yy_n_chars = yy_n_chars;
	2059	}
	2060
	2061	yy_current_buffer = new_buffer;
	2062	yy_load_buffer_state();
	2063
	2064	/* We don't actually know whether we did this switch during
	2065	* EOF (yywrap()) processing, but the only time this flag
	2066	* is looked at is after yywrap() is called, so it's safe
	2067	* to go ahead and always set it.
	2068	*/
	2069	yy_did_buffer_switch_on_eof = 1;
	2070	}
	2071
	2072
	2073	#ifdef YY_USE_PROTOS
	2074	void yy_load_buffer_state( void )
	2075	#else
	2076	void yy_load_buffer_state()
	2077	#endif
	2078	{
	2079	yy_n_chars = yy_current_buffer->yy_n_chars;
	2080	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
	2081	yyin = yy_current_buffer->yy_input_file;
	2082	yy_hold_char = *yy_c_buf_p;
	2083	}
	2084
	2085
	2086	#ifdef YY_USE_PROTOS
	2087	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
	2088	#else
	2089	YY_BUFFER_STATE yy_create_buffer( file, size )
	2090	FILE *file;
	2091	int size;
	2092	#endif
	2093	{
	2094	YY_BUFFER_STATE b;
	2095
	2096	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
	2097	if ( ! b )
	2098	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
	2099
	2100	b->yy_buf_size = size;
	2101
	2102	/* yy_ch_buf has to be 2 characters longer than the size given because
	2103	* we need to put in 2 end-of-buffer characters.
	2104	*/
	2105	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
	2106	if ( ! b->yy_ch_buf )
	2107	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
	2108
	2109	b->yy_is_our_buffer = 1;
	2110
	2111	yy_init_buffer( b, file );
	2112
	2113	return b;
	2114	}
	2115
	2116
	2117	#ifdef YY_USE_PROTOS
	2118	void yy_delete_buffer( YY_BUFFER_STATE b )
	2119	#else
	2120	void yy_delete_buffer( b )
	2121	YY_BUFFER_STATE b;
	2122	#endif
	2123	{
	2124	if ( ! b )
	2125	return;
	2126
	2127	if ( b == yy_current_buffer )
	2128	yy_current_buffer = (YY_BUFFER_STATE) 0;
	2129
	2130	if ( b->yy_is_our_buffer )
	2131	yy_flex_free( (void *) b->yy_ch_buf );
	2132
	2133	yy_flex_free( (void *) b );
	2134	}
	2135
	2136
	2137
	2138	#ifdef YY_USE_PROTOS
	2139	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
	2140	#else
	2141	void yy_init_buffer( b, file )
	2142	YY_BUFFER_STATE b;
	2143	FILE *file;
	2144	#endif
	2145
	2146
	2147	{
	2148	yy_flush_buffer( b );
	2149
	2150	b->yy_input_file = file;
	2151	b->yy_fill_buffer = 1;
	2152
	2153	#if YY_ALWAYS_INTERACTIVE
	2154	b->yy_is_interactive = 1;
	2155	#else
	2156	#if YY_NEVER_INTERACTIVE
	2157	b->yy_is_interactive = 0;
	2158	#else
	2159	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
	2160	#endif
	2161	#endif
	2162	}
	2163
	2164
	2165	#ifdef YY_USE_PROTOS
	2166	void yy_flush_buffer( YY_BUFFER_STATE b )
	2167	#else
	2168	void yy_flush_buffer( b )
	2169	YY_BUFFER_STATE b;
	2170	#endif
	2171
	2172	{
	2173	if ( ! b )
	2174	return;
	2175
	2176	b->yy_n_chars = 0;
	2177
	2178	/* We always need two end-of-buffer characters. The first causes
	2179	* a transition to the end-of-buffer state. The second causes
	2180	* a jam in that state.
	2181	*/
	2182	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	2183	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
	2184
	2185	b->yy_buf_pos = &b->yy_ch_buf[0];
	2186
	2187	b->yy_at_bol = 1;
	2188	b->yy_buffer_status = YY_BUFFER_NEW;
	2189
	2190	if ( b == yy_current_buffer )
	2191	yy_load_buffer_state();
	2192	}
	2193
	2194
	2195	#ifndef YY_NO_SCAN_BUFFER
	2196	#ifdef YY_USE_PROTOS
	2197	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
	2198	#else
	2199	YY_BUFFER_STATE yy_scan_buffer( base, size )
	2200	char *base;
	2201	yy_size_t size;
	2202	#endif
	2203	{
	2204	YY_BUFFER_STATE b;
	2205
	2206	if ( size < 2 \|\|
	2207	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
	2208	base[size-1] != YY_END_OF_BUFFER_CHAR )
	2209	/* They forgot to leave room for the EOB's. */
	2210	return 0;
	2211
	2212	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
	2213	if ( ! b )
	2214	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
	2215
	2216	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
	2217	b->yy_buf_pos = b->yy_ch_buf = base;
	2218	b->yy_is_our_buffer = 0;
	2219	b->yy_input_file = 0;
	2220	b->yy_n_chars = b->yy_buf_size;
	2221	b->yy_is_interactive = 0;
	2222	b->yy_at_bol = 1;
	2223	b->yy_fill_buffer = 0;
	2224	b->yy_buffer_status = YY_BUFFER_NEW;
	2225
	2226	yy_switch_to_buffer( b );
	2227
	2228	return b;
	2229	}
	2230	#endif
	2231
	2232
	2233	#ifndef YY_NO_SCAN_STRING
	2234	#ifdef YY_USE_PROTOS
	2235	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
	2236	#else
	2237	YY_BUFFER_STATE yy_scan_string( yy_str )
	2238	yyconst char *yy_str;
	2239	#endif
	2240	{
	2241	int len;
	2242	for ( len = 0; yy_str[len]; ++len )
	2243	;
	2244
	2245	return yy_scan_bytes( yy_str, len );
	2246	}
	2247	#endif
	2248
	2249
	2250	#ifndef YY_NO_SCAN_BYTES
	2251	#ifdef YY_USE_PROTOS
	2252	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
	2253	#else
	2254	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
	2255	yyconst char *bytes;
	2256	int len;
	2257	#endif
	2258	{
	2259	YY_BUFFER_STATE b;
	2260	char *buf;
	2261	yy_size_t n;
	2262	int i;
	2263
	2264	/* Get memory for full buffer, including space for trailing EOB's. */
	2265	n = len + 2;
	2266	buf = (char *) yy_flex_alloc( n );
	2267	if ( ! buf )
	2268	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
	2269
	2270	for ( i = 0; i < len; ++i )
	2271	buf[i] = bytes[i];
	2272
	2273	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
	2274
	2275	b = yy_scan_buffer( buf, n );
	2276	if ( ! b )
	2277	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
	2278
	2279	/* It's okay to grow etc. this buffer, and we should throw it
	2280	* away when we're done.
	2281	*/
	2282	b->yy_is_our_buffer = 1;
	2283
	2284	return b;
	2285	}
	2286	#endif
	2287
	2288
	2289	#ifndef YY_NO_PUSH_STATE
	2290	#ifdef YY_USE_PROTOS
	2291	static void yy_push_state( int new_state )
	2292	#else
	2293	static void yy_push_state( new_state )
	2294	int new_state;
	2295	#endif
	2296	{
	2297	if ( yy_start_stack_ptr >= yy_start_stack_depth )
	2298	{
	2299	yy_size_t new_size;
	2300
	2301	yy_start_stack_depth += YY_START_STACK_INCR;
	2302	new_size = yy_start_stack_depth * sizeof( int );
	2303
	2304	if ( ! yy_start_stack )
	2305	yy_start_stack = (int *) yy_flex_alloc( new_size );
	2306
	2307	else
	2308	yy_start_stack = (int *) yy_flex_realloc(
	2309	(void *) yy_start_stack, new_size );
	2310
	2311	if ( ! yy_start_stack )
	2312	YY_FATAL_ERROR(
	2313	"out of memory expanding start-condition stack" );
	2314	}
	2315
	2316	yy_start_stack[yy_start_stack_ptr++] = YY_START;
	2317
	2318	BEGIN(new_state);
	2319	}
	2320	#endif
	2321
	2322
	2323	#ifndef YY_NO_POP_STATE
	2324	static void yy_pop_state()
	2325	{
	2326	if ( --yy_start_stack_ptr < 0 )
	2327	YY_FATAL_ERROR( "start-condition stack underflow" );
	2328
	2329	BEGIN(yy_start_stack[yy_start_stack_ptr]);
	2330	}
	2331	#endif
	2332
	2333
	2334	#ifndef YY_NO_TOP_STATE
	2335	static int yy_top_state()
	2336	{
	2337	return yy_start_stack[yy_start_stack_ptr - 1];
	2338	}
	2339	#endif
	2340
	2341	#ifndef YY_EXIT_FAILURE
	2342	#define YY_EXIT_FAILURE 2
	2343	#endif
	2344
	2345	#ifdef YY_USE_PROTOS
	2346	static void yy_fatal_error( yyconst char msg[] )
	2347	#else
	2348	static void yy_fatal_error( msg )
	2349	char msg[];
	2350	#endif
	2351	{
	2352	(void) fprintf( stderr, "%s\n", msg );
	2353	exit( YY_EXIT_FAILURE );
	2354	}
	2355
	2356
	2357
	2358	/* Redefine yyless() so it works in section 3 code. */
	2359
	2360	#undef yyless
	2361	#define yyless(n) \
	2362	do \
	2363	{ \
	2364	/* Undo effects of setting up yytext. */ \
	2365	yytext[yyleng] = yy_hold_char; \
	2366	yy_c_buf_p = yytext + n; \
	2367	yy_hold_char = *yy_c_buf_p; \
	2368	*yy_c_buf_p = '\0'; \
	2369	yyleng = n; \
	2370	} \
	2371	while ( 0 )
	2372
	2373
	2374	/* Internal utility routines. */
	2375
	2376	#ifndef yytext_ptr
	2377	#ifdef YY_USE_PROTOS
	2378	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
	2379	#else
	2380	static void yy_flex_strncpy( s1, s2, n )
	2381	char *s1;
	2382	yyconst char *s2;
	2383	int n;
	2384	#endif
	2385	{
	2386	register int i;
	2387	for ( i = 0; i < n; ++i )
	2388	s1[i] = s2[i];
	2389	}
	2390	#endif
	2391
	2392	#ifdef YY_NEED_STRLEN
	2393	#ifdef YY_USE_PROTOS
	2394	static int yy_flex_strlen( yyconst char *s )
	2395	#else
	2396	static int yy_flex_strlen( s )
	2397	yyconst char *s;
	2398	#endif
	2399	{
	2400	register int n;
	2401	for ( n = 0; s[n]; ++n )
	2402	;
	2403
	2404	return n;
	2405	}
	2406	#endif
	2407
	2408
	2409	#ifdef YY_USE_PROTOS
	2410	static void *yy_flex_alloc( yy_size_t size )
	2411	#else
	2412	static void *yy_flex_alloc( size )
	2413	yy_size_t size;
	2414	#endif
	2415	{
	2416	return (void *) malloc( size );
	2417	}
	2418
	2419	#ifdef YY_USE_PROTOS
	2420	static void yy_flex_realloc( void ptr, yy_size_t size )
	2421	#else
	2422	static void *yy_flex_realloc( ptr, size )
	2423	void *ptr;
	2424	yy_size_t size;
	2425	#endif
	2426	{
	2427	/* The cast to (char *) in the following accommodates both
	2428	* implementations that use char* generic pointers, and those
	2429	* that use void* generic pointers. It works with the latter
	2430	* because both ANSI C and C++ allow castless assignment from
	2431	* any pointer type to void*, and deal with argument conversions
	2432	* as though doing an assignment.
	2433	*/
	2434	return (void ) realloc( (char ) ptr, size );
	2435	}
	2436
	2437	#ifdef YY_USE_PROTOS
	2438	static void yy_flex_free( void *ptr )
	2439	#else
	2440	static void yy_flex_free( ptr )
	2441	void *ptr;
	2442	#endif
	2443	{
	2444	free( ptr );
	2445	}
	2446
	2447	#if YY_MAIN
	2448	int main()
	2449	{
	2450	yylex();
	2451	return 0;
	2452	}
	2453	#endif
	2454	#line 389 "rc1.0_tokens.l"
	2455
	2456
	2457	bool rc10_init_more();
	2458
	2459	bool rc10_init(char* inputString)
	2460	{
	2461	myin = inputString;
	2462	return rc10_init_more();
	2463	}
	2464
	2465	#ifndef rc10_wrap
	2466	int rc10_wrap(void)
	2467	{
	2468	return(1);
	2469	}
	2470	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: