Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
.
authormquinson <mquinson@48e7efb5-ca39-0410-a469-dd3cf9ba447f>
Fri, 15 Apr 2005 14:30:24 +0000 (14:30 +0000)
committermquinson <mquinson@48e7efb5-ca39-0410-a469-dd3cf9ba447f>
Fri, 15 Apr 2005 14:30:24 +0000 (14:30 +0000)
git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@1223 48e7efb5-ca39-0410-a469-dd3cf9ba447f

src/surf/surfxml.c [new file with mode: 0644]

diff --git a/src/surf/surfxml.c b/src/surf/surfxml.c
new file mode 100644 (file)
index 0000000..728292f
--- /dev/null
@@ -0,0 +1,4560 @@
+#line 2 "surf/surfxml.c"
+
+#line 4 "surf/surfxml.c"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 31
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+#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;
+#endif /* ! C99 */
+
+/* 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 /* ! FLEXINT_H */
+
+#ifdef __cplusplus
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else  /* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_CONST
+
+#endif /* __STDC__ */
+#endif /* ! __cplusplus */
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN (yy_start) = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START (((yy_start) - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE surf_parse_restart(surf_parse_in  )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#define YY_BUF_SIZE 16384
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+extern int surf_parse_leng;
+
+extern FILE *surf_parse_in, *surf_parse_out;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    /* 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 surf_parse_lex. 
+     *       One obvious solution it to make yy_act a global. I tried that, and saw
+     *       a 5% performance hit in a non-surf_parse_lineno 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 < surf_parse_leng; ++yyl )\
+                    if ( surf_parse_text[yyl] == '\n' )\
+                        --surf_parse_lineno;\
+            }while(0)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up surf_parse_text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               *yy_cp = (yy_hold_char); \
+               YY_RESTORE_YY_MORE_OFFSET \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up surf_parse_text 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).
+ */
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef unsigned int yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+       {
+       FILE *yy_input_file;
+
+       char *yy_ch_buf;                /* input buffer */
+       char *yy_buf_pos;               /* current position in input buffer */
+
+       /* Size of input buffer in bytes, not including room for EOB
+        * characters.
+        */
+       yy_size_t yy_buf_size;
+
+       /* Number of characters read into yy_ch_buf, not including EOB
+        * characters.
+        */
+       int yy_n_chars;
+
+       /* Whether we "own" the buffer - i.e., we know we created it,
+        * and can realloc() it to grow it, and should free() it to
+        * delete it.
+        */
+       int yy_is_our_buffer;
+
+       /* Whether this is an "interactive" input source; if so, and
+        * if we're using stdio for input, then we want to use getc()
+        * instead of fread(), to make sure we stop fetching input after
+        * each newline.
+        */
+       int yy_is_interactive;
+
+       /* Whether we're considered to be at the beginning of a line.
+        * If so, '^' rules will be active on the next match, otherwise
+        * not.
+        */
+       int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+       /* Whether to try to fill the input buffer when we reach the
+        * end of it.
+        */
+       int yy_fill_buffer;
+
+       int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+       /* When an EOF's been seen but there's still some text to process
+        * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+        * shouldn't try reading from the input source any more.  We might
+        * still have a bunch of tokens to match, though, because of
+        * possible backing-up.
+        *
+        * When we actually see the EOF, we change the status to "new"
+        * (via surf_parse_restart()), so that the user can continue scanning by
+        * just pointing surf_parse_in at a new input file.
+        */
+#define YY_BUFFER_EOF_PENDING 2
+
+       };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
+
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
+
+/* yy_hold_char holds the character lost when surf_parse_text is formed. */
+static char yy_hold_char;
+static int yy_n_chars;         /* number of characters read into yy_ch_buf */
+int surf_parse_leng;
+
+/* 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 surf_parse_wrap()'s to do buffer switches
+ * instead of setting up a fresh surf_parse_in.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void surf_parse_restart (FILE *input_file  );
+void surf_parse__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE surf_parse__create_buffer (FILE *file,int size  );
+void surf_parse__delete_buffer (YY_BUFFER_STATE b  );
+void surf_parse__flush_buffer (YY_BUFFER_STATE b  );
+void surf_parse_push_buffer_state (YY_BUFFER_STATE new_buffer  );
+void surf_parse_pop_buffer_state (void );
+
+static void surf_parse_ensure_buffer_stack (void );
+static void surf_parse__load_buffer_state (void );
+static void surf_parse__init_buffer (YY_BUFFER_STATE b,FILE *file  );
+
+#define YY_FLUSH_BUFFER surf_parse__flush_buffer(YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE surf_parse__scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE surf_parse__scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE surf_parse__scan_bytes (yyconst char *bytes,int len  );
+
+void *surf_parse_alloc (yy_size_t  );
+void *surf_parse_realloc (void *,yy_size_t  );
+void surf_parse_free (void *  );
+
+#define yy_new_buffer surf_parse__create_buffer
+
+#define yy_set_interactive(is_interactive) \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        surf_parse_ensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+       }
+
+#define yy_set_bol(at_bol) \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){\
+        surf_parse_ensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+       }
+
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define surf_parse_wrap(n) 1
+#define YY_SKIP_YYWRAP
+
+typedef unsigned char YY_CHAR;
+
+FILE *surf_parse_in = (FILE *) 0, *surf_parse_out = (FILE *) 0;
+
+typedef int yy_state_type;
+
+extern int surf_parse_lineno;
+
+int surf_parse_lineno = 1;
+
+extern char *surf_parse_text;
+#define yytext_ptr surf_parse_text
+
+static yy_state_type yy_get_previous_state (void );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
+static int yy_get_next_buffer (void );
+static void yy_fatal_error (yyconst char msg[]  );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up surf_parse_text.
+ */
+#define YY_DO_BEFORE_ACTION \
+       (yytext_ptr) = yy_bp; \
+       surf_parse_leng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
+       *yy_cp = '\0'; \
+       (yy_c_buf_p) = yy_cp;
+
+#define YY_NUM_RULES 168
+#define YY_END_OF_BUFFER 169
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
+static yyconst flex_int16_t yy_accept[1256] =
+    {   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,  169,  167,   22,   10,   10,   22,   22,  147,
+
+       10,  147,    5,    6,    5,    8,    9,    8,  163,  155,
+      156,  164,  161,  164,  162,  166,  155,  156,  166,  167,
+       26,   10,   26,   26,   26,   24,   30,   10,   30,  167,
+       30,  167,   36,   10,   36,   36,   36,   34,   36,   40,
+       10,   40,   40,  167,   66,   10,   66,   66,   66,   64,
+       66,   66,   66,   66,   66,   66,   70,   10,   70,  167,
+       90,   10,   90,   90,   90,   88,   90,   90,   90,   90,
+       94,   10,   94,  167,  110,   10,  110,  110,  110,  108,
+      110,  110,  110,  114,   10,  114,  167,  114,  120,   10,
+      120,  120,  120,  118,  120,  124,   10,  124,  167,  132,
+
+       10,  132,  132,  132,  130,  132,  132,  136,   10,  136,
+      167,  136,  142,   10,  142,  142,  142,  140,  142,  146,
+       10,  146,  164,  163,   10,    0,    2,    2,    0,    4,
+        7,  158,  157,    0,    0,    0,    0,    0,    0,    0,
+       25,   27,    0,    0,    0,    0,    0,    0,   35,   37,
+       37,    0,   65,   67,   67,   67,   67,   67,   67,   67,
+        0,   89,   91,   91,   91,   91,   91,    0,  109,  111,
+      111,  111,  111,    0,    0,  119,  121,  121,    0,  131,
+      133,  133,  133,    0,    0,  141,  143,  143,    0,    0,
+        0,    0,    0,    0,    0,    3,    0,    0,    0,    0,
+
+        0,    0,    0,  165,    0,    0,    0,    0,    0,    0,
+        0,    0,   37,    0,    0,   67,   67,   67,   67,   67,
+       67,    0,    0,   91,   91,   91,   91,    0,    0,  111,
+      111,  111,    0,    0,    0,  121,    0,    0,  133,  133,
+        0,    0,    0,  143,    0,    0,    0,  160,    0,   21,
+        1,    0,    0,  153,    0,    0,    0,  150,  149,    0,
+        0,    0,    0,   29,    0,   41,    0,    0,    0,    0,
+       37,    0,    0,   39,    0,   67,   67,   67,   67,   67,
+       67,    0,    0,   69,    0,   91,   91,   91,   91,    0,
+        0,   93,    0,    0,    0,  111,    0,    0,    0,    0,
+
+      113,    0,    0,  121,    0,    0,  123,    0,  133,  133,
+        0,    0,  135,    0,    0,  143,    0,    0,  145,    0,
+        0,    0,    0,  154,  148,    0,    0,    0,    0,   41,
+        0,    0,    0,    0,    0,    0,    0,   67,   67,   67,
+        0,    0,   67,   67,    0,   91,   91,    0,    0,   91,
+        0,    0,   99,   98,  111,    0,   97,   96,    0,    0,
+        0,    0,    0,  133,    0,    0,    0,    0,  143,    0,
+        0,    0,    0,    0,   12,    0,  151,  152,    0,    0,
+        0,    0,    0,   95,    0,   33,   32,    0,   67,   67,
+       67,    0,   43,   42,    0,    0,    0,    0,   67,    0,
+
+       68,   91,   91,    0,   73,   72,    0,    0,   91,    0,
+      111,    0,    0,    0,  117,  116,    0,  133,    0,  127,
+      126,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       11,    0,    0,    0,    0,    0,   95,    0,   67,   67,
+       67,    0,   45,   44,    0,    0,    0,   67,   91,   91,
+        0,    0,    0,   91,    0,  111,    0,    0,    0,  133,
+        0,    0,    0,  139,  138,    0,    0,    0,    0,    0,
+        0,    0,   31,    0,  125,    0,   67,   67,   67,    0,
+        0,   67,   91,    0,    0,   91,    0,    0,   91,    0,
+      111,    0,  112,    0,    0,  133,    0,    0,    0,    0,
+
+        0,    0,    0,    0,    0,   31,    0,  125,    0,   67,
+       67,   67,    0,    0,    0,    0,   67,   91,    0,   79,
+       78,   91,    0,    0,    0,    0,   91,    0,  111,    0,
+        0,    0,    0,    0,  137,    0,  159,    0,    0,    0,
+        0,    0,    0,    0,   38,   67,   67,   67,    0,   51,
+        0,   50,   67,    0,    0,   91,   91,    0,   83,    0,
+       82,   91,    0,  111,    0,    0,    0,  129,  128,    0,
+      134,  137,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   67,   67,   67,   53,   52,    0,
+        0,    0,   75,   74,   91,   91,   85,   84,    0,    0,
+
+        0,  111,  111,    0,    0,    0,  144,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,   67,
+       67,   67,    0,   55,   54,   91,   91,    0,   87,   86,
+        0,  111,  111,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,   71,    0,    0,   67,
+       67,   67,   91,    0,    0,    0,  111,  111,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,   71,    0,   47,   46,   67,   67,   67,   67,
+       91,    0,   81,   80,    0,    0,    0,  111,    0,    0,
+      111,  115,    0,    0,    0,    0,    0,    0,    0,    0,
+
+        0,    0,    0,    0,    0,    0,    0,   67,   67,   67,
+       67,    0,    0,    0,   92,    0,  103,  102,  111,    0,
+      101,  100,  111,  115,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       67,   67,   67,   67,    0,   77,   76,  111,  111,    0,
+      122,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   12,    0,   12,    0,    0,    0,   67,   67,   67,
+       67,  111,  111,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   67,    0,    0,  111,  111,    0,    0,
+
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       49,   48,    0,   59,   58,    0,   57,   56,   67,    0,
+       63,   62,  111,  111,    0,    0,    0,    0,    0,    0,
+        0,    0,   11,    0,    0,   67,  111,  111,    0,    0,
+        0,    0,    0,    0,    0,    0,   23,    0,   67,  111,
+      111,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       23,    0,   67,  111,  111,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,   28,    0,    0,  111,  111,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   61,   60,  111,  111,    0,    0,    0,    0,    0,
+
+        0,    0,    0,    0,    0,  111,  111,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,  111,
+      111,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,  111,  111,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,  111,
+      111,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,  111,  111,    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,  107,  106,
+
+        0,  105,  104,    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,
+       15,    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,   17,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,   16,    0,
+
+        0,    0,    0,    0,   20,    0,    0,    0,   13,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   19,    0,    0,    0,    0,    0,    0,
+       14,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   18,    0
+    } ;
+
+static yyconst flex_int32_t yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    2,    4,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    5,    6,    7,    1,    1,    8,    9,    1,
+        1,    1,    1,    1,   10,   11,   12,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   14,   15,   16,
+       17,   18,   19,    1,   20,   21,   22,   23,   24,   25,
+       14,   14,   14,   14,   14,   14,   26,   27,   28,   29,
+       14,   14,   30,   31,   14,   14,   14,   14,   32,   14,
+       33,    1,   34,    1,   35,    1,   36,   37,   38,   39,
+
+       40,   41,   42,   43,   44,   14,   45,   46,   47,   48,
+       49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
+       59,   14,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst flex_int32_t yy_meta[60] =
+    {   0,
+        1,    2,    2,    2,    1,    1,    1,    1,    1,    3,
+        3,    1,    4,    5,    1,    1,    1,    6,    1,    7,
+        7,    7,    7,    7,    7,    5,    5,    5,    5,    5,
+        5,    5,    1,    1,    5,    7,    7,    7,    7,    7,
+        7,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5
+    } ;
+
+static yyconst flex_int16_t yy_base[1311] =
+    {   0,
+        0,    0,    0,    3,    6,    9,   24,   27,   11,   14,
+       15,   17,   29,   38,   45,   52,   59,   61,   67,   70,
+       95,  129,   73,   76,  148,  151,  154,  157,  172,  175,
+      178,  181,  197,  238,  216,  219,  257,  260,  264,  279,
+      282,  285,  288,  303,  319,    0,  377,  380,  383,  386,
+      402,    0,  460,  463,  466,  469,  485,  538,  504,  507,
+      510,  557,  560,  563,  581,  584,  590,  599,  615,  663,
+      634,  637,  640,  643,  711,  754,  682,  685,  688,  691,
+      730,  733,  737,  773,  776,  780,  797,  853,  816,  819,
+      833,  872, 3532, 3533, 3533,  113,  116,   47,   62, 3533,
+
+      119,  167, 3533, 3533, 3521, 3533, 3533, 3512, 3533, 3525,
+     3525,  267, 3533, 3533, 3533, 3533, 3523, 3523, 3491,  585,
+     3533,  122, 3506,    0,  206, 3533, 3533,  224,  872,  873,
+      516,  570, 3533,  308, 3505,    0,  289, 3533, 3478, 3533,
+      312,  888,  593,  591, 3533,  513, 3503,    0,  517, 3533,
+     3464, 3471, 3482, 3481, 3467, 3461, 3533,  528,  821,  833,
+     3533,  566, 3496,    0,  576, 3533, 3477, 3476, 3475, 3456,
+     3533,  605,  877,  878, 3533,  658, 3491,    0,  594, 3533,
+     3455, 3460, 3454, 3533,  706,  889,  885,  893, 3533,  825,
+     3487,    0,  806, 3533, 3468, 3533,  840,  923,  829, 3533,
+
+      843, 3485,    0,  880, 3533, 3447, 3452, 3533,  911,  934,
+      914,  939, 3533,  945, 3482,    0,  924, 3533, 3463, 3533,
+      952,  940, 3493, 3463,  958,   34, 3438, 3533, 3485, 3476,
+     3533, 3533, 3533,   26,   35, 3439, 3438, 3436, 3472, 3443,
+     3533,    0, 3438, 3437, 3438, 3445, 3432, 3434, 3533,    0,
+     3436, 3437, 3533,    0, 3444, 3425, 3420, 3430, 3419, 3439,
+     3436, 3533,    0, 3425, 3418, 3424, 3434, 3421, 3533,    0,
+     3414, 3417, 3428, 3413, 3415, 3533,    0, 3416, 3410, 3533,
+        0, 3413, 3407, 3409, 3406, 3533,    0, 3411, 3420, 3422,
+     3436, 3435, 3442,  206, 3404, 3533,   75,    0, 3400, 3400,
+
+     3433, 3432, 3397, 3533, 3409,  961,  964, 3389, 3405, 3388,
+     3392, 3385, 3399,  969,  972, 3394, 3397, 3401, 3395, 3394,
+     3379,  981,  989, 3393, 3391, 3390, 3375,  993,  998, 1001,
+     3392, 1010, 1019, 1022, 3372, 3386, 1026, 1029, 3387, 3370,
+     1032, 1039, 3381, 3367, 1049, 1052, 3399, 3533, 3402, 3533,
+     3533,   69, 3373, 3533, 3403, 3402, 3363, 3533, 3533, 3361,
+     3360, 1056, 1059, 3533, 1062, 1079, 3367, 3355, 3373, 3356,
+     1082, 1085, 1090, 3533, 1093, 3363, 3356, 3358, 1098, 3354,
+     3365, 1103, 1110, 3533, 1114, 3347, 3355, 1120, 3362, 1123,
+     1131, 3533, 1136, 1140, 1144, 3363, 1156, 1159, 1168, 1173,
+
+     3533, 1176, 3346, 1179, 1185, 1195, 3533, 1198, 3345, 1202,
+     1205, 1208, 3533, 1218, 3343, 3357, 1225, 1230, 3533, 1236,
+     3373,  234, 1242, 3533, 3533, 3380, 3379, 3352, 1247, 1253,
+     3337, 3342, 3350, 3349, 1260, 1266, 1277, 3352, 3346, 3331,
+     1280, 1283, 1296, 1300, 1303, 3341, 3346, 1307, 1316, 1312,
+     1324, 1328, 3533, 3533, 3329, 1337, 3533, 3533, 1346, 3342,
+     1349, 1352, 1365, 3337, 1368, 1371, 1384, 3333, 1387, 1390,
+     3359,  962, 3360, 1393, 3533, 3359, 3533, 3533, 3327, 1403,
+     3336, 3322, 3320, 1410, 1414, 3533, 3533, 1422, 3335, 3331,
+     3316, 1425, 3533, 3533, 1433, 1449, 1439, 1457, 3328, 1444,
+
+     3533, 3329, 3308, 1465, 3533, 3533, 1476, 1479, 3325, 1487,
+     3330, 1492, 3329, 1495, 3533, 3533, 1504, 3314, 1509, 3533,
+     3533, 1517, 3322, 1521, 1524, 1537, 3330,  240,  147,  109,
+     3533, 3308, 1543, 3319, 3313, 3304, 1546, 1549, 3312, 3303,
+     3312, 1556, 3533, 3533, 1566, 3325, 3324, 3307, 3296, 1574,
+     1577, 3321, 3320, 3303, 1592, 3297, 1595, 3305, 1598, 3296,
+     1601, 3295, 1618, 3533, 3533, 1627, 3322,  169,  151,   91,
+     3294, 1632, 1604, 3305, 1635, 1638, 3293, 3298, 3288,  141,
+      165, 3290, 3292, 1644, 1649, 3293,  250,  272, 3287, 1661,
+     3284, 1667, 3533, 3285, 1670, 1673, 1678, 3276, 1689, 3296,
+
+     1695,  456,   41, 3293, 1698, 1701, 3281, 1715, 1718, 3282,
+     3277, 3280, 3298, 3316, 3296, 3311, 3279, 1721, 1724, 3533,
+     3533, 3274, 3292, 3310, 3290, 3207, 3175, 1737, 3170, 3162,
+     1740, 1744, 1748, 1760, 1763, 1766, 3533, 1819,  178,  252,
+     3160, 1771, 3152, 1777, 3533, 3139, 3152, 3139, 3178, 3533,
+     3172, 3533, 1788, 1794, 1798, 3133, 3123, 3158, 3533, 3150,
+     3533, 1810, 1806, 1037, 3107, 1813, 1826, 3533, 3533, 1836,
+     3533, 1839, 1842,  481,  633,  720,  260,  963,  509,  534,
+      562, 3109, 1846, 3096, 3080, 2947, 2944, 3533, 3533, 1870,
+     1873, 1886, 3533, 3533, 2941, 2944, 3533, 3533, 1894, 1897,
+
+     1905, 2929, 2929, 2940, 1910, 1913, 3533,  275,  519,  639,
+      688,  707,  682,  730,  733,  776, 2926, 1916, 2933, 1923,
+     2942, 2941, 1933, 3533, 3533, 2929, 1942, 1958, 3533, 3533,
+     1948, 2914, 2927, 2915, 1951,  951, 1968,  856,  729,  877,
+      939, 1055,  732, 1971, 2923, 1974, 1977, 1980, 1996, 2919,
+      184, 2902, 2874, 1991, 2007, 2015, 2018, 2021, 2736, 2026,
+      970, 2037,  990,  885,  832,  799, 1028, 2044, 2047, 2066,
+     2684, 2055, 2074, 2077, 3533, 3533, 2677, 2605, 2594, 2595,
+     2085, 2088, 3533, 3533, 2096, 2101, 2104, 2526, 2113, 2117,
+     2453, 2125, 2129, 1111, 1134,  980, 1112, 1030, 1057, 2132,
+
+     2135, 2139, 2152, 2183, 2217, 2411, 2160, 2395, 2360, 2320,
+     2284, 2177, 2201, 2235, 3533, 2238, 3533, 3533, 2247, 2252,
+     3533, 3533, 2205, 2169, 2260, 1137,    5, 1127, 1196, 1166,
+     1177, 2263, 1175, 2266, 1219,  382, 2293, 2327, 2196, 2319,
+     2126, 2055, 2057, 2055, 2283, 3533, 3533, 1980, 1977, 2346,
+     3533, 1102, 1240, 2349, 1101, 1229, 2352, 1234, 1290, 1327,
+      376, 1984,  383, 1978, 2355, 1884, 2373, 2211, 2376, 2379,
+     2382, 1879, 1862, 2385,  457, 2398, 1364, 1224, 2402, 1385,
+     1256, 1874, 1859, 1849, 2406, 1732, 2409, 2427, 2311, 2431,
+     2434, 2447, 2450, 1659, 2458, 2463, 1576, 1343, 2474,  960,
+
+     1344, 1294, 1255, 1347, 1326, 1383, 1342, 1310, 2477, 2480,
+     3533, 3533, 2494, 3533, 3533, 2503, 3533, 3533, 1253, 2511,
+     3533, 3533, 1242, 1241, 1366, 2520, 1446, 1391, 1414, 1454,
+      459, 1447, 3533, 1240, 2523, 1197, 1163, 1120, 1484, 2526,
+     1439, 1455, 1511, 1485, 1491, 1525, 2172, 2543, 1016,  946,
+      808, 1556, 1513, 1536,  460, 2546, 1031,  634, 2549, 1345,
+     2415, 2552, 2556,  753,  751,  681, 1420, 1516, 1564, 2572,
+     1597, 1567, 2575, 2583, 2592, 3533, 2595, 2602,  738,  651,
+     1599, 1605, 1608, 2611, 1524, 1519, 2614, 1641, 1696, 2617,
+     2621, 3533, 3533,  667,  620, 2634, 1625, 1668, 2637, 1665,
+
+     1174, 2647, 1716, 1764, 1596,  601,  428, 2655, 1650, 1671,
+     1735, 1741, 1816, 1807, 1765, 1815, 1818, 1841, 1769,  358,
+      357, 1833, 1838, 1847, 1863, 1866, 1886, 1468, 1759, 1930,
+     1988, 1694, 1906, 1912,  254,  195, 1997, 2008, 1669, 1714,
+     1911, 1985, 1767, 1884, 2014, 2094, 1808, 1996, 1594,  190,
+      115, 2107, 2159, 2133, 2234, 2083, 2190, 2664, 1614, 2230,
+     2239, 1989, 2024, 1986, 2667, 2672, 2241, 2242, 1844, 2188,
+     2027, 2064, 2677, 2688, 2091, 2151, 2122, 2147, 2694, 2697,
+     2701, 2713, 2716, 2258, 2261, 1914, 1947, 2256, 2259, 2272,
+     2344, 2724, 2300, 2322, 2354, 2404, 2729, 2737, 3533, 3533,
+
+     2746, 3533, 3533, 2348, 2374, 2408, 2452, 2427, 2439, 2142,
+     2286, 2164, 2453, 2456, 2469, 2472, 2372, 2389, 2470, 2516,
+     2513,  516, 2483, 2522, 2255, 2519, 2539, 2525, 2571, 2270,
+     2574, 2545, 2548, 2615, 2667, 2754, 2500, 2570, 2353, 2524,
+     2212, 2624, 2654, 2669, 2670, 2642, 2659, 2684, 2695, 2757,
+     3533, 2711, 2719, 2604, 2706, 2630, 2726, 2727, 2562,  909,
+     2733, 2735, 2744, 2745, 2748, 2749, 2421, 2750, 2751, 2752,
+     2753, 2782, 2760, 2761, 2764, 2765, 2783, 2784, 2776, 2777,
+     2803, 2790, 2802, 2810, 3533, 2791, 2792, 2809, 2807, 2827,
+     2806, 2815, 2838, 2832, 2814, 2819, 2849, 2855, 3533, 2825,
+
+     2830, 2440, 2828, 2859, 3533, 2857, 2860, 2880, 3533, 2831,
+     2836, 2589, 2837, 2848, 2852, 2854, 2856, 2858, 2861, 2862,
+     2868, 2882, 2885, 2871, 2878, 2879, 2881, 2903, 2883, 2884,
+     2905, 2899, 2922, 3533, 2886, 2891, 2925, 2912, 2913, 2932,
+     3533, 2921, 2926, 2927, 2928, 2897, 2929, 2930, 2931, 2946,
+     2944, 2953, 2970, 3533, 3533, 2988, 2995, 3002, 3009, 3016,
+     3023, 3030, 3037, 3044, 3051, 3058, 3065, 3072, 3079, 3086,
+     3093, 3100, 3107, 3114, 3121, 3128, 3133, 3138, 3143, 3148,
+     3153, 3158, 3163, 3168, 3175, 3178, 3181, 3184, 3187, 3190,
+     3193, 3196, 3199, 3206, 3210, 3216, 3222, 3228, 3234, 3240,
+
+     3246, 3252, 3258, 3265, 3272, 3279, 3286, 3293, 3300, 3307
+    } ;
+
+static yyconst flex_int16_t yy_def[1311] =
+    {   0,
+     1256, 1256, 1257, 1257, 1257, 1257, 1258, 1258, 1259, 1259,
+     1260, 1260, 1261, 1261, 1261, 1261, 1262, 1262, 1256, 1256,
+     1263, 1263, 1264, 1264, 1256, 1256, 1264, 1264, 1264, 1264,
+     1256, 1256, 1265, 1265, 1266, 1266, 1256, 1256, 1266, 1266,
+     1266, 1266, 1256, 1256, 1255,   45, 1267, 1267, 1256, 1256,
+     1255,   51, 1268, 1268, 1256, 1256, 1269, 1269, 1270, 1270,
+     1256, 1256, 1270, 1270, 1270, 1270, 1256, 1256, 1271, 1271,
+     1272, 1272, 1256, 1256, 1273, 1273, 1274, 1274, 1256, 1256,
+     1274, 1274, 1274, 1274, 1256, 1256, 1275, 1275, 1276, 1276,
+     1261, 1261, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1277, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1278, 1255, 1255, 1278, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1279, 1255, 1255,
+     1279, 1279, 1279, 1279, 1279, 1279, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1280, 1255, 1255, 1280, 1280, 1280, 1280,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1281, 1255, 1255,
+     1281, 1281, 1281, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1282, 1255, 1255, 1282, 1255, 1255, 1255, 1255, 1255,
+
+     1255, 1255, 1283, 1255, 1255, 1283, 1283, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1284, 1255, 1255, 1284, 1255,
+     1255, 1255, 1255, 1255, 1255, 1285, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1277, 1286, 1255, 1255, 1255, 1255, 1255, 1255, 1278,
+     1278, 1287, 1255, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
+     1288, 1255, 1280, 1280, 1280, 1280, 1280, 1289, 1255, 1281,
+     1281, 1281, 1281, 1290, 1255, 1255, 1282, 1282, 1291, 1255,
+     1283, 1283, 1283, 1292, 1255, 1255, 1284, 1284, 1293, 1255,
+     1255, 1294, 1255, 1294, 1255, 1255, 1255, 1295, 1255, 1255,
+
+     1255, 1255, 1255, 1255, 1255, 1296, 1296, 1255, 1255, 1255,
+     1255, 1255, 1278, 1297, 1297, 1279, 1279, 1279, 1279, 1279,
+     1279, 1298, 1298, 1280, 1280, 1280, 1280, 1299, 1299, 1281,
+     1281, 1281, 1300, 1300, 1255, 1282, 1301, 1301, 1283, 1283,
+     1302, 1302, 1255, 1284, 1303, 1303, 1255, 1255, 1294, 1255,
+     1255, 1294, 1255, 1255, 1295, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1296, 1255, 1296, 1255, 1255, 1255, 1255, 1255,
+     1278, 1255, 1297, 1255, 1297, 1279, 1279, 1279, 1279, 1279,
+     1279, 1255, 1298, 1255, 1298, 1280, 1280, 1280, 1280, 1255,
+     1299, 1255, 1299, 1255, 1255, 1281, 1255, 1255, 1255, 1300,
+
+     1255, 1300, 1255, 1282, 1255, 1301, 1255, 1301, 1283, 1283,
+     1255, 1302, 1255, 1302, 1255, 1284, 1255, 1303, 1255, 1303,
+     1255, 1294, 1304, 1255, 1255, 1255, 1255, 1255, 1296, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1297, 1279, 1279, 1279,
+     1255, 1255, 1279, 1279, 1298, 1280, 1280, 1255, 1255, 1280,
+     1299, 1255, 1255, 1255, 1281, 1255, 1255, 1255, 1300, 1255,
+     1255, 1255, 1301, 1283, 1255, 1255, 1302, 1255, 1284, 1303,
+     1255, 1294, 1304, 1304, 1255, 1304, 1255, 1255, 1255, 1296,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1297, 1279, 1279,
+     1279, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1279, 1255,
+
+     1255, 1280, 1280, 1255, 1255, 1255, 1255, 1255, 1280, 1299,
+     1281, 1300, 1255, 1255, 1255, 1255, 1301, 1283, 1255, 1255,
+     1255, 1302, 1255, 1255, 1255, 1303, 1255, 1294, 1304, 1304,
+     1255, 1255, 1296, 1255, 1255, 1255, 1255, 1297, 1279, 1279,
+     1279, 1255, 1255, 1255, 1255, 1255, 1255, 1279, 1280, 1280,
+     1255, 1255, 1255, 1280, 1299, 1281, 1300, 1255, 1301, 1283,
+     1302, 1255, 1255, 1255, 1255, 1303, 1255, 1294, 1304, 1304,
+     1255, 1296, 1255, 1255, 1255, 1297, 1279, 1279, 1279, 1255,
+     1255, 1279, 1280, 1255, 1255, 1280, 1255, 1255, 1280, 1299,
+     1281, 1255, 1255, 1255, 1301, 1283, 1302, 1255, 1303, 1255,
+
+     1294, 1304, 1304, 1255, 1296, 1255, 1255, 1255, 1297, 1279,
+     1279, 1279, 1255, 1255, 1255, 1255, 1279, 1280, 1255, 1255,
+     1255, 1280, 1255, 1255, 1255, 1255, 1280, 1299, 1281, 1255,
+     1301, 1255, 1255, 1302, 1255, 1303, 1255, 1294, 1304, 1304,
+     1255, 1296, 1255, 1255, 1255, 1279, 1279, 1279, 1255, 1255,
+     1255, 1255, 1279, 1255, 1255, 1280, 1280, 1255, 1255, 1255,
+     1255, 1280, 1299, 1281, 1255, 1301, 1255, 1255, 1255, 1255,
+     1255, 1255, 1303, 1294, 1294, 1294, 1294, 1294, 1294, 1304,
+     1304, 1255, 1296, 1255, 1279, 1279, 1279, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1280, 1280, 1255, 1255, 1255, 1255,
+
+     1299, 1281, 1281, 1255, 1301, 1255, 1255, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1304, 1304, 1255, 1296, 1255, 1279,
+     1279, 1279, 1255, 1255, 1255, 1280, 1280, 1255, 1255, 1255,
+     1299, 1281, 1281, 1255, 1301, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1304, 1304, 1255, 1296, 1255, 1255, 1255, 1279,
+     1279, 1279, 1280, 1255, 1255, 1299, 1281, 1281, 1255, 1301,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1304, 1304, 1304,
+     1255, 1296, 1255, 1255, 1255, 1255, 1279, 1279, 1279, 1279,
+     1280, 1255, 1255, 1255, 1299, 1255, 1255, 1281, 1255, 1255,
+     1281, 1255, 1301, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+
+     1304, 1304, 1304, 1305, 1306, 1255, 1296, 1279, 1279, 1279,
+     1279, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1281, 1255,
+     1255, 1255, 1281, 1255, 1301, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1304, 1307, 1308, 1305, 1306, 1255, 1296,
+     1279, 1279, 1279, 1279, 1255, 1255, 1255, 1281, 1281, 1255,
+     1255, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1307,
+     1304, 1309, 1308, 1310, 1304, 1255, 1296, 1279, 1279, 1279,
+     1279, 1281, 1281, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1309, 1255, 1310, 1304, 1255, 1296, 1255, 1255, 1255,
+     1255, 1255, 1255, 1279, 1255, 1255, 1281, 1281, 1294, 1294,
+
+     1294, 1294, 1294, 1294, 1294, 1294, 1255, 1255, 1296, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1279, 1255,
+     1255, 1255, 1281, 1281, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1255, 1255, 1296, 1279, 1281, 1281, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1255, 1296, 1279, 1281,
+     1281, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1255, 1296, 1279, 1281, 1281, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1255, 1255, 1255, 1255, 1281, 1281,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1255, 1255, 1255, 1281, 1281, 1294, 1294, 1294, 1294, 1294,
+
+     1294, 1294, 1294, 1294, 1294, 1281, 1281, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1281,
+     1281, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1281, 1281, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1281,
+     1281, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1281, 1281, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1255,
+     1255, 1255, 1255, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1255, 1255, 1255,
+
+     1255, 1255, 1255, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1255, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1255, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1255, 1294,
+
+     1294, 1294, 1294, 1294, 1255, 1294, 1294, 1294, 1255, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1255, 1294, 1294, 1294, 1294, 1294, 1294,
+     1255, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1255,    0, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255
+    } ;
+
+static yyconst flex_int16_t yy_nxt[3593] =
+    {   0,
+     1255,   96,   97,   96,   96,   97,   96,   96,   97,   96,
+       96,   97,   96,  104, 1255,   98,  104,  107,   98,  107,
+      105,   99,  350,  105,   99,  101,   97,  101,  101,   97,
+      101,  110,  111,  108,  853,  108,  112,  113,  297,  102,
+      110,  111,  102,  293,  114,  112,  113,  110,  111, 1255,
+      115,  226,  112,  114,  110,  111,  294,  115,  475,  112,
+      114,  117,  118,  117,  118,  227,  226,  114,   97,   97,
+       97,   97,   97,   97,  128,   97,  128,  128,   97,  128,
+      228,  299,  120,  298,  300,  120,  350,  297,  129,  354,
+      422,  129,  119,  640,  119,  121,  122,   97,  122,  121,
+
+      121,  121,  121,  121,  121,  121,  123,  121,  475,  121,
+      125,  121,  126,  121,  225,  225,  225,  225,  225,  225,
+      225,  225,  225,  225,  225,  225,  475,  121,  121,  121,
+      122,   97,  122,  121,  121,  121,  121,  121,  121,  121,
+      123,  121,  603,  121,  125,  121,  126,  121,  570,   97,
+       97,   97,   97,   97,   97,  128,   97,  128,  128,   97,
+      128,  121,  121,  130,  475,  613,  130,  614,  475,  129,
+     1066,  229,  129,  128,   97,  128,  128,   97,  128,   97,
+       97,   97,   97,   97,   97,  228,  350,  131,  602,  615,
+      131,  616,  601,  132,  569,  475,  132,  133,  134,   97,
+
+      134,  133,  133,  133,  133,  133,  133,  133,  135,  133,
+      229,  133,  137,  133,  138,  133,  680,  141,   97,  141,
+      141,   97,  141,  350,  228,  225,  225,  225, 1065,  133,
+      133,  142, 1051,  352,  142,  778,  779,  139,  133,  134,
+       97,  134,  133,  133,  133,  133,  133,  133,  133,  135,
+      133,  350,  133,  137,  133,  138,  133,  350,   97,   97,
+       97,   97,   97,   97,  472,  141,   97,  141,  568,  475,
+      133,  133,  130,  234,  623,  130,  624,  350,  139,  142,
+      141,   97,  141,  141,   97,  141,  141,   97,  141,   97,
+       97,   97,  350,  229,  142,  681,  625,  143,  626,  711,
+
+      143, 1050,  235,  144,   97,   97,   97,  228,  236,  225,
+      225,  225,  237,  225,  225,  225,  736,  238,  144,  145,
+      146,   97,  146,  145,  145,  145,  145,  145,  145,  145,
+      147,  145,  148,  145,  149,  145,  150,  145,  148,  148,
+      148,  148,  148,  148,  148,  148,  148,  148,  148,  148,
+      148,  145,  145,  148,  151,  148,  148,  148,  148,  148,
+      148,  148,  152,  148,  148,  153,  154,  148,  155,  148,
+      148,  156,  148,  148,  148,  148,  148,  148,  158,   97,
+      158,  158,   97,  158,   97,   97,   97,   97,   97,   97,
+      861,  861,  159,  475,  476,  159, 1036, 1035,  160,  864,
+
+      864,  160,  161,  162,   97,  162,  161,  161,  161,  161,
+      161,  161,  161,  163,  161,  164,  161,  165,  161,  166,
+      161,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  161,  161,  164,  164,  167,  164,
+      164,  164,  164,  164,  164,  164,  164,  168,  164,  169,
+      164,  164,  164,  164,  170,  164,  164,  164,  164,  164,
+      164,  172,   97,  172,  172,   97,  172,   97,   97,   97,
+       97,   97,   97,  475,  350,  173,  350,  350,  173, 1021,
+      900,  174,  945,  969,  174,  175,  176,   97,  176,  175,
+      175,  175,  175,  175,  175,  175,  177,  175,  350,  175,
+
+      179,  175,  180,  175,  639,  185,   97,  185,  185,   97,
+      185,   97,   97,   97,  225,  225,  225,  175,  175,  186,
+      229,  229,  186,  181, 1136,  187,  350,  243,  182,  225,
+      225,  225,  708,  350,  228,  228,  350,  183,  175,  176,
+       97,  176,  175,  175,  175,  175,  175,  175,  175,  177,
+      175,  475,  175,  179,  175,  180,  175,  714,   97,   97,
+       97,  185,   97,  185,  185,   97,  185,  225,  225,  225,
+      175,  175,  187,  737,  229,  186,  181,  715,  186,  475,
+      229,  182,  185,   97,  185,  185,   97,  185,  228,  229,
+      183,   97,   97,   97,  228,  229,  188,  229,  229,  188,
+
+       97,   97,   97,  228,  252,  187,  225,  225,  225,  228,
+      716,  228,  228,  245,  187,  189,  190,   97,  190,  189,
+      189,  189,  189,  189,  189,  189,  191,  189,  244,  189,
+      193,  189,  194,  189,  240,  197,   97,  197,  197,   97,
+      197,   97,   97,   97,   97,   97,   97,  189,  189,  198,
+      350,  350,  198, 1020, 1007,  199,  350,  972,  199,  225,
+      225,  225,  195,  189,  190,   97,  190,  189,  189,  189,
+      189,  189,  189,  189,  191,  189,  738,  189,  193,  189,
+      194,  189,  709,  209,   97,  209,  209,   97,  209,   97,
+       97,   97,   97,   97,   97,  189,  189,  210,  350,  350,
+
+      210, 1006,  995,  211,  981,  350,  211,  225,  225,  225,
+      195,  200,  201,   97,  201,  200,  200,  200,  200,  200,
+      200,  200,  202,  200,  350,  200,  204,  200,  205,  200,
+      741,  209,   97,  209,  209,   97,  209,  350,  209,   97,
+      209,  739,  740,  200,  200,  210,  350,  350,  210,  475,
+      475,  206,  212,  207,  200,  201,   97,  201,  200,  200,
+      200,  200,  200,  200,  200,  202,  200,  710,  200,  204,
+      200,  205,  200,  768,  209,   97,  209,   97,   97,   97,
+      743,   97,   97,   97,  742,  764,  200,  200,  212,  994,
+      980,  211,  979,  475,  206,  211,  207,  213,  214,   97,
+
+      214,  213,  213,  213,  213,  213,  213,  213,  215,  213,
+      229,  213,  217,  213,  218,  213,  350,  221,   97,  221,
+      221,   97,  221,  744,  228,  229,  225,  225,  225,  213,
+      213,  222,  261,  229,  222,  110,  111,  229,  799,  228,
+      112,  225,  225,  225,  225,  225,  225,  228,  223,  350,
+      965,  228,  219,  213,  214,   97,  214,  213,  213,  213,
+      213,  213,  213,  213,  215,  213,  224,  213,  217,  213,
+      218,  213,  798,  350,  110,  111,  229,  229,  247,  112,
+      246,  229,  229,  243,  229,  213,  213,  223,  268,  229,
+      228,  228,  229,  229,  350,  228,  228,  229,  228,  252,
+
+      274,  763,  350,  228,  274,  224,  228,  228,  219,  244,
+      244,  228,  225,  225,  225,  245,  245, 1172,  229,  246,
+      246,  247,  247,  248,  248,  244,  350,  229,  229,  248,
+      765,  245,  228,  797,  279,  246,  275,  247,  229,  248,
+      275,  228,  228,  229,  229,  284,  225,  225,  225,  285,
+      284,  289,  228,  225,  225,  225,  350,  228,  228,  225,
+      225,  225,  362,  362,  362,  362,  362,  362,  350,  285,
+      372,  372,  372,  372,  372,  372,  766,  350,  364,  350,
+      350,  364,  382,  382,  382,  926,  374,  350,  964,  374,
+      382,  382,  382,  528,  390,  390,  390,  350,  384,  390,
+
+      390,  390,  394,  394,  394,  761,  384,  350,  712,  365,
+      392,  397,  397,  397,  713,  392,  794,  395,  828,  375,
+      399,  399,  399,  399,  399,  399,  398,  405,  405,  405,
+      405,  405,  405,  411,  411,  411,  401,  393,  385,  401,
+      411,  411,  411,  407,  796,  350,  407,  350,  350,  413,
+      417,  417,  417,  417,  417,  417,  413,  362,  362,  362,
+      362,  362,  362,  362,  362,  362,  419,  800,  971,  419,
+      402,  963,  350,  364,  350,  702,  364,  408,  830,  364,
+      430,  430,  430,  435,  435,  435,  372,  372,  372,  703,
+      414,  372,  372,  372,  372,  372,  372,  429,  436,  441,
+
+      441,  441,  374,  420,  382,  382,  382,  374,  767,  831,
+      374,  382,  382,  382,  442,  382,  382,  382,  350,  350,
+      384,  448,  448,  448,  390,  390,  390,  384,  350,  350,
+      437,  384,  390,  390,  390,  877,  449,  390,  390,  390,
+      392,  394,  394,  394,  350,  452,  452,  452,  392,  453,
+      826,  350,  454,  392,  350,  874,  395,  397,  397,  397,
+      456,  456,  456,  829,  457,  827,  854,  458,  445,  399,
+      399,  399,  398,  951,  399,  399,  399,  399,  399,  399,
+      461,  461,  461,  350,  852,  401,  405,  405,  405,  451,
+      401,  350,  350,  401,  350,  462,  405,  405,  405,  405,
+
+      405,  405,  407,  465,  465,  465,  411,  411,  411,  411,
+      411,  411,  407,  350,  859,  407,  950,  856,  466,  411,
+      411,  411,  413, 1014,  861,  413,  417,  417,  417,  857,
+      459,  417,  417,  417,  949,  413,  862,  417,  417,  417,
+      855,  350,  419,  474,  474,  474,  350,  419,  362,  362,
+      362,  350,  463,  419,  430,  430,  430,  350,  903,  475,
+      476,  435,  435,  435,  364,  880,  467,  485,  485,  485,
+      875,  486,  350,  350,  487,  878,  436,  470,  372,  372,
+      372,  441,  441,  441,  492,  492,  492,  947,  493,  938,
+      937,  494,  936,  929,  374,  906,  442,  495,  495,  495,
+
+      480,  497,  497,  497,  500,  500,  500,  350,  448,  448,
+      448,  350,  496,  507,  507,  507,  498,  504,  504,  504,
+      501,  505,  488,  449,  506,  390,  390,  390,  508,  452,
+      452,  452,  861,  453,  499,  881,  454,  928,  456,  456,
+      456,  392,  457,  350,  862,  458,  509,  399,  399,  399,
+      461,  461,  461,  514,  514,  514,  931,  515,  934,  933,
+      516,  350,  350,  401,  350,  462,  405,  405,  405,  465,
+      465,  465,  519,  519,  519,  927,  520,  924,  930,  521,
+      510,  350,  407,  350,  466,  411,  411,  411,  524,  524,
+      524,  417,  417,  417,  474,  474,  474,  939,  974,  512,
+
+      350,  413,  350,  525,  362,  362,  362,  419,  350,  902,
+      475,  537,  537,  537,  905,  485,  485,  485,  517,  486,
+      364,  522,  487,  372,  372,  372,  492,  492,  492,  932,
+      493,  350,  529,  494,  495,  495,  495,  350,  942,  374,
+      497,  497,  497,  533,  526,  500,  500,  500,  530,  496,
+      542,  542,  542,  943,  543,  498,  350,  544,  545,  545,
+      545,  501,  546,  350,  350,  547,  504,  504,  504,  955,
+      505,  350,  350,  506,  982,  941,  538,  507,  507,  507,
+      551,  551,  551,  944,  552,  350,  946,  553,  390,  390,
+      390, 1043,  508,  399,  399,  399,  514,  514,  514,  956,
+
+      515,  350,  350,  516,  392,  405,  405,  405,  350,  401,
+      519,  519,  519,  952,  520,  958,  959,  521,  411,  411,
+      411,  407,  524,  524,  524,  563,  563,  563,  350,  564,
+      350,  557,  565,  350,  413,  555,  350,  525,  417,  417,
+      417,  350,  350,  559,  362,  362,  362,  537,  537,  537,
+      372,  372,  372,  350,  419, 1000,  561,  542,  542,  542,
+      364,  543, 1001,  957,  544,  967,  374,  545,  545,  545,
+      983,  546,  960,  350,  547,  584,  584,  584,  551,  551,
+      551,  350,  552,  566,  350,  553,  966,  576,  968,  984,
+      585,  572,  987,  390,  390,  390,  592,  592,  592,  405,
+
+      405,  405,  411,  411,  411,  606,  606,  606,  586,  392,
+      923,  350,  593,  350,  350,  407,  350, 1064,  413,  563,
+      563,  563,  350,  564,  996,  350,  565, 1019,  417,  417,
+      417,  350,  595,  362,  362,  362,  608,  608,  608,  372,
+      372,  372,  350,  590,  419,  584,  584,  584,  986,  364,
+      619,  619,  619,  597,  620,  374,  997,  621,  350,  998,
+      585, 1074,  390,  390,  390, 1009,  599,  350,  592,  592,
+      592,  405,  405,  405,  632,  632,  632,  609,  392,  411,
+      411,  411,  350,  605,  593,  350,  350,  407,  350,  633,
+      417,  417,  417, 1003, 1013,  413,  638,  638,  638,  362,
+
+      362,  362,  606,  606,  606,  628,  419, 1024, 1010,  631,
+      919,  350,  350,  350, 1054,  364,  608,  608,  608,  644,
+      644,  644,  654,  654,  654,  619,  619,  619, 1025,  620,
+      634,  350,  621,  350, 1047,  645,  636,  655,  390,  390,
+      390,  405,  405,  405,  642,  632,  632,  632, 1004,  667,
+      667,  667,  350,  668,  392,  656,  669,  407,  350, 1055,
+      633,  670,  670,  670,  672,  672,  672,  417,  417,  417,
+     1017,  663,  362,  362,  362,  908,  350,  671,  644,  644,
+      644,  350,  350,  419,  350,  666,  350, 1026,  364,  690,
+      690,  690, 1058, 1027,  645,  654,  654,  654, 1034,  692,
+
+      692,  692, 1044,  693,  691,  683,  694,  390,  390,  390,
+      655,  699,  699,  699,  405,  405,  405, 1030, 1018,  673,
+      638,  638,  638,  392,  350,  350,  700,  667,  667,  667,
+      407,  668,  350,  350,  669,  350,  350,  670,  670,  670,
+      672,  672,  672,  706,  706,  706, 1028,  362,  362,  362,
+      350,  701,  705,  671,  674,  350,  675,  883,  350,  707,
+     1029,  350,  676,  364,  350, 1062,  677, 1031,  678, 1032,
+      679,  690,  690,  690,  723,  723,  723,  907,  724,  883,
+      350,  725, 1086,  350,  718, 1037,  691,  692,  692,  692,
+     1038,  693, 1033, 1039,  694,  699,  699,  699,  728,  728,
+
+      728,  350,  729,  350,  898,  730,  390,  390,  390, 1040,
+      700,  405,  405,  405,  706,  706,  706,  362,  362,  362,
+     1041,  897,  392,  350,  748,  748,  748,  407,  350,  350,
+      707,  350, 1059,  364,  723,  723,  723,  886,  724,  749,
+     1042,  725, 1049,  754,  754,  754, 1048,  350,  731,  390,
+      390,  390,  405,  405,  405,  746,  735,  750,  755,  728,
+      728,  728, 1056,  729,  350,  392,  730, 1106,  407,  762,
+      762,  762,  769,  769,  769,  362,  362,  362,  773,  773,
+      773,  748,  748,  748, 1045,  350,  883,  770,  475,  883,
+      760,  364,  754,  754,  754,  756,  749,  774,  774,  774,
+
+     1107,  775,  350,  350,  776,  350,  350,  755,  782,  782,
+      782, 1079,  783,  350,  350,  784,  390,  390,  390,  786,
+      786,  786,  789,  789,  789,  350,  772,  405,  405,  405,
+      873,  350,  392,  872,  787, 1077, 1057,  790,  762,  762,
+      762,  350, 1046,  407,  350,  801,  801,  801,  769,  769,
+      769, 1052,  788, 1063,  350,  791,  362,  362,  362,  785,
+      802,  475, 1053,  770,  475, 1060,  795,  803,  803,  803,
+     1078,  804,  364,  793,  805,  773,  773,  773,  774,  774,
+      774,  350,  775,  475, 1088,  776,  812,  812,  812,  782,
+      782,  782,  807,  783,  871,  870,  784,  814,  814,  814,
+
+      350,  813,  786,  786,  786,  816,  816,  816,  350,  817,
+      869,  350,  818,  815,  789,  789,  789,  787,  820,  820,
+      820, 1089,  821, 1071,  350,  822,  824,  824,  824,  790,
+      405,  405,  405,  832,  832,  832,  801,  801,  801,  350,
+      834,  834,  834, 1069,  835, 1061,  407,  836, 1093,  350,
+      350,  802,  475,  803,  803,  803,  475,  804, 1067,  350,
+      805,  362,  362,  362,  350,  868,  833, 1095,  350,  475,
+      824,  824,  824,  961,  961,  961,  350,  364,  812,  812,
+      812,  350,  825,  473,  473,  473,  473,  473,  473,  473,
+      473,  473, 1096,  813,  473, 1127, 1125,  473,  473,  473,
+
+      475,  473,  845,  845,  845,  350,  846,  350, 1094,  847,
+     1068,  840,  888,  888,  888,  473,  473,  473,  473,  473,
+      473,  473,  473,  473,  473,  473, 1087,  889,  473,  350,
+     1072,  473,  473,  473,  475,  473,  814,  814,  814,  816,
+      816,  816, 1156,  817, 1070,  866,  818,  350,  849,  473,
+      473,  350,  815,  820,  820,  820,  350,  821,  350,  350,
+      822,  850,  850,  850,  832,  832,  832,  834,  834,  834,
+     1075,  835,  350,  350,  836,  350,  350,  851,  350, 1076,
+      350, 1084, 1085,  475,  845,  845,  845,  350,  846,  350,
+      848,  847,  858,  473,  473,  473,  473,  473,  865,  473,
+
+      473,  473, 1108,  350,  473, 1109, 1139,  473,  473,  473,
+      475,  473,  910,  910,  910, 1104,  911,  350, 1105,  912,
+      362,  362,  362, 1144, 1110,  473,  473,  473,  473,  473,
+      473,  473,  473,  473,  473,  865,  364,  844,  473,  350,
+     1126,  473,  473,  473,  475,  473, 1113,  850,  850,  850,
+      876,  876,  876,  879,  879,  879,  885,  885,  885,  473,
+      473,  350,  867,  851, 1115,  350,  350,  843, 1114,  350,
+      350,  350,  475,  476,  362,  362,  362,  890,  890,  890,
+      892,  892,  892,  895,  895,  895,  899,  899,  899,  350,
+      364,  350,  891, 1154, 1119,  893, 1111,  842,  896,  876,
+
+      876,  876,  350,  879,  879,  879,  350,  885,  885,  885,
+      362,  362,  362,  894, 1116,  350,  961,  961,  961,  350,
+     1120,  350,  887,  475, 1132,  350,  364,  901,  888,  888,
+      888,  904,  890,  890,  890,  913,  913,  913,  350,  914,
+      841, 1133,  915,  889,  350,  529, 1121,  891,  892,  892,
+      892,  916,  916,  916,  839,  917,  350,  350,  918,  895,
+      895,  895,  909,  893,  920,  920,  920, 1179,  921,  350,
+      350,  922, 1123,  350,  896,  899,  899,  899,  362,  362,
+      362,  910,  910,  910, 1124,  911,  350,  350,  912,  350,
+     1122,  350, 1212, 1137,  364,  913,  913,  913, 1128,  914,
+
+      350, 1129,  915,  925,  916,  916,  916, 1130,  917,  823,
+     1131,  918,  920,  920,  920, 1134,  921,  350, 1136,  922,
+      935,  940,  940,  940,  362,  362,  362,  940,  940,  940,
+      350,  953, 1138,  350,  954, 1142,  350,  350, 1152,  350,
+      364,  350,  350,  350,  362,  362,  362,  970,  970,  970,
+      973,  973,  973,  975,  975,  975,  350,  977,  977,  977,
+      364, 1135,  350,  350, 1155,  350,  350, 1172, 1141,  976,
+     1140,  948,  978,  970,  970,  970,  973,  973,  973,  350,
+      988, 1143,  819,  989,  990,  990,  990,  350,  350,  350,
+      962,  350,  350,  975,  975,  975,  977,  977,  977, 1146,
+
+      350,  985, 1147,  991,  991,  991,  350,  992, 1153,  976,
+      993,  978,  999,  999,  999, 1002, 1002, 1002,  990,  990,
+      990,  350,  991,  991,  991, 1148,  992, 1145,  350,  993,
+      811,  350,  350,  810,  350, 1008, 1008, 1008,  999,  999,
+      999,  350, 1011, 1218,  809, 1012, 1005,  350, 1002, 1002,
+     1002,  350, 1015, 1169,  350, 1016, 1008, 1008, 1008,  350,
+     1022, 1167, 1157, 1023,  350, 1073, 1073, 1073, 1080, 1080,
+     1080,  350,  350, 1082, 1082, 1082,  350, 1149, 1073, 1073,
+     1073,  350, 1090, 1081,  350, 1091,  350,  350, 1083, 1092,
+     1092, 1092, 1158, 1161,  350, 1097, 1097, 1097, 1080, 1080,
+
+     1080,  350, 1098, 1098, 1098,  350, 1099, 1159, 1160, 1100,
+     1162,  350,  350, 1081, 1082, 1082, 1082, 1101, 1101, 1101,
+      808, 1102, 1163,  350, 1103, 1092, 1092, 1092,  350, 1083,
+     1097, 1097, 1097, 1164, 1117,  806,  350, 1118, 1098, 1098,
+     1098,  350, 1099,  350,  350, 1100,  350, 1101, 1101, 1101,
+      350, 1102,  350, 1112, 1103, 1150, 1150, 1150, 1150, 1150,
+     1150,  350,  350, 1168, 1165,  350,  350,  350,  350,  350,
+      350, 1151, 1166, 1173, 1151, 1174, 1181,  350,  350, 1170,
+     1171,  350,  350, 1184, 1184, 1184, 1177, 1178, 1190,  792,
+     1182, 1183, 1190,  350,  350, 1194, 1180, 1175, 1176, 1185,
+
+      350,  350, 1188, 1189, 1193, 1193, 1193,  350,  350,  350,
+     1194, 1184, 1184, 1184, 1197, 1197, 1200, 1186, 1187,  350,
+      350, 1191, 1192,  350,  350, 1201,  350, 1185, 1198, 1198,
+     1198,  350,  350, 1204, 1204, 1204,  350, 1195, 1196, 1193,
+     1193, 1193,  350, 1202, 1199,  350, 1203,  350,  350, 1205,
+     1208, 1208, 1208,  350,  350,  350, 1198, 1198, 1198, 1206,
+     1204, 1204, 1204, 1210, 1207,  350, 1209, 1214, 1211,  350,
+     1215,  350, 1199,  350,  350,  350, 1205,  350,  350,  350,
+     1213, 1208, 1208, 1208, 1216,  350, 1220, 1228,  350, 1217,
+     1221, 1219, 1222, 1228, 1223,  350,  350, 1209,  350,  350,
+
+      350,  350,  350,  350, 1233, 1233, 1233, 1237,  350, 1224,
+     1237, 1229, 1225,  781,  350, 1226,  350, 1231, 1230, 1232,
+     1234, 1227,  350, 1233, 1233, 1233, 1240, 1240, 1240,  350,
+      350, 1244, 1238, 1240, 1240, 1240, 1245, 1239,  350, 1234,
+     1235, 1236, 1241,  350,  350,  350,  350,  350,  350, 1241,
+     1248, 1252, 1252,  780, 1253, 1253, 1253, 1242, 1243,  777,
+      771,  350,  759,  350,  758, 1246, 1247,  757, 1250, 1251,
+     1254, 1253, 1253, 1253,  753,  752,  751,  747,  745,  734,
+      733,  732, 1249,  727,  726,  722,  721, 1254,   94,   94,
+       94,   94,   94,   94,   94,   95,   95,   95,   95,   95,
+
+       95,   95,  100,  100,  100,  100,  100,  100,  100,  103,
+      103,  103,  103,  103,  103,  103,  106,  106,  106,  106,
+      106,  106,  106,  109,  109,  109,  109,  109,  109,  109,
+      116,  116,  116,  116,  116,  116,  116,  124,  124,  124,
+      124,  124,  124,  124,  127,  127,  127,  127,  127,  127,
+      127,  136,  136,  136,  136,  136,  136,  136,  140,  140,
+      140,  140,  140,  140,  140,  157,  157,  157,  157,  157,
+      157,  157,  171,  171,  171,  171,  171,  171,  171,  178,
+      178,  178,  178,  178,  178,  178,  184,  184,  184,  184,
+      184,  184,  184,  192,  192,  192,  192,  192,  192,  192,
+
+      196,  196,  196,  196,  196,  196,  196,  203,  203,  203,
+      203,  203,  203,  203,  208,  208,  208,  208,  208,  208,
+      208,  216,  216,  216,  216,  216,  216,  216,  220,  220,
+      220,  220,  220,  220,  220,  242,  242,  242,  720,  242,
+      250,  250,  250,  719,  250,  254,  254,  254,  717,  254,
+      263,  263,  263,  704,  263,  270,  270,  270,  698,  270,
+      277,  277,  277,  697,  277,  281,  281,  281,  696,  281,
+      287,  287,  287,  695,  287,  292,  292,  292,  292,  292,
+      689,  292,  306,  688,  306,  314,  687,  314,  322,  686,
+      322,  328,  685,  328,  333,  684,  333,  337,  682,  337,
+
+      341,  665,  341,  345,  664,  345,  349,  349,  349,  349,
+      349,  349,  349,  355,  662,  661,  355,  363,  363,  363,
+      363,  363,  363,  373,  373,  373,  373,  373,  373,  383,
+      383,  383,  383,  383,  383,  391,  391,  391,  391,  391,
+      391,  400,  400,  400,  400,  400,  400,  406,  406,  406,
+      406,  406,  406,  412,  412,  412,  412,  412,  412,  418,
+      418,  418,  418,  418,  418,  473,  473,  473,  473,  473,
+      473,  473,  837,  837,  837,  837,  837,  837,  837,  838,
+      838,  838,  838,  838,  838,  838,  860,  860,  860,  860,
+      860,  860,  860,  863,  863,  863,  863,  863,  863,  863,
+
+      882,  882,  882,  882,  882,  882,  882,  884,  884,  884,
+      884,  884,  884,  884,  660,  659,  658,  657,  653,  652,
+      651,  650,  649,  648,  647,  646,  643,  641,  637,  635,
+      630,  629,  627,  622,  618,  617,  612,  611,  610,  607,
+      604,  600,  598,  596,  594,  591,  589,  588,  587,  583,
+      582,  581,  580,  579,  578,  577,  575,  574,  573,  571,
+      567,  562,  560,  558,  556,  554,  550,  549,  548,  541,
+      540,  539,  536,  535,  534,  532,  531,  475,  527,  523,
+      518,  513,  511,  503,  502,  491,  490,  489,  484,  483,
+      482,  481,  479,  478,  477,  471,  469,  468,  464,  460,
+
+      455,  450,  447,  446,  444,  443,  440,  439,  438,  434,
+      433,  432,  431,  428,  427,  426,  425,  424,  423,  350,
+      421,  416,  415,  410,  409,  404,  403,  396,  389,  388,
+      387,  386,  381,  380,  379,  378,  377,  376,  371,  370,
+      369,  368,  367,  366,  361,  360,  359,  358,  357,  356,
+      353,  351,  350,  348,  347,  346,  344,  343,  342,  340,
+      339,  338,  336,  335,  334,  332,  331,  330,  329,  327,
+      326,  325,  324,  323,  321,  320,  319,  318,  317,  316,
+      315,  313,  312,  311,  310,  309,  308,  307,  305,  304,
+      303,  302,  301,  296,  293,  295,  291,  290,  288,  286,
+
+      283,  282,  280,  278,  276,  273,  272,  271,  269,  267,
+      266,  265,  264,  262,  260,  259,  258,  257,  256,  255,
+      253,  251,  249,  241,  239,  233,  232,  233,  232,  231,
+      230, 1255,   93, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255
+
+    } ;
+
+static yyconst flex_int16_t yy_chk[3593] =
+    {   0,
+        0,    3,    3,    3,    4,    4,    4,    5,    5,    5,
+        6,    6,    6,    9,    0,    3,   10,   11,    4,   12,
+        9,    5,  827,   10,    6,    7,    7,    7,    8,    8,
+        8,   13,   13,   11,  827,   12,   13,   13,  234,    7,
+       14,   14,    8,  226,   13,   14,   14,   15,   15,    0,
+       15,   98,   15,   14,   16,   16,  226,   16,  603,   16,
+       15,   17,   17,   18,   18,   98,   99,   16,   19,   19,
+       19,   20,   20,   20,   23,   23,   23,   24,   24,   24,
+       99,  235,   19,  234,  235,   20,  352,  297,   23,  297,
+      352,   24,   17,  603,   18,   21,   21,   21,   21,   21,
+
+       21,   21,   21,   21,   21,   21,   21,   21,  570,   21,
+       21,   21,   21,   21,   96,   96,   96,   97,   97,   97,
+      101,  101,  101,  122,  122,  122,  530,   21,   21,   22,
+       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+       22,   22,  570,   22,   22,   22,   22,   22,  530,   25,
+       25,   25,   26,   26,   26,   27,   27,   27,   28,   28,
+       28,   22,   22,   25,  529,  580,   26,  580,  569,   27,
+     1051,  102,   28,   29,   29,   29,   30,   30,   30,   31,
+       31,   31,   32,   32,   32,  102,  568,   29,  569,  581,
+       30,  581,  568,   31,  529,  639,   32,   33,   33,   33,
+
+       33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
+      125,   33,   33,   33,   33,   33,  639,   35,   35,   35,
+       36,   36,   36,  294,  125,  128,  128,  128, 1050,   33,
+       33,   35, 1036,  294,   36,  751,  751,   33,   34,   34,
+       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
+       34,  422,   34,   34,   34,   34,   34,  528,   37,   37,
+       37,   38,   38,   38,  422,   39,   39,   39,  528,  640,
+       34,   34,   37,  112,  587,   38,  587,  677,   34,   39,
+       40,   40,   40,   41,   41,   41,   42,   42,   42,   43,
+       43,   43,  708,  137,   40,  640,  588,   41,  588,  677,
+
+       42, 1035,  112,   43,   44,   44,   44,  137,  112,  134,
+      134,  134,  112,  141,  141,  141,  708,  112,   44,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   47,   47,
+       47,   48,   48,   48,   49,   49,   49,   50,   50,   50,
+      836,  863,   47,  861,  861,   48, 1021, 1020,   49,  836,
+
+      863,   50,   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,   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,   51,   51,   51,   51,   51,   51,
+       51,   53,   53,   53,   54,   54,   54,   55,   55,   55,
+       56,   56,   56,  602,  875,   53,  931,  955,   54, 1007,
+      875,   55,  931,  955,   56,   57,   57,   57,   57,   57,
+       57,   57,   57,   57,   57,   57,   57,   57,  674,   57,
+
+       57,   57,   57,   57,  602,   59,   59,   59,   60,   60,
+       60,   61,   61,   61,  146,  146,  146,   57,   57,   59,
+      131,  149,   60,   57, 1122,   61,  679,  131,   57,  158,
+      158,  158,  674, 1122,  131,  149,  709,   57,   58,   58,
+       58,   58,   58,   58,   58,   58,   58,   58,   58,   58,
+       58,  680,   58,   58,   58,   58,   58,  679,   62,   62,
+       62,   63,   63,   63,   64,   64,   64,  162,  162,  162,
+       58,   58,   62,  709,  132,   63,   58,  680,   64,  681,
+      165,   58,   65,   65,   65,   66,   66,   66,  132,  120,
+       58,   67,   67,   67,  165,  144,   65,  143,  179,   66,
+
+       68,   68,   68,  120,  143,   67,  172,  172,  172,  144,
+      681,  143,  179,  132,   68,   69,   69,   69,   69,   69,
+       69,   69,   69,   69,   69,   69,   69,   69,  144,   69,
+       69,   69,   69,   69,  120,   71,   71,   71,   72,   72,
+       72,   73,   73,   73,   74,   74,   74,   69,   69,   71,
+      675,  958,   72, 1006,  995,   73,  710,  958,   74,  176,
+      176,  176,   69,   70,   70,   70,   70,   70,   70,   70,
+       70,   70,   70,   70,   70,   70,  710,   70,   70,   70,
+       70,   70,  675,   77,   77,   77,   78,   78,   78,   79,
+       79,   79,   80,   80,   80,   70,   70,   77,  966,  713,
+
+       78,  994,  980,   79,  966,  711,   80,  185,  185,  185,
+       70,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,  712,   75,   75,   75,   75,   75,
+      713,   81,   81,   81,   82,   82,   82,  676,   83,   83,
+       83,  711,  712,   75,   75,   81,  739,  714,   82,  743,
+      715,   75,   83,   75,   76,   76,   76,   76,   76,   76,
+       76,   76,   76,   76,   76,   76,   76,  676,   76,   76,
+       76,   76,   76,  743,   84,   84,   84,   85,   85,   85,
+      715,   86,   86,   86,  714,  739,   76,   76,   84,  979,
+      965,   85,  964,  716,   76,   86,   76,   87,   87,   87,
+
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+      193,   87,   87,   87,   87,   87,  766,   89,   89,   89,
+       90,   90,   90,  716,  193,  159,  190,  190,  190,   87,
+       87,   89,  159,  199,   90,   91,   91,  160,  766,  159,
+       91,  197,  197,  197,  201,  201,  201,  199,   91,  765,
+      951,  160,   87,   88,   88,   88,   88,   88,   88,   88,
+       88,   88,   88,   88,   88,   88,   91,   88,   88,   88,
+       88,   88,  765,  738,   92,   92,  129,  130,  199,   92,
+      160,  173,  174,  129,  204,   88,   88,   92,  173,  187,
+      129,  130,  142,  186,  740,  173,  174,  188,  204,  142,
+
+      186,  738,  764,  187,  188,   92,  142,  186,   88,  129,
+      130,  188,  209,  209,  209,  129,  130, 1160,  211,  129,
+      130,  129,  130,  129,  130,  142, 1160,  198,  217,  174,
+      740,  142,  211,  764,  198,  142,  187,  142,  210,  142,
+      186,  198,  217,  212,  222,  210,  214,  214,  214,  211,
+      212,  222,  210,  221,  221,  221,  741,  212,  222,  225,
+      225,  225,  306,  306,  306,  307,  307,  307,  736,  210,
+      314,  314,  314,  315,  315,  315,  741,  900,  306,  472,
+      678,  307,  322,  322,  322,  900,  314,  761,  950,  315,
+      323,  323,  323,  472,  328,  328,  328,  796,  322,  329,
+
+      329,  329,  330,  330,  330,  736,  323,  763,  678,  307,
+      328,  332,  332,  332,  678,  329,  761,  330,  796,  315,
+      333,  333,  333,  334,  334,  334,  332,  337,  337,  337,
+      338,  338,  338,  341,  341,  341,  333,  329,  323,  334,
+      342,  342,  342,  337,  763,  767,  338,  798,  957,  341,
+      345,  345,  345,  346,  346,  346,  342,  362,  362,  362,
+      363,  363,  363,  365,  365,  365,  345,  767,  957,  346,
+      334,  949,  742,  362,  799,  664,  363,  338,  798,  365,
+      366,  366,  366,  371,  371,  371,  372,  372,  372,  664,
+      342,  373,  373,  373,  375,  375,  375,  365,  371,  379,
+
+      379,  379,  372,  346,  382,  382,  382,  373,  742,  799,
+      375,  383,  383,  383,  379,  385,  385,  385,  855,  852,
+      382,  388,  388,  388,  390,  390,  390,  383,  794,  797,
+      375,  385,  391,  391,  391,  855,  388,  393,  393,  393,
+      390,  394,  394,  394,  828,  395,  395,  395,  391,  395,
+      794,  795,  395,  393,  826,  852,  394,  397,  397,  397,
+      398,  398,  398,  797,  398,  795,  828,  398,  385,  399,
+      399,  399,  397,  938,  400,  400,  400,  402,  402,  402,
+      404,  404,  404,  830,  826,  399,  405,  405,  405,  393,
+      400, 1001,  833,  402,  831,  404,  406,  406,  406,  408,
+
+      408,  408,  405,  410,  410,  410,  411,  411,  411,  412,
+      412,  412,  406,  829,  833,  408,  937,  830,  410,  414,
+      414,  414,  411, 1001,  835,  412,  417,  417,  417,  831,
+      402,  418,  418,  418,  936,  414,  835,  420,  420,  420,
+      829,  878,  417,  423,  423,  423,  856,  418,  429,  429,
+      429,  858,  408,  420,  430,  430,  430,  853,  878,  423,
+      423,  435,  435,  435,  429,  858,  414,  436,  436,  436,
+      853,  436,  903,  881,  436,  856,  435,  420,  437,  437,
+      437,  441,  441,  441,  442,  442,  442,  934,  442,  924,
+      923,  442,  919,  903,  437,  881,  441,  443,  443,  443,
+
+      429,  444,  444,  444,  445,  445,  445,  859,  448,  448,
+      448,  902,  443,  450,  450,  450,  444,  449,  449,  449,
+      445,  449,  437,  448,  449,  451,  451,  451,  450,  452,
+      452,  452,  860,  452,  444,  859,  452,  902,  456,  456,
+      456,  451,  456,  905,  860,  456,  450,  459,  459,  459,
+      461,  461,  461,  462,  462,  462,  905,  462,  908,  907,
+      462,  901,  960,  459,  904,  461,  463,  463,  463,  465,
+      465,  465,  466,  466,  466,  901,  466,  898,  904,  466,
+      451,  877,  463,  925,  465,  467,  467,  467,  469,  469,
+      469,  470,  470,  470,  474,  474,  474,  925,  960,  459,
+
+      906,  467,  880,  469,  480,  480,  480,  470,  928,  877,
+      474,  484,  484,  484,  880,  485,  485,  485,  463,  485,
+      480,  467,  485,  488,  488,  488,  492,  492,  492,  906,
+      492,  929,  474,  492,  495,  495,  495,  967,  928,  488,
+      497,  497,  497,  480,  470,  500,  500,  500,  474,  495,
+      496,  496,  496,  929,  496,  497,  941,  496,  498,  498,
+      498,  500,  498,  927,  932,  498,  504,  504,  504,  941,
+      504,  930,  942,  504,  967,  927,  488,  507,  507,  507,
+      508,  508,  508,  930,  508, 1028,  932,  508,  510,  510,
+      510, 1028,  507,  512,  512,  512,  514,  514,  514,  942,
+
+      514,  939,  944,  514,  510,  517,  517,  517,  945,  512,
+      519,  519,  519,  939,  519,  944,  945,  519,  522,  522,
+      522,  517,  524,  524,  524,  525,  525,  525,  943,  525,
+      953,  512,  525,  968,  522,  510,  986,  524,  526,  526,
+      526,  985,  946,  517,  533,  533,  533,  537,  537,  537,
+      538,  538,  538,  954,  526,  985,  522,  542,  542,  542,
+      533,  542,  986,  943,  542,  953,  538,  545,  545,  545,
+      968,  545,  946,  952,  545,  550,  550,  550,  551,  551,
+      551,  969,  551,  526,  972,  551,  952,  538,  954,  969,
+      550,  533,  972,  555,  555,  555,  557,  557,  557,  559,
+
+      559,  559,  561,  561,  561,  573,  573,  573,  550,  555,
+      897, 1049,  557, 1005,  971,  559,  981, 1049,  561,  563,
+      563,  563,  982,  563,  981,  983,  563, 1005,  566,  566,
+      566, 1059,  559,  572,  572,  572,  575,  575,  575,  576,
+      576,  576,  997,  555,  566,  584,  584,  584,  971,  572,
+      585,  585,  585,  561,  585,  576,  982,  585,  988,  983,
+      584, 1059,  590,  590,  590,  997,  566, 1009,  592,  592,
+      592,  595,  595,  595,  596,  596,  596,  576,  590,  597,
+      597,  597, 1000,  572,  592,  998, 1039,  595, 1010,  596,
+      599,  599,  599,  988, 1000,  597,  601,  601,  601,  605,
+
+      605,  605,  606,  606,  606,  590,  599, 1009,  998,  595,
+      894, 1032,  601,  989, 1039,  605,  608,  608,  608,  609,
+      609,  609,  618,  618,  618,  619,  619,  619, 1010,  619,
+      597, 1040,  619, 1003, 1032,  609,  599,  618,  628,  628,
+      628,  631,  631,  631,  605,  632,  632,  632,  989,  633,
+      633,  633, 1011,  633,  628,  618,  633,  631, 1012, 1040,
+      632,  634,  634,  634,  635,  635,  635,  636,  636,  636,
+     1003,  628,  642,  642,  642,  886, 1029,  634,  644,  644,
+      644, 1004, 1015,  636, 1043,  631, 1019, 1011,  642,  653,
+      653,  653, 1043, 1012,  644,  654,  654,  654, 1019,  655,
+
+      655,  655, 1029,  655,  653,  642,  655,  663,  663,  663,
+      654,  662,  662,  662,  666,  666,  666, 1015, 1004,  636,
+      638,  638,  638,  663, 1014, 1047,  662,  667,  667,  667,
+      666,  667, 1016, 1013,  667, 1017,  638,  670,  670,  670,
+      672,  672,  672,  673,  673,  673, 1013,  683,  683,  683,
+     1022,  663,  666,  670,  638, 1023,  638,  884, 1018,  673,
+     1014, 1069,  638,  683, 1024, 1047,  638, 1016,  638, 1017,
+      638,  690,  690,  690,  691,  691,  691,  883,  691,  882,
+     1025,  691, 1069, 1026,  683, 1022,  690,  692,  692,  692,
+     1023,  692, 1018, 1024,  692,  699,  699,  699,  700,  700,
+
+      700, 1044,  700, 1027,  873,  700,  701,  701,  701, 1025,
+      699,  705,  705,  705,  706,  706,  706,  718,  718,  718,
+     1026,  872,  701, 1033,  720,  720,  720,  705, 1041, 1034,
+      706, 1086, 1044,  718,  723,  723,  723,  866,  723,  720,
+     1027,  723, 1034,  727,  727,  727, 1033, 1030,  701,  731,
+      731,  731,  735,  735,  735,  718,  705,  720,  727,  728,
+      728,  728, 1041,  728, 1087,  731,  728, 1086,  735,  737,
+      737,  737,  744,  744,  744,  746,  746,  746,  747,  747,
+      747,  748,  748,  748, 1030,  737,  864,  744,  744,  862,
+      735,  746,  754,  754,  754,  731,  748,  749,  749,  749,
+
+     1087,  749, 1042, 1064,  749, 1031, 1062,  754,  755,  755,
+      755, 1064,  755, 1048, 1037,  755,  756,  756,  756,  757,
+      757,  757,  758,  758,  758, 1038,  746,  760,  760,  760,
+      849, 1045,  756,  848,  757, 1062, 1042,  758,  762,  762,
+      762, 1063, 1031,  760, 1071,  768,  768,  768,  769,  769,
+      769, 1037,  757, 1048,  762,  758,  772,  772,  772,  756,
+      768,  768, 1038,  769,  769, 1045,  762,  770,  770,  770,
+     1063,  770,  772,  760,  770,  773,  773,  773,  774,  774,
+      774, 1072,  774,  770, 1071,  774,  781,  781,  781,  782,
+      782,  782,  772,  782,  844,  843,  782,  785,  785,  785,
+
+     1056,  781,  786,  786,  786,  787,  787,  787, 1075,  787,
+      842, 1046,  787,  785,  789,  789,  789,  786,  790,  790,
+      790, 1072,  790, 1056, 1052,  790,  792,  792,  792,  789,
+      793,  793,  793,  800,  800,  800,  801,  801,  801, 1077,
+      802,  802,  802, 1054,  802, 1046,  793,  802, 1075,  800,
+     1054,  801,  801,  803,  803,  803,  802,  803, 1052, 1110,
+      803,  807,  807,  807, 1078,  841,  800, 1077, 1076,  803,
+      824,  824,  824,  947,  947,  947, 1053,  807,  812,  812,
+      812, 1112,  793,  804,  804,  804,  804,  804,  804,  804,
+      804,  804, 1078,  812,  804, 1112, 1110,  804,  804,  804,
+
+      804,  804,  813,  813,  813, 1070,  813, 1057, 1076,  813,
+     1053,  807,  868,  868,  868,  804,  804,  805,  805,  805,
+      805,  805,  805,  805,  805,  805, 1070,  868,  805, 1141,
+     1057,  805,  805,  805,  805,  805,  814,  814,  814,  816,
+      816,  816, 1141,  816, 1055,  839,  816, 1060,  823,  805,
+      805, 1055,  814,  820,  820,  820, 1061,  820, 1067, 1068,
+      820,  825,  825,  825,  832,  832,  832,  834,  834,  834,
+     1060,  834, 1125, 1088,  834, 1084, 1089,  825, 1085, 1061,
+      832, 1067, 1068,  834,  845,  845,  845, 1130,  845, 1090,
+      819,  845,  832,  837,  837,  837,  837,  837,  837,  837,
+
+      837,  837, 1088, 1111,  837, 1089, 1125,  837,  837,  837,
+      837,  837,  889,  889,  889, 1084,  889, 1093, 1085,  889,
+      840,  840,  840, 1130, 1090,  837,  837,  838,  838,  838,
+      838,  838,  838,  838,  838,  838,  840,  811,  838, 1094,
+     1111,  838,  838,  838,  838,  838, 1093,  850,  850,  850,
+      854,  854,  854,  857,  857,  857,  865,  865,  865,  838,
+      838, 1091,  840,  850, 1095, 1104,  854,  810, 1094,  857,
+     1139, 1095,  865,  865,  867,  867,  867,  869,  869,  869,
+      870,  870,  870,  871,  871,  871,  874,  874,  874, 1117,
+      867, 1105,  869, 1139, 1104,  870, 1091,  809,  871,  876,
+
+      876,  876,  874,  879,  879,  879, 1118,  885,  885,  885,
+      887,  887,  887,  870, 1096,  876,  961,  961,  961,  879,
+     1105, 1096,  867,  885, 1117, 1106,  887,  876,  888,  888,
+      888,  879,  890,  890,  890,  891,  891,  891, 1167,  891,
+      808, 1118,  891,  888, 1108,  885, 1106,  890,  892,  892,
+      892,  893,  893,  893,  806,  893, 1109, 1202,  893,  895,
+      895,  895,  887,  892,  896,  896,  896, 1167,  896, 1107,
+     1113,  896, 1108, 1114,  895,  899,  899,  899,  909,  909,
+      909,  910,  910,  910, 1109,  910, 1115, 1119,  910, 1116,
+     1107,  899, 1202, 1123,  909,  913,  913,  913, 1113,  913,
+
+     1123, 1114,  913,  899,  916,  916,  916, 1115,  916,  791,
+     1116,  916,  920,  920,  920, 1119,  920, 1137, 1121,  920,
+      909,  926,  926,  926,  935,  935,  935,  940,  940,  940,
+     1121,  940, 1124, 1120,  940, 1128, 1126,  926, 1137, 1124,
+      935, 1140, 1128,  940,  948,  948,  948,  956,  956,  956,
+      959,  959,  959,  962,  962,  962, 1127,  963,  963,  963,
+      948, 1120, 1132,  956, 1140, 1133,  959, 1159, 1127,  962,
+     1126,  935,  963,  970,  970,  970,  973,  973,  973, 1159,
+      973, 1129,  788,  973,  974,  974,  974, 1138, 1129,  970,
+      948, 1131,  973,  975,  975,  975,  977,  977,  977, 1132,
+
+      974,  970, 1133,  978,  978,  978, 1212,  978, 1138,  975,
+      978,  977,  984,  984,  984,  987,  987,  987,  990,  990,
+      990, 1154,  991,  991,  991, 1134,  991, 1131,  984,  991,
+      780,  987, 1134,  779,  990,  996,  996,  996,  999,  999,
+      999, 1142,  999, 1212,  778,  999,  990, 1156, 1002, 1002,
+     1002,  996, 1002, 1156,  999, 1002, 1008, 1008, 1008, 1146,
+     1008, 1154, 1142, 1008, 1002, 1058, 1058, 1058, 1065, 1065,
+     1065, 1143, 1008, 1066, 1066, 1066, 1147, 1135, 1073, 1073,
+     1073, 1058, 1073, 1065, 1135, 1073, 1144, 1145, 1066, 1074,
+     1074, 1074, 1143, 1146, 1073, 1079, 1079, 1079, 1080, 1080,
+
+     1080, 1148, 1081, 1081, 1081, 1074, 1081, 1144, 1145, 1081,
+     1147, 1079, 1149, 1080, 1082, 1082, 1082, 1083, 1083, 1083,
+      777, 1083, 1148, 1155, 1083, 1092, 1092, 1092, 1152, 1082,
+     1097, 1097, 1097, 1149, 1097,  771, 1153, 1097, 1098, 1098,
+     1098, 1092, 1098, 1157, 1158, 1098, 1097, 1101, 1101, 1101,
+     1161, 1101, 1162, 1092, 1101, 1136, 1136, 1136, 1150, 1150,
+     1150, 1163, 1164, 1155, 1152, 1165, 1166, 1168, 1169, 1170,
+     1171, 1136, 1153, 1161, 1150, 1162, 1169, 1173, 1174, 1157,
+     1158, 1175, 1176, 1172, 1172, 1172, 1165, 1166, 1177,  759,
+     1170, 1171, 1178, 1179, 1180, 1182, 1168, 1163, 1164, 1172,
+
+     1177, 1178, 1175, 1176, 1181, 1181, 1181, 1182, 1186, 1187,
+     1183, 1184, 1184, 1184, 1188, 1189, 1191, 1173, 1174, 1183,
+     1181, 1179, 1180, 1191, 1189, 1192, 1188, 1184, 1190, 1190,
+     1190, 1195, 1192, 1194, 1194, 1194, 1196, 1186, 1187, 1193,
+     1193, 1193, 1200, 1193, 1190, 1203, 1193, 1201, 1210, 1194,
+     1197, 1197, 1197, 1211, 1213, 1193, 1198, 1198, 1198, 1195,
+     1204, 1204, 1204, 1200, 1196, 1214, 1197, 1206, 1201, 1215,
+     1207, 1216, 1198, 1217, 1206, 1218, 1204, 1207, 1219, 1220,
+     1203, 1208, 1208, 1208, 1210, 1221, 1214, 1222, 1224, 1211,
+     1215, 1213, 1216, 1223, 1217, 1225, 1226, 1208, 1227, 1222,
+
+     1229, 1230, 1223, 1235, 1228, 1228, 1228, 1232, 1236, 1218,
+     1231, 1224, 1219,  753, 1246, 1220, 1232, 1226, 1225, 1227,
+     1228, 1221, 1231, 1233, 1233, 1233, 1237, 1237, 1237, 1238,
+     1239, 1242, 1235, 1240, 1240, 1240, 1243, 1236, 1242, 1233,
+     1229, 1230, 1237, 1243, 1244, 1245, 1247, 1248, 1249, 1240,
+     1246, 1250, 1251,  752, 1252, 1252, 1252, 1238, 1239,  750,
+      745, 1251,  734, 1250,  733, 1244, 1245,  732, 1248, 1249,
+     1252, 1253, 1253, 1253,  726,  722,  721,  719,  717,  704,
+      703,  702, 1247,  696,  695,  687,  686, 1253, 1256, 1256,
+     1256, 1256, 1256, 1256, 1256, 1257, 1257, 1257, 1257, 1257,
+
+     1257, 1257, 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1259,
+     1259, 1259, 1259, 1259, 1259, 1259, 1260, 1260, 1260, 1260,
+     1260, 1260, 1260, 1261, 1261, 1261, 1261, 1261, 1261, 1261,
+     1262, 1262, 1262, 1262, 1262, 1262, 1262, 1263, 1263, 1263,
+     1263, 1263, 1263, 1263, 1264, 1264, 1264, 1264, 1264, 1264,
+     1264, 1265, 1265, 1265, 1265, 1265, 1265, 1265, 1266, 1266,
+     1266, 1266, 1266, 1266, 1266, 1267, 1267, 1267, 1267, 1267,
+     1267, 1267, 1268, 1268, 1268, 1268, 1268, 1268, 1268, 1269,
+     1269, 1269, 1269, 1269, 1269, 1269, 1270, 1270, 1270, 1270,
+     1270, 1270, 1270, 1271, 1271, 1271, 1271, 1271, 1271, 1271,
+
+     1272, 1272, 1272, 1272, 1272, 1272, 1272, 1273, 1273, 1273,
+     1273, 1273, 1273, 1273, 1274, 1274, 1274, 1274, 1274, 1274,
+     1274, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1276, 1276,
+     1276, 1276, 1276, 1276, 1276, 1277, 1277, 1277,  685, 1277,
+     1278, 1278, 1278,  684, 1278, 1279, 1279, 1279,  682, 1279,
+     1280, 1280, 1280,  665, 1280, 1281, 1281, 1281,  660, 1281,
+     1282, 1282, 1282,  658, 1282, 1283, 1283, 1283,  657, 1283,
+     1284, 1284, 1284,  656, 1284, 1285, 1285, 1285, 1285, 1285,
+      651, 1285, 1286,  649, 1286, 1287,  648, 1287, 1288,  647,
+     1288, 1289,  646, 1289, 1290,  643, 1290, 1291,  641, 1291,
+
+     1292,  630, 1292, 1293,  629, 1293, 1294, 1294, 1294, 1294,
+     1294, 1294, 1294, 1295,  627,  626, 1295, 1296, 1296, 1296,
+     1296, 1296, 1296, 1297, 1297, 1297, 1297, 1297, 1297, 1298,
+     1298, 1298, 1298, 1298, 1298, 1299, 1299, 1299, 1299, 1299,
+     1299, 1300, 1300, 1300, 1300, 1300, 1300, 1301, 1301, 1301,
+     1301, 1301, 1301, 1302, 1302, 1302, 1302, 1302, 1302, 1303,
+     1303, 1303, 1303, 1303, 1303, 1304, 1304, 1304, 1304, 1304,
+     1304, 1304, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1306,
+     1306, 1306, 1306, 1306, 1306, 1306, 1307, 1307, 1307, 1307,
+     1307, 1307, 1307, 1308, 1308, 1308, 1308, 1308, 1308, 1308,
+
+     1309, 1309, 1309, 1309, 1309, 1309, 1309, 1310, 1310, 1310,
+     1310, 1310, 1310, 1310,  625,  624,  623,  622,  617,  616,
+      615,  614,  613,  612,  611,  610,  607,  604,  600,  598,
+      594,  591,  589,  586,  583,  582,  579,  578,  577,  574,
+      571,  567,  562,  560,  558,  556,  554,  553,  552,  549,
+      548,  547,  546,  541,  540,  539,  536,  535,  534,  532,
+      527,  523,  518,  513,  511,  509,  503,  502,  499,  491,
+      490,  489,  483,  482,  481,  479,  476,  473,  471,  468,
+      464,  460,  455,  447,  446,  440,  439,  438,  434,  433,
+      432,  431,  428,  427,  426,  421,  416,  415,  409,  403,
+
+      396,  389,  387,  386,  381,  380,  378,  377,  376,  370,
+      369,  368,  367,  361,  360,  357,  356,  355,  353,  349,
+      347,  344,  343,  340,  339,  336,  335,  331,  327,  326,
+      325,  324,  321,  320,  319,  318,  317,  316,  313,  312,
+      311,  310,  309,  308,  305,  303,  302,  301,  300,  299,
+      295,  293,  292,  291,  290,  289,  288,  285,  284,  283,
+      282,  279,  278,  275,  274,  273,  272,  271,  268,  267,
+      266,  265,  264,  261,  260,  259,  258,  257,  256,  255,
+      252,  251,  248,  247,  246,  245,  244,  243,  240,  239,
+      238,  237,  236,  230,  229,  227,  224,  223,  219,  215,
+
+      207,  206,  202,  195,  191,  183,  182,  181,  177,  170,
+      169,  168,  167,  163,  156,  155,  154,  153,  152,  151,
+      147,  139,  135,  123,  119,  118,  117,  111,  110,  108,
+      105,   93, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255, 1255,
+     1255, 1255
+
+    } ;
+
+/* Table of booleans, true if rule could match eol. */
+static yyconst flex_int32_t yy_rule_can_match_eol[169] =
+    {   0,
+0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+    1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+    1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 
+    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 
+    0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 
+    0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 
+    0, 0, 0, 1, 0, 0, 0, 1, 0,     };
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+extern int surf_parse__flex_debug;
+int surf_parse__flex_debug = 0;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *surf_parse_text;
+#line 1 "surf/surfxml.l"
+/* Validating XML processor for surfxml.dtd.
+ * Generated 2005/04/15 16:26:24.
+ *
+ * This program was generated with the FleXML XML processor generator,
+ * (Id: flexml.pl,v 1.39 2005/02/13 18:12:19 legranda Exp).
+ * Copyright © 1999 Kristoffer Rose.  All rights reserved.
+ *
+ * You can redistribute and/or modify this program provided the following
+ * two conditions hold:
+ *
+ * 1. The program is distributed WITHOUT ANY WARRANTY from the author of
+ *    FleXML; without even the implied warranty of MERCHANTABILITY or
+ *    FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * 2. The program distribution conditions do not in any way affect the
+ *    distribution conditions of the FleXML system used to generate this
+ *    file or any version of FleXML derived from that system.
+ *
+ * Notice that these are explicit rights granted to you for files
+ * generated by the FleXML system.  For your rights in connection with
+ * the FleXML system itself please consult the GNU General Public License.
+ */
+#line 25 "surf/surfxml.l"
+
+/* Version strings. */
+const char rcs_flexml_skeleton[] =
+ "$" "Id: skel,v 1.24 2005/02/10 11:42:39 mquinson Exp $";
+const char rcs_flexml[] =
+ "$" "Id: flexml.pl,v 1.39 2005/02/13 18:12:19 legranda Exp $";
+
+/* ANSI headers. */
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+/* Generated definitions. */
+#define FLEXML_yylineno
+#define FLEXML_BUFFERSTACKSIZE 1000000
+
+/* XML processor api. */
+/* FleXML-provided data. */
+const char* pcdata;
+AT_network_link_bandwidth A_network_link_bandwidth;
+AT_cpu_name A_cpu_name;
+AT_network_link_state A_network_link_state;
+AT_argument_value A_argument_value;
+AT_cpu_availability_file A_cpu_availability_file;
+AT_process_host A_process_host;
+AT_route_impact_on_src A_route_impact_on_src;
+AT_route_src A_route_src;
+AT_network_link_latency_file A_network_link_latency_file;
+AT_cpu_max_outgoing_rate A_cpu_max_outgoing_rate;
+AT_route_impact_on_dst_with_other_send A_route_impact_on_dst_with_other_send;
+AT_cpu_interference_send_recv A_cpu_interference_send_recv;
+AT_cpu_availability A_cpu_availability;
+AT_route_impact_on_dst A_route_impact_on_dst;
+AT_cpu_interference_recv A_cpu_interference_recv;
+AT_route_impact_on_src_with_other_recv A_route_impact_on_src_with_other_recv;
+AT_network_link_name A_network_link_name;
+AT_route_element_name A_route_element_name;
+AT_cpu_power A_cpu_power;
+AT_include_file A_include_file;
+AT_process_function A_process_function;
+AT_route_dst A_route_dst;
+AT_cpu_state A_cpu_state;
+AT_network_link_latency A_network_link_latency;
+AT_network_link_state_file A_network_link_state_file;
+AT_cpu_interference_send A_cpu_interference_send;
+AT_cpu_state_file A_cpu_state_file;
+AT_network_link_bandwidth_file A_network_link_bandwidth_file;
+
+/* XML state. */
+#ifdef FLEX_DEBUG
+# define ENTER(state)  debug_enter(state,#state)
+# define LEAVE         debug_leave()
+# define SET(state)    debug_set(state,#state)
+  static void debug_enter(int, const char*);
+  static void debug_leave(void);
+  static void debug_set(int, const char*);
+#else
+# define ENTER(state)  (yy_push_state(state))
+# define LEAVE         (yy_pop_state())
+# define SET(state)    BEGIN(state)
+#endif
+
+/* Generic actions. */
+#define SKIP   /*skip*/
+#define SUCCEED        return 0
+
+#define FAIL   return fail
+static int fail(const char*, ...);
+const char * parse_err_msg(void);
+
+/* Text buffer stack handling. */
+char bufferstack[FLEXML_BUFFERSTACKSIZE];
+char* limit = bufferstack + FLEXML_BUFFERSTACKSIZE;
+typedef struct BufferLast_s {
+  struct BufferLast_s *old; char* saved; char new1[1];
+} BufferLast;
+BufferLast* last = (BufferLast*)0;
+char* next = bufferstack;
+
+#define BUFFERSET(P)  (P = next)
+#define BUFFERPUTC(C) (assert(next<limit), *(next++) = (C))
+#define BUFFERDONE    (BUFFERPUTC('\0'))
+
+#define BUFFERLITERAL(C,P) bufferliteral(C,&(P),surf_parse_text)
+static void bufferliteral(char c, const char** pp, char* text)
+{
+  char *s = strchr(text,c), *e = strrchr(text,c);
+  assert(s <= e); BUFFERSET(*pp);
+  while (++s<e) {
+    if (isspace(*s)) { BUFFERPUTC(' '); while (isspace(*s)) ++s; }
+    else BUFFERPUTC(*s);
+  }
+  BUFFERDONE;
+}
+
+#ifdef FLEXML_HasMixed
+static void pushbuffer(char* p)
+{
+  BufferLast* l = (BufferLast*)next;
+  assert(next < limit);
+  l->old = last;
+  l->saved = p;
+  next = l->new1;
+  last = l;
+}
+
+static char* popbuffer(void)
+{
+  BufferLast* l = last;
+  assert(last != (BufferLast*)0);
+  last = l->old;
+  next = (char*)l;
+  return l->saved;
+}
+#endif
+
+/* General internal entities are `unput' back onto the input stream... */
+#define ENTITYTEXT(T) \
+  { char *s = (T), *e = s+strlen(s);\
+    while (--e >= s) { unput(*e); }}
+/* Flex standard options. */
+#define YY_NO_INPUT 1
+/* Flex user-requested options. */
+/* XML character classes (currently restricted to ASCII). */
+/* "Common syntactic structures." */
+/* "Names and Tokens." */
+/* Miscellaneous. */
+/* Parser states (flex `exclusive start conditions'):
+ *
+ * PROLOG      the XML prolog of the document before <?xml...>
+ * DOCTYPE     the XML prolog of the document after <?xml...>
+ * EPILOG      after the root element
+ * INCOMMENT   inside an XML comment <!--....-->
+ * INPI                inside an XML PI <?...?>
+ * VALUE1      inside a '...'-delimited literal
+ * VALUE2      inside a "..."-delimited literal
+ * CDATA       inside a <![CDATA[...m4_userquote_end()> section.
+ * ROOT_<tag>  expect root element <tag>
+ * AL_<tag>    inside the attribute list for <tag>
+ * IN_<tag>    inside a <tag> with element contents (ready for end tag)
+ * IMPOSSIBLE  dummy to permit disabling rules; must be last
+ */
+
+
+
+
+
+
+
+
+
+
+#line 207 "surf/surfxml.l"
+/* State names. */
+const char* *statenames=NULL;
+#line 1870 "surf/surfxml.c"
+
+#define INITIAL 0
+#define PROLOG 1
+#define DOCTYPE 2
+#define EPILOG 3
+#define INCOMMENT 4
+#define INPI 5
+#define VALUE1 6
+#define VALUE2 7
+#define CDATA 8
+#define ROOT_platform_description 9
+#define AL_platform_description 10
+#define S_platform_description 11
+#define S_platform_description_1 12
+#define S_platform_description_2 13
+#define E_platform_description 14
+#define ROOT_include 15
+#define AL_include 16
+#define S_include 17
+#define S_include_1 18
+#define S_include_2 19
+#define E_include 20
+#define ROOT_cpu 21
+#define AL_cpu 22
+#define E_cpu 23
+#define ROOT_network_link 24
+#define AL_network_link 25
+#define E_network_link 26
+#define ROOT_route 27
+#define AL_route 28
+#define S_route 29
+#define S_route_1 30
+#define S_route_2 31
+#define E_route 32
+#define ROOT_route_element 33
+#define AL_route_element 34
+#define E_route_element 35
+#define ROOT_process 36
+#define AL_process 37
+#define S_process 38
+#define S_process_1 39
+#define S_process_2 40
+#define E_process 41
+#define ROOT_argument 42
+#define AL_argument 43
+#define E_argument 44
+#define IMPOSSIBLE 45
+
+#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
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int surf_parse_wrap (void );
+#else
+extern int surf_parse_wrap (void );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char *,yyconst char *,int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * );
+#endif
+
+#ifndef YY_NO_INPUT
+
+#ifdef __cplusplus
+static int yyinput (void );
+#else
+static int input (void );
+#endif
+
+#endif
+
+        static int yy_start_stack_ptr = 0;
+        static int yy_start_stack_depth = 0;
+        static int *yy_start_stack = 0;
+    
+    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( surf_parse_text, surf_parse_leng, 1, surf_parse_out )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+               { \
+               int c = '*'; \
+               size_t n; \
+               for ( n = 0; n < max_size && \
+                            (c = getc( surf_parse_in )) != EOF && c != '\n'; ++n ) \
+                       buf[n] = (char) c; \
+               if ( c == '\n' ) \
+                       buf[n++] = (char) c; \
+               if ( c == EOF && ferror( surf_parse_in ) ) \
+                       YY_FATAL_ERROR( "input in flex scanner failed" ); \
+               result = n; \
+               } \
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, surf_parse_in))==0 && ferror(surf_parse_in)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(surf_parse_in); \
+                       } \
+               }\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int surf_parse_lex (void);
+
+#define YY_DECL int surf_parse_lex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after surf_parse_text and surf_parse_leng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+       YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+       register yy_state_type yy_current_state;
+       register char *yy_cp, *yy_bp;
+       register int yy_act;
+    
+#line 211 "surf/surfxml.l"
+
+
+ /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
+ SET(PROLOG);
+  /* FleXML_init */
+  if(!statenames) statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*));
+  statenames[PROLOG] = NULL;
+  statenames[DOCTYPE] = NULL;
+  statenames[EPILOG] = NULL;
+  statenames[INCOMMENT] = NULL;
+  statenames[INPI] = NULL;
+  statenames[VALUE1] = NULL;
+  statenames[VALUE2] = NULL;
+  statenames[CDATA] = NULL;
+  statenames[ROOT_platform_description] = NULL;
+  statenames[AL_platform_description] = NULL;
+  statenames[S_platform_description] = "platform_description";
+  statenames[S_platform_description_1] = "platform_description";
+  statenames[S_platform_description_2] = "platform_description";
+  statenames[E_platform_description] = "platform_description";
+  statenames[ROOT_include] = NULL;
+  statenames[AL_include] = NULL;
+  statenames[S_include] = "include";
+  statenames[S_include_1] = "include";
+  statenames[S_include_2] = "include";
+  statenames[E_include] = "include";
+  statenames[ROOT_cpu] = NULL;
+  statenames[AL_cpu] = NULL;
+  statenames[E_cpu] = "cpu";
+  statenames[ROOT_network_link] = NULL;
+  statenames[AL_network_link] = NULL;
+  statenames[E_network_link] = "network_link";
+  statenames[ROOT_route] = NULL;
+  statenames[AL_route] = NULL;
+  statenames[S_route] = "route";
+  statenames[S_route_1] = "route";
+  statenames[S_route_2] = "route";
+  statenames[E_route] = "route";
+  statenames[ROOT_route_element] = NULL;
+  statenames[AL_route_element] = NULL;
+  statenames[E_route_element] = "route_element";
+  statenames[ROOT_process] = NULL;
+  statenames[AL_process] = NULL;
+  statenames[S_process] = "process";
+  statenames[S_process_1] = "process";
+  statenames[S_process_2] = "process";
+  statenames[E_process] = "process";
+  statenames[ROOT_argument] = NULL;
+  statenames[AL_argument] = NULL;
+  statenames[E_argument] = "argument";
+
+ /* COMMENTS and PIs: handled uniformly for efficiency. */
+
+#line 2126 "surf/surfxml.c"
+
+       if ( (yy_init) )
+               {
+               (yy_init) = 0;
+
+#ifdef YY_USER_INIT
+               YY_USER_INIT;
+#endif
+
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
+
+               if ( ! surf_parse_in )
+                       surf_parse_in = stdin;
+
+               if ( ! surf_parse_out )
+                       surf_parse_out = stdout;
+
+               if ( ! YY_CURRENT_BUFFER ) {
+                       surf_parse_ensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE );
+               }
+
+               surf_parse__load_buffer_state( );
+               }
+
+       while ( 1 )             /* loops until end-of-file is reached */
+               {
+               yy_cp = (yy_c_buf_p);
+
+               /* Support of surf_parse_text. */
+               *yy_cp = (yy_hold_char);
+
+               /* yy_bp points to the position in yy_ch_buf of the start of
+                * the current run.
+                */
+               yy_bp = yy_cp;
+
+               yy_current_state = (yy_start);
+yy_match:
+               do
+                       {
+                       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                       if ( yy_accept[yy_current_state] )
+                               {
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
+                               }
+                       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                               {
+                               yy_current_state = (int) yy_def[yy_current_state];
+                               if ( yy_current_state >= 1256 )
+                                       yy_c = yy_meta[(unsigned int) yy_c];
+                               }
+                       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                       ++yy_cp;
+                       }
+               while ( yy_base[yy_current_state] != 3533 );
+
+yy_find_action:
+               yy_act = yy_accept[yy_current_state];
+               if ( yy_act == 0 )
+                       { /* have to back up */
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       yy_act = yy_accept[yy_current_state];
+                       }
+
+               YY_DO_BEFORE_ACTION;
+
+               if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+                       {
+                       int yyl;
+                       for ( yyl = 0; yyl < surf_parse_leng; ++yyl )
+                               if ( surf_parse_text[yyl] == '\n' )
+                                          
+    surf_parse_lineno++;
+;
+                       }
+
+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 265 "surf/surfxml.l"
+ENTER(INCOMMENT);
+       YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 266 "surf/surfxml.l"
+ENTER(INPI);
+       YY_BREAK
+
+
+case 3:
+YY_RULE_SETUP
+#line 269 "surf/surfxml.l"
+LEAVE;
+       YY_BREAK
+case 4:
+#line 271 "surf/surfxml.l"
+case 5:
+#line 272 "surf/surfxml.l"
+case 6:
+/* rule 6 can match eol */
+YY_RULE_SETUP
+#line 272 "surf/surfxml.l"
+SKIP;
+       YY_BREAK
+case YY_STATE_EOF(INCOMMENT):
+#line 273 "surf/surfxml.l"
+FAIL("EOF in comment.");
+       YY_BREAK
+
+
+case 7:
+YY_RULE_SETUP
+#line 276 "surf/surfxml.l"
+LEAVE;
+       YY_BREAK
+case 8:
+#line 278 "surf/surfxml.l"
+case 9:
+/* rule 9 can match eol */
+YY_RULE_SETUP
+#line 278 "surf/surfxml.l"
+SKIP;
+       YY_BREAK
+case YY_STATE_EOF(INPI):
+#line 279 "surf/surfxml.l"
+FAIL("EOF in PI (processing instruction).");
+       YY_BREAK
+
+/* SPACES: skipped uniformly */
+case 10:
+/* rule 10 can match eol */
+YY_RULE_SETUP
+#line 284 "surf/surfxml.l"
+SKIP;
+       YY_BREAK
+/* PROLOG: determine root element and process it. */
+
+case 11:
+/* rule 11 can match eol */
+YY_RULE_SETUP
+#line 289 "surf/surfxml.l"
+SET(DOCTYPE); 
+       YY_BREAK
+case 12:
+/* rule 12 can match eol */
+YY_RULE_SETUP
+#line 290 "surf/surfxml.l"
+FAIL("Bad declaration %s.",surf_parse_text);
+       YY_BREAK
+
+
+case 13:
+/* rule 13 can match eol */
+YY_RULE_SETUP
+#line 294 "surf/surfxml.l"
+SET(ROOT_argument);
+       YY_BREAK
+case 14:
+/* rule 14 can match eol */
+YY_RULE_SETUP
+#line 295 "surf/surfxml.l"
+SET(ROOT_route_element);
+       YY_BREAK
+case 15:
+/* rule 15 can match eol */
+YY_RULE_SETUP
+#line 296 "surf/surfxml.l"
+SET(ROOT_cpu);
+       YY_BREAK
+case 16:
+/* rule 16 can match eol */
+YY_RULE_SETUP
+#line 297 "surf/surfxml.l"
+SET(ROOT_include);
+       YY_BREAK
+case 17:
+/* rule 17 can match eol */
+YY_RULE_SETUP
+#line 298 "surf/surfxml.l"
+SET(ROOT_route);
+       YY_BREAK
+case 18:
+/* rule 18 can match eol */
+YY_RULE_SETUP
+#line 299 "surf/surfxml.l"
+SET(ROOT_platform_description);
+       YY_BREAK
+case 19:
+/* rule 19 can match eol */
+YY_RULE_SETUP
+#line 300 "surf/surfxml.l"
+SET(ROOT_network_link);
+       YY_BREAK
+case 20:
+/* rule 20 can match eol */
+YY_RULE_SETUP
+#line 301 "surf/surfxml.l"
+SET(ROOT_process);
+       YY_BREAK
+case 21:
+/* rule 21 can match eol */
+YY_RULE_SETUP
+#line 302 "surf/surfxml.l"
+FAIL("Bad declaration %s.",surf_parse_text);
+       YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 303 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in prolog.", surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(PROLOG):
+case YY_STATE_EOF(DOCTYPE):
+#line 304 "surf/surfxml.l"
+FAIL("EOF in prolog.");
+       YY_BREAK
+
+/* RULES DERIVED FROM DTD. */
+/* <!-- Small DTD for SURF based tools. -->  */
+case 23:
+/* rule 23 can match eol */
+YY_RULE_SETUP
+#line 311 "surf/surfxml.l"
+{
+  ENTER(AL_platform_description);
+  }
+       YY_BREAK
+
+case 24:
+YY_RULE_SETUP
+#line 316 "surf/surfxml.l"
+{
+  LEAVE; STag_platform_description();pcdata = NULL; ENTER(S_platform_description);
+ }
+       YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 319 "surf/surfxml.l"
+{
+  LEAVE; STag_platform_description(); pcdata = NULL; ETag_platform_description();
+  switch (YY_START) {
+   case ROOT_platform_description: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 325 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of platform_description element.", surf_parse_text[0]);
+       YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 326 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `platform_description' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_platform_description):
+#line 327 "surf/surfxml.l"
+FAIL("EOF in attribute list of `platform_description' element.");
+       YY_BREAK
+
+
+case 28:
+/* rule 28 can match eol */
+YY_RULE_SETUP
+#line 331 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_platform_description();
+  switch (YY_START) {
+   case ROOT_platform_description: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 29:
+/* rule 29 can match eol */
+YY_RULE_SETUP
+#line 338 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</platform_description>' expected.",surf_parse_text);
+       YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 339 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</platform_description>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(E_platform_description):
+case YY_STATE_EOF(S_platform_description_2):
+case YY_STATE_EOF(S_platform_description):
+#line 340 "surf/surfxml.l"
+FAIL("Premature EOF: `</platform_description>' expected.");
+       YY_BREAK
+
+case 31:
+/* rule 31 can match eol */
+YY_RULE_SETUP
+#line 343 "surf/surfxml.l"
+{
+  A_include_file = NULL;
+  ENTER(AL_include);
+  }
+       YY_BREAK
+
+case 32:
+/* rule 32 can match eol */
+YY_RULE_SETUP
+#line 349 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_include_file);
+       YY_BREAK
+case 33:
+/* rule 33 can match eol */
+YY_RULE_SETUP
+#line 350 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_include_file);
+       YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 352 "surf/surfxml.l"
+{
+  if (!A_include_file) FAIL("Required attribute `file' not set for `include' element.");
+  LEAVE; STag_include();pcdata = NULL; ENTER(S_include);
+ }
+       YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 356 "surf/surfxml.l"
+{
+  if (!A_include_file) FAIL("Required attribute `file' not set for `include' element.");
+  LEAVE; STag_include(); pcdata = NULL; ETag_include();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_include: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 365 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of include element.", surf_parse_text[0]);
+       YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 366 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `include' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_include):
+#line 367 "surf/surfxml.l"
+FAIL("EOF in attribute list of `include' element.");
+       YY_BREAK
+
+
+case 38:
+/* rule 38 can match eol */
+YY_RULE_SETUP
+#line 371 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_include();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_include: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 39:
+/* rule 39 can match eol */
+YY_RULE_SETUP
+#line 380 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</include>' expected.",surf_parse_text);
+       YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 381 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</include>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(E_include):
+case YY_STATE_EOF(S_include):
+case YY_STATE_EOF(S_include_2):
+#line 382 "surf/surfxml.l"
+FAIL("Premature EOF: `</include>' expected.");
+       YY_BREAK
+
+case 41:
+/* rule 41 can match eol */
+YY_RULE_SETUP
+#line 385 "surf/surfxml.l"
+{
+  A_cpu_name = NULL;
+  A_cpu_power = NULL;
+  A_cpu_availability = "1.0";
+  A_cpu_availability_file = NULL;
+  A_cpu_state = A_cpu_state_ON;
+  A_cpu_state_file = NULL;
+  A_cpu_interference_send = "1.0";
+  A_cpu_interference_recv = "1.0";
+  A_cpu_interference_send_recv = "1.0";
+  A_cpu_max_outgoing_rate = "-1.0";
+  ENTER(AL_cpu);
+  }
+       YY_BREAK
+
+case 42:
+/* rule 42 can match eol */
+YY_RULE_SETUP
+#line 400 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_name);
+       YY_BREAK
+case 43:
+/* rule 43 can match eol */
+YY_RULE_SETUP
+#line 401 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_name);
+       YY_BREAK
+case 44:
+/* rule 44 can match eol */
+YY_RULE_SETUP
+#line 403 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_power);
+       YY_BREAK
+case 45:
+/* rule 45 can match eol */
+YY_RULE_SETUP
+#line 404 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_power);
+       YY_BREAK
+case 46:
+/* rule 46 can match eol */
+YY_RULE_SETUP
+#line 406 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_availability);
+       YY_BREAK
+case 47:
+/* rule 47 can match eol */
+YY_RULE_SETUP
+#line 407 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_availability);
+       YY_BREAK
+case 48:
+/* rule 48 can match eol */
+YY_RULE_SETUP
+#line 409 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_availability_file);
+       YY_BREAK
+case 49:
+/* rule 49 can match eol */
+YY_RULE_SETUP
+#line 410 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_availability_file);
+       YY_BREAK
+case 50:
+/* rule 50 can match eol */
+#line 413 "surf/surfxml.l"
+case 51:
+/* rule 51 can match eol */
+YY_RULE_SETUP
+#line 413 "surf/surfxml.l"
+A_cpu_state = A_cpu_state_ON;
+       YY_BREAK
+case 52:
+/* rule 52 can match eol */
+#line 415 "surf/surfxml.l"
+case 53:
+/* rule 53 can match eol */
+YY_RULE_SETUP
+#line 415 "surf/surfxml.l"
+A_cpu_state = A_cpu_state_OFF;
+       YY_BREAK
+case 54:
+/* rule 54 can match eol */
+YY_RULE_SETUP
+#line 417 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_state_file);
+       YY_BREAK
+case 55:
+/* rule 55 can match eol */
+YY_RULE_SETUP
+#line 418 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_state_file);
+       YY_BREAK
+case 56:
+/* rule 56 can match eol */
+YY_RULE_SETUP
+#line 420 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_interference_send);
+       YY_BREAK
+case 57:
+/* rule 57 can match eol */
+YY_RULE_SETUP
+#line 421 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_interference_send);
+       YY_BREAK
+case 58:
+/* rule 58 can match eol */
+YY_RULE_SETUP
+#line 423 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_interference_recv);
+       YY_BREAK
+case 59:
+/* rule 59 can match eol */
+YY_RULE_SETUP
+#line 424 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_interference_recv);
+       YY_BREAK
+case 60:
+/* rule 60 can match eol */
+YY_RULE_SETUP
+#line 426 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_interference_send_recv);
+       YY_BREAK
+case 61:
+/* rule 61 can match eol */
+YY_RULE_SETUP
+#line 427 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_interference_send_recv);
+       YY_BREAK
+case 62:
+/* rule 62 can match eol */
+YY_RULE_SETUP
+#line 429 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_cpu_max_outgoing_rate);
+       YY_BREAK
+case 63:
+/* rule 63 can match eol */
+YY_RULE_SETUP
+#line 430 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_cpu_max_outgoing_rate);
+       YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 432 "surf/surfxml.l"
+{
+  if (!A_cpu_name) FAIL("Required attribute `name' not set for `cpu' element.");
+  if (!A_cpu_power) FAIL("Required attribute `power' not set for `cpu' element.");
+  LEAVE; STag_cpu();pcdata = NULL; ENTER(E_cpu);
+ }
+       YY_BREAK
+case 65:
+YY_RULE_SETUP
+#line 437 "surf/surfxml.l"
+{
+  if (!A_cpu_name) FAIL("Required attribute `name' not set for `cpu' element.");
+  if (!A_cpu_power) FAIL("Required attribute `power' not set for `cpu' element.");
+  LEAVE; STag_cpu(); pcdata = NULL; ETag_cpu();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_cpu: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 447 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of cpu element.", surf_parse_text[0]);
+       YY_BREAK
+case 67:
+YY_RULE_SETUP
+#line 448 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `cpu' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_cpu):
+#line 449 "surf/surfxml.l"
+FAIL("EOF in attribute list of `cpu' element.");
+       YY_BREAK
+
+
+case 68:
+/* rule 68 can match eol */
+YY_RULE_SETUP
+#line 453 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_cpu();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_cpu: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 69:
+/* rule 69 can match eol */
+YY_RULE_SETUP
+#line 462 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</cpu>' expected.",surf_parse_text);
+       YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 463 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</cpu>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(E_cpu):
+#line 464 "surf/surfxml.l"
+FAIL("Premature EOF: `</cpu>' expected.");
+       YY_BREAK
+
+case 71:
+/* rule 71 can match eol */
+YY_RULE_SETUP
+#line 467 "surf/surfxml.l"
+{
+  A_network_link_name = NULL;
+  A_network_link_bandwidth = NULL;
+  A_network_link_bandwidth_file = NULL;
+  A_network_link_latency = "0.0";
+  A_network_link_latency_file = NULL;
+  A_network_link_state = A_network_link_state_ON;
+  A_network_link_state_file = NULL;
+  ENTER(AL_network_link);
+  }
+       YY_BREAK
+
+case 72:
+/* rule 72 can match eol */
+YY_RULE_SETUP
+#line 479 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_network_link_name);
+       YY_BREAK
+case 73:
+/* rule 73 can match eol */
+YY_RULE_SETUP
+#line 480 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_network_link_name);
+       YY_BREAK
+case 74:
+/* rule 74 can match eol */
+YY_RULE_SETUP
+#line 482 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_network_link_bandwidth);
+       YY_BREAK
+case 75:
+/* rule 75 can match eol */
+YY_RULE_SETUP
+#line 483 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_network_link_bandwidth);
+       YY_BREAK
+case 76:
+/* rule 76 can match eol */
+YY_RULE_SETUP
+#line 485 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_network_link_bandwidth_file);
+       YY_BREAK
+case 77:
+/* rule 77 can match eol */
+YY_RULE_SETUP
+#line 486 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_network_link_bandwidth_file);
+       YY_BREAK
+case 78:
+/* rule 78 can match eol */
+YY_RULE_SETUP
+#line 488 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_network_link_latency);
+       YY_BREAK
+case 79:
+/* rule 79 can match eol */
+YY_RULE_SETUP
+#line 489 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_network_link_latency);
+       YY_BREAK
+case 80:
+/* rule 80 can match eol */
+YY_RULE_SETUP
+#line 491 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_network_link_latency_file);
+       YY_BREAK
+case 81:
+/* rule 81 can match eol */
+YY_RULE_SETUP
+#line 492 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_network_link_latency_file);
+       YY_BREAK
+case 82:
+/* rule 82 can match eol */
+#line 495 "surf/surfxml.l"
+case 83:
+/* rule 83 can match eol */
+YY_RULE_SETUP
+#line 495 "surf/surfxml.l"
+A_network_link_state = A_network_link_state_ON;
+       YY_BREAK
+case 84:
+/* rule 84 can match eol */
+#line 497 "surf/surfxml.l"
+case 85:
+/* rule 85 can match eol */
+YY_RULE_SETUP
+#line 497 "surf/surfxml.l"
+A_network_link_state = A_network_link_state_OFF;
+       YY_BREAK
+case 86:
+/* rule 86 can match eol */
+YY_RULE_SETUP
+#line 499 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_network_link_state_file);
+       YY_BREAK
+case 87:
+/* rule 87 can match eol */
+YY_RULE_SETUP
+#line 500 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_network_link_state_file);
+       YY_BREAK
+case 88:
+YY_RULE_SETUP
+#line 502 "surf/surfxml.l"
+{
+  if (!A_network_link_name) FAIL("Required attribute `name' not set for `network_link' element.");
+  if (!A_network_link_bandwidth) FAIL("Required attribute `bandwidth' not set for `network_link' element.");
+  LEAVE; STag_network_link();pcdata = NULL; ENTER(E_network_link);
+ }
+       YY_BREAK
+case 89:
+YY_RULE_SETUP
+#line 507 "surf/surfxml.l"
+{
+  if (!A_network_link_name) FAIL("Required attribute `name' not set for `network_link' element.");
+  if (!A_network_link_bandwidth) FAIL("Required attribute `bandwidth' not set for `network_link' element.");
+  LEAVE; STag_network_link(); pcdata = NULL; ETag_network_link();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_network_link: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 90:
+YY_RULE_SETUP
+#line 517 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of network_link element.", surf_parse_text[0]);
+       YY_BREAK
+case 91:
+YY_RULE_SETUP
+#line 518 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `network_link' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_network_link):
+#line 519 "surf/surfxml.l"
+FAIL("EOF in attribute list of `network_link' element.");
+       YY_BREAK
+
+
+case 92:
+/* rule 92 can match eol */
+YY_RULE_SETUP
+#line 523 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_network_link();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_network_link: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 93:
+/* rule 93 can match eol */
+YY_RULE_SETUP
+#line 532 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</network_link>' expected.",surf_parse_text);
+       YY_BREAK
+case 94:
+YY_RULE_SETUP
+#line 533 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</network_link>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(E_network_link):
+#line 534 "surf/surfxml.l"
+FAIL("Premature EOF: `</network_link>' expected.");
+       YY_BREAK
+
+case 95:
+/* rule 95 can match eol */
+YY_RULE_SETUP
+#line 537 "surf/surfxml.l"
+{
+  A_route_src = NULL;
+  A_route_dst = NULL;
+  A_route_impact_on_src = "0.0";
+  A_route_impact_on_dst = "0.0";
+  A_route_impact_on_src_with_other_recv = "0.0";
+  A_route_impact_on_dst_with_other_send = "0.0";
+  ENTER(AL_route);
+  }
+       YY_BREAK
+
+case 96:
+/* rule 96 can match eol */
+YY_RULE_SETUP
+#line 548 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_src);
+       YY_BREAK
+case 97:
+/* rule 97 can match eol */
+YY_RULE_SETUP
+#line 549 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_src);
+       YY_BREAK
+case 98:
+/* rule 98 can match eol */
+YY_RULE_SETUP
+#line 551 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_dst);
+       YY_BREAK
+case 99:
+/* rule 99 can match eol */
+YY_RULE_SETUP
+#line 552 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_dst);
+       YY_BREAK
+case 100:
+/* rule 100 can match eol */
+YY_RULE_SETUP
+#line 554 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_impact_on_src);
+       YY_BREAK
+case 101:
+/* rule 101 can match eol */
+YY_RULE_SETUP
+#line 555 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_impact_on_src);
+       YY_BREAK
+case 102:
+/* rule 102 can match eol */
+YY_RULE_SETUP
+#line 557 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_impact_on_dst);
+       YY_BREAK
+case 103:
+/* rule 103 can match eol */
+YY_RULE_SETUP
+#line 558 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_impact_on_dst);
+       YY_BREAK
+case 104:
+/* rule 104 can match eol */
+YY_RULE_SETUP
+#line 560 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_impact_on_src_with_other_recv);
+       YY_BREAK
+case 105:
+/* rule 105 can match eol */
+YY_RULE_SETUP
+#line 561 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_impact_on_src_with_other_recv);
+       YY_BREAK
+case 106:
+/* rule 106 can match eol */
+YY_RULE_SETUP
+#line 563 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_impact_on_dst_with_other_send);
+       YY_BREAK
+case 107:
+/* rule 107 can match eol */
+YY_RULE_SETUP
+#line 564 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_impact_on_dst_with_other_send);
+       YY_BREAK
+case 108:
+YY_RULE_SETUP
+#line 566 "surf/surfxml.l"
+{
+  if (!A_route_src) FAIL("Required attribute `src' not set for `route' element.");
+  if (!A_route_dst) FAIL("Required attribute `dst' not set for `route' element.");
+  LEAVE; STag_route();pcdata = NULL; ENTER(S_route);
+ }
+       YY_BREAK
+case 109:
+YY_RULE_SETUP
+#line 571 "surf/surfxml.l"
+{
+  if (!A_route_src) FAIL("Required attribute `src' not set for `route' element.");
+  if (!A_route_dst) FAIL("Required attribute `dst' not set for `route' element.");
+  LEAVE; STag_route(); pcdata = NULL; ETag_route();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_route: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 110:
+YY_RULE_SETUP
+#line 581 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of route element.", surf_parse_text[0]);
+       YY_BREAK
+case 111:
+YY_RULE_SETUP
+#line 582 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `route' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_route):
+#line 583 "surf/surfxml.l"
+FAIL("EOF in attribute list of `route' element.");
+       YY_BREAK
+
+
+case 112:
+/* rule 112 can match eol */
+YY_RULE_SETUP
+#line 587 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_route();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_route: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 113:
+/* rule 113 can match eol */
+YY_RULE_SETUP
+#line 596 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</route>' expected.",surf_parse_text);
+       YY_BREAK
+case 114:
+YY_RULE_SETUP
+#line 597 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</route>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(S_route):
+case YY_STATE_EOF(S_route_2):
+case YY_STATE_EOF(E_route):
+#line 598 "surf/surfxml.l"
+FAIL("Premature EOF: `</route>' expected.");
+       YY_BREAK
+
+case 115:
+/* rule 115 can match eol */
+YY_RULE_SETUP
+#line 601 "surf/surfxml.l"
+{
+  A_route_element_name = NULL;
+  ENTER(AL_route_element);
+  }
+       YY_BREAK
+
+case 116:
+/* rule 116 can match eol */
+YY_RULE_SETUP
+#line 607 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_route_element_name);
+       YY_BREAK
+case 117:
+/* rule 117 can match eol */
+YY_RULE_SETUP
+#line 608 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_route_element_name);
+       YY_BREAK
+case 118:
+YY_RULE_SETUP
+#line 610 "surf/surfxml.l"
+{
+  if (!A_route_element_name) FAIL("Required attribute `name' not set for `route_element' element.");
+  LEAVE; STag_route_element();pcdata = NULL; ENTER(E_route_element);
+ }
+       YY_BREAK
+case 119:
+YY_RULE_SETUP
+#line 614 "surf/surfxml.l"
+{
+  if (!A_route_element_name) FAIL("Required attribute `name' not set for `route_element' element.");
+  LEAVE; STag_route_element(); pcdata = NULL; ETag_route_element();
+  switch (YY_START) {
+   case S_route_1: case S_route: case S_route_2: SET(S_route_2); break;
+   case ROOT_route_element: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 120:
+YY_RULE_SETUP
+#line 622 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of route_element element.", surf_parse_text[0]);
+       YY_BREAK
+case 121:
+YY_RULE_SETUP
+#line 623 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `route_element' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_route_element):
+#line 624 "surf/surfxml.l"
+FAIL("EOF in attribute list of `route_element' element.");
+       YY_BREAK
+
+
+case 122:
+/* rule 122 can match eol */
+YY_RULE_SETUP
+#line 628 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_route_element();
+  switch (YY_START) {
+   case S_route_1: case S_route: case S_route_2: SET(S_route_2); break;
+   case ROOT_route_element: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 123:
+/* rule 123 can match eol */
+YY_RULE_SETUP
+#line 636 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</route_element>' expected.",surf_parse_text);
+       YY_BREAK
+case 124:
+YY_RULE_SETUP
+#line 637 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</route_element>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(E_route_element):
+#line 638 "surf/surfxml.l"
+FAIL("Premature EOF: `</route_element>' expected.");
+       YY_BREAK
+
+case 125:
+/* rule 125 can match eol */
+YY_RULE_SETUP
+#line 641 "surf/surfxml.l"
+{
+  A_process_host = NULL;
+  A_process_function = NULL;
+  ENTER(AL_process);
+  }
+       YY_BREAK
+
+case 126:
+/* rule 126 can match eol */
+YY_RULE_SETUP
+#line 648 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_process_host);
+       YY_BREAK
+case 127:
+/* rule 127 can match eol */
+YY_RULE_SETUP
+#line 649 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_process_host);
+       YY_BREAK
+case 128:
+/* rule 128 can match eol */
+YY_RULE_SETUP
+#line 651 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_process_function);
+       YY_BREAK
+case 129:
+/* rule 129 can match eol */
+YY_RULE_SETUP
+#line 652 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_process_function);
+       YY_BREAK
+case 130:
+YY_RULE_SETUP
+#line 654 "surf/surfxml.l"
+{
+  if (!A_process_host) FAIL("Required attribute `host' not set for `process' element.");
+  if (!A_process_function) FAIL("Required attribute `function' not set for `process' element.");
+  LEAVE; STag_process();pcdata = NULL; ENTER(S_process);
+ }
+       YY_BREAK
+case 131:
+YY_RULE_SETUP
+#line 659 "surf/surfxml.l"
+{
+  if (!A_process_host) FAIL("Required attribute `host' not set for `process' element.");
+  if (!A_process_function) FAIL("Required attribute `function' not set for `process' element.");
+  LEAVE; STag_process(); pcdata = NULL; ETag_process();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_process: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 132:
+YY_RULE_SETUP
+#line 669 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of process element.", surf_parse_text[0]);
+       YY_BREAK
+case 133:
+YY_RULE_SETUP
+#line 670 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `process' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_process):
+#line 671 "surf/surfxml.l"
+FAIL("EOF in attribute list of `process' element.");
+       YY_BREAK
+
+
+case 134:
+/* rule 134 can match eol */
+YY_RULE_SETUP
+#line 675 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_process();
+  switch (YY_START) {
+   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
+   case S_include: case S_include_2: case S_include_1: SET(S_include_2); break;
+   case ROOT_process: SET(EPILOG); break;
+  }
+ }
+       YY_BREAK
+case 135:
+/* rule 135 can match eol */
+YY_RULE_SETUP
+#line 684 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</process>' expected.",surf_parse_text);
+       YY_BREAK
+case 136:
+YY_RULE_SETUP
+#line 685 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</process>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(S_process):
+case YY_STATE_EOF(E_process):
+case YY_STATE_EOF(S_process_2):
+#line 686 "surf/surfxml.l"
+FAIL("Premature EOF: `</process>' expected.");
+       YY_BREAK
+
+case 137:
+/* rule 137 can match eol */
+YY_RULE_SETUP
+#line 689 "surf/surfxml.l"
+{
+  A_argument_value = NULL;
+  ENTER(AL_argument);
+  }
+       YY_BREAK
+
+case 138:
+/* rule 138 can match eol */
+YY_RULE_SETUP
+#line 695 "surf/surfxml.l"
+ENTER(VALUE1); BUFFERSET(A_argument_value);
+       YY_BREAK
+case 139:
+/* rule 139 can match eol */
+YY_RULE_SETUP
+#line 696 "surf/surfxml.l"
+ENTER(VALUE2); BUFFERSET(A_argument_value);
+       YY_BREAK
+case 140:
+YY_RULE_SETUP
+#line 698 "surf/surfxml.l"
+{
+  if (!A_argument_value) FAIL("Required attribute `value' not set for `argument' element.");
+  LEAVE; STag_argument();pcdata = NULL; ENTER(E_argument);
+ }
+       YY_BREAK
+case 141:
+YY_RULE_SETUP
+#line 702 "surf/surfxml.l"
+{
+  if (!A_argument_value) FAIL("Required attribute `value' not set for `argument' element.");
+  LEAVE; STag_argument(); pcdata = NULL; ETag_argument();
+  switch (YY_START) {
+   case ROOT_argument: SET(EPILOG); break;
+   case S_process_1: case S_process: case S_process_2: SET(S_process_2); break;
+  }
+ }
+       YY_BREAK
+case 142:
+YY_RULE_SETUP
+#line 710 "surf/surfxml.l"
+FAIL("Unexpected character `%c' in attribute list of argument element.", surf_parse_text[0]);
+       YY_BREAK
+case 143:
+YY_RULE_SETUP
+#line 711 "surf/surfxml.l"
+FAIL("Bad attribute `%s' in `argument' element start tag.",surf_parse_text);
+       YY_BREAK
+case YY_STATE_EOF(AL_argument):
+#line 712 "surf/surfxml.l"
+FAIL("EOF in attribute list of `argument' element.");
+       YY_BREAK
+
+
+case 144:
+/* rule 144 can match eol */
+YY_RULE_SETUP
+#line 716 "surf/surfxml.l"
+{
+  LEAVE;
+  ETag_argument();
+  switch (YY_START) {
+   case ROOT_argument: SET(EPILOG); break;
+   case S_process_1: case S_process: case S_process_2: SET(S_process_2); break;
+  }
+ }
+       YY_BREAK
+case 145:
+/* rule 145 can match eol */
+YY_RULE_SETUP
+#line 724 "surf/surfxml.l"
+FAIL("Unexpected end-tag `%s': `</argument>' expected.",surf_parse_text);
+       YY_BREAK
+case 146:
+YY_RULE_SETUP
+#line 725 "surf/surfxml.l"
+FAIL("Unexpected character `%c': `</argument>' expected.",surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(E_argument):
+#line 726 "surf/surfxml.l"
+FAIL("Premature EOF: `</argument>' expected.");
+       YY_BREAK
+
+/* EPILOG: after the root element. */
+
+case 147:
+YY_RULE_SETUP
+#line 732 "surf/surfxml.l"
+{SET(PROLOG); yyless(0); return -1;}
+       YY_BREAK
+case YY_STATE_EOF(EPILOG):
+#line 733 "surf/surfxml.l"
+SUCCEED;
+       YY_BREAK
+
+/* CHARACTER DATA. */
+
+/* Non-defined standard entities... */
+case 148:
+YY_RULE_SETUP
+#line 740 "surf/surfxml.l"
+BUFFERPUTC('&');
+       YY_BREAK
+case 149:
+YY_RULE_SETUP
+#line 741 "surf/surfxml.l"
+BUFFERPUTC('<');
+       YY_BREAK
+case 150:
+YY_RULE_SETUP
+#line 742 "surf/surfxml.l"
+BUFFERPUTC('>');
+       YY_BREAK
+case 151:
+YY_RULE_SETUP
+#line 743 "surf/surfxml.l"
+BUFFERPUTC('\'');
+       YY_BREAK
+case 152:
+YY_RULE_SETUP
+#line 744 "surf/surfxml.l"
+BUFFERPUTC('"');
+       YY_BREAK
+/* Character entities. */
+case 153:
+YY_RULE_SETUP
+#line 747 "surf/surfxml.l"
+BUFFERPUTC((unsigned char)atoi(surf_parse_text+2));
+       YY_BREAK
+case 154:
+YY_RULE_SETUP
+#line 748 "surf/surfxml.l"
+BUFFERPUTC((unsigned char)strtol(surf_parse_text+3,NULL,16));
+       YY_BREAK
+
+
+case 155:
+/* rule 155 can match eol */
+#line 753 "surf/surfxml.l"
+case 156:
+/* rule 156 can match eol */
+#line 754 "surf/surfxml.l"
+case 157:
+/* rule 157 can match eol */
+#line 755 "surf/surfxml.l"
+case 158:
+/* rule 158 can match eol */
+YY_RULE_SETUP
+#line 755 "surf/surfxml.l"
+BUFFERPUTC('\n');
+       YY_BREAK
+
+
+case 159:
+YY_RULE_SETUP
+#line 759 "surf/surfxml.l"
+ENTER(CDATA);
+       YY_BREAK
+case 160:
+YY_RULE_SETUP
+#line 760 "surf/surfxml.l"
+FAIL("Unexpected `]""]>' in character data.");
+       YY_BREAK
+
+
+case 161:
+YY_RULE_SETUP
+#line 764 "surf/surfxml.l"
+BUFFERDONE; LEAVE;
+       YY_BREAK
+case YY_STATE_EOF(VALUE1):
+#line 765 "surf/surfxml.l"
+FAIL("EOF in literal (\"'\" expected).");
+       YY_BREAK
+
+
+case 162:
+YY_RULE_SETUP
+#line 769 "surf/surfxml.l"
+BUFFERDONE; LEAVE;
+       YY_BREAK
+case YY_STATE_EOF(VALUE2):
+#line 770 "surf/surfxml.l"
+FAIL("EOF in literal (`\"' expected).");
+       YY_BREAK
+
+
+case 163:
+/* rule 163 can match eol */
+YY_RULE_SETUP
+#line 774 "surf/surfxml.l"
+BUFFERPUTC(surf_parse_text[0]);
+       YY_BREAK
+case 164:
+YY_RULE_SETUP
+#line 775 "surf/surfxml.l"
+FAIL("Spurious `%c' in character data.",surf_parse_text[0]);
+       YY_BREAK
+
+
+case 165:
+YY_RULE_SETUP
+#line 779 "surf/surfxml.l"
+LEAVE;
+       YY_BREAK
+/* "]""]"              BUFFERPUTC(surf_parse_text[0]); BUFFERPUTC(surf_parse_text[1]); */
+case 166:
+YY_RULE_SETUP
+#line 781 "surf/surfxml.l"
+BUFFERPUTC(surf_parse_text[0]);
+       YY_BREAK
+case YY_STATE_EOF(CDATA):
+#line 782 "surf/surfxml.l"
+FAIL("EOF in CDATA section.");
+       YY_BREAK
+
+/* Impossible rules to avoid warnings from flex(1). */
+/* Ideally, this should be replaced by code in flexml.pl that
+    generates just the states not covered by other rules. */
+
+case 167:
+/* rule 167 can match eol */
+YY_RULE_SETUP
+#line 789 "surf/surfxml.l"
+FAIL("Syntax error on character `%c'.", surf_parse_text[0]);
+       YY_BREAK
+
+case 168:
+YY_RULE_SETUP
+#line 792 "surf/surfxml.l"
+ECHO;
+       YY_BREAK
+#line 3499 "surf/surfxml.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(ROOT_platform_description):
+case YY_STATE_EOF(S_platform_description_1):
+case YY_STATE_EOF(ROOT_include):
+case YY_STATE_EOF(S_include_1):
+case YY_STATE_EOF(ROOT_cpu):
+case YY_STATE_EOF(ROOT_network_link):
+case YY_STATE_EOF(ROOT_route):
+case YY_STATE_EOF(S_route_1):
+case YY_STATE_EOF(ROOT_route_element):
+case YY_STATE_EOF(ROOT_process):
+case YY_STATE_EOF(S_process_1):
+case YY_STATE_EOF(ROOT_argument):
+case YY_STATE_EOF(IMPOSSIBLE):
+       yyterminate();
+
+       case YY_END_OF_BUFFER:
+               {
+               /* Amount of text matched not including the EOB char. */
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+               /* Undo the effects of YY_DO_BEFORE_ACTION. */
+               *yy_cp = (yy_hold_char);
+               YY_RESTORE_YY_MORE_OFFSET
+
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+                       {
+                       /* We're scanning a new file or input source.  It's
+                        * possible that this happened because the user
+                        * just pointed surf_parse_in at a new source and called
+                        * surf_parse_lex().  If so, then we have to assure
+                        * consistency between YY_CURRENT_BUFFER and our
+                        * globals.  Here is the right place to do so, because
+                        * this is the first action (other than possibly a
+                        * back-up) that will match for the new input source.
+                        */
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = surf_parse_in;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+                       }
+
+               /* Note that here we test for yy_c_buf_p "<=" to the position
+                * of the first EOB in the buffer, since yy_c_buf_p will
+                * already have been incremented past the NUL character
+                * (since all states make transitions on EOB to the
+                * end-of-buffer state).  Contrast this with the test
+                * in input().
+                */
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+                       { /* This was really a NUL. */
+                       yy_state_type yy_next_state;
+
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+                       yy_current_state = yy_get_previous_state(  );
+
+                       /* Okay, we're now positioned to make the NUL
+                        * transition.  We couldn't have
+                        * yy_get_previous_state() go ahead and do it
+                        * for us because it doesn't know how to deal
+                        * with the possibility of jamming (and we don't
+                        * want to build jamming into it because then it
+                        * will run more slowly).
+                        */
+
+                       yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+                       if ( yy_next_state )
+                               {
+                               /* Consume the NUL. */
+                               yy_cp = ++(yy_c_buf_p);
+                               yy_current_state = yy_next_state;
+                               goto yy_match;
+                               }
+
+                       else
+                               {
+                               yy_cp = (yy_c_buf_p);
+                               goto yy_find_action;
+                               }
+                       }
+
+               else switch ( yy_get_next_buffer(  ) )
+                       {
+                       case EOB_ACT_END_OF_FILE:
+                               {
+                               (yy_did_buffer_switch_on_eof) = 0;
+
+                               if ( surf_parse_wrap( ) )
+                                       {
+                                       /* Note: because we've taken care in
+                                        * yy_get_next_buffer() to have set up
+                                        * surf_parse_text, we can now set up
+                                        * yy_c_buf_p so that if some total
+                                        * hoser (like flex itself) wants to
+                                        * call the scanner after we return the
+                                        * YY_NULL, it'll still work - another
+                                        * YY_NULL will get returned.
+                                        */
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+                                       yy_act = YY_STATE_EOF(YY_START);
+                                       goto do_action;
+                                       }
+
+                               else
+                                       {
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
+                                       }
+                               break;
+                               }
+
+                       case EOB_ACT_CONTINUE_SCAN:
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
+
+                               yy_current_state = yy_get_previous_state(  );
+
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_match;
+
+                       case EOB_ACT_LAST_MATCH:
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+                               yy_current_state = yy_get_previous_state(  );
+
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_find_action;
+                       }
+               break;
+               }
+
+       default:
+               YY_FATAL_ERROR(
+                       "fatal flex scanner internal error--no action found" );
+       } /* end of action switch */
+               } /* end of scanning one token */
+} /* end of surf_parse_lex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *     EOB_ACT_LAST_MATCH -
+ *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *     EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (void)
+{
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
+       register int number_to_move, i;
+       int ret_val;
+
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+               YY_FATAL_ERROR(
+               "fatal flex scanner internal error--end of buffer missed" );
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+               { /* Don't try to fill the buffer, so this is an EOF. */
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+                       {
+                       /* We matched a single character, the EOB, so
+                        * treat this as a final EOF.
+                        */
+                       return EOB_ACT_END_OF_FILE;
+                       }
+
+               else
+                       {
+                       /* We matched some text prior to the EOB, first
+                        * process it.
+                        */
+                       return EOB_ACT_LAST_MATCH;
+                       }
+               }
+
+       /* Try to read more data. */
+
+       /* First move last chars to start of buffer. */
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
+
+       for ( i = 0; i < number_to_move; ++i )
+               *(dest++) = *(source++);
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+               /* don't do the read, it's not guaranteed to return an EOF,
+                * just force an EOF
+                */
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+       else
+               {
+                       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. */
+
+                       /* 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. */
+                                       surf_parse_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
+                               }
+                       else
+                               /* Can't grow it, we don't own it. */
+                               b->yy_ch_buf = 0;
+
+                       if ( ! b->yy_ch_buf )
+                               YY_FATAL_ERROR(
+                               "fatal error - scanner input buffer overflow" );
+
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+                                               number_to_move - 1;
+
+                       }
+
+               if ( num_to_read > YY_READ_BUF_SIZE )
+                       num_to_read = YY_READ_BUF_SIZE;
+
+               /* Read in more data. */
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), num_to_read );
+
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       if ( (yy_n_chars) == 0 )
+               {
+               if ( number_to_move == YY_MORE_ADJ )
+                       {
+                       ret_val = EOB_ACT_END_OF_FILE;
+                       surf_parse_restart(surf_parse_in  );
+                       }
+
+               else
+                       {
+                       ret_val = EOB_ACT_LAST_MATCH;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+                               YY_BUFFER_EOF_PENDING;
+                       }
+               }
+
+       else
+               ret_val = EOB_ACT_CONTINUE_SCAN;
+
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+       (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+       return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (void)
+{
+       register yy_state_type yy_current_state;
+       register char *yy_cp;
+    
+       yy_current_state = (yy_start);
+
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+               {
+               register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+               if ( yy_accept[yy_current_state] )
+                       {
+                       (yy_last_accepting_state) = yy_current_state;
+                       (yy_last_accepting_cpos) = yy_cp;
+                       }
+               while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                       {
+                       yy_current_state = (int) yy_def[yy_current_state];
+                       if ( yy_current_state >= 1256 )
+                               yy_c = yy_meta[(unsigned int) yy_c];
+                       }
+               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+               }
+
+       return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *     next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
+       register int yy_is_jam;
+       register char *yy_cp = (yy_c_buf_p);
+
+       register YY_CHAR yy_c = 1;
+       if ( yy_accept[yy_current_state] )
+               {
+               (yy_last_accepting_state) = yy_current_state;
+               (yy_last_accepting_cpos) = yy_cp;
+               }
+       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+               {
+               yy_current_state = (int) yy_def[yy_current_state];
+               if ( yy_current_state >= 1256 )
+                       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 == 1255);
+
+       return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (void)
+#else
+    static int input  (void)
+#endif
+
+{
+       int c;
+    
+       *(yy_c_buf_p) = (yy_hold_char);
+
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+               {
+               /* yy_c_buf_p now points to the character we want to return.
+                * If this occurs *before* the EOB characters, then it's a
+                * valid NUL; if not, then we've hit the end of the buffer.
+                */
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+                       /* This was really a NUL. */
+                       *(yy_c_buf_p) = '\0';
+
+               else
+                       { /* need more input */
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
+
+                       switch ( yy_get_next_buffer(  ) )
+                               {
+                               case EOB_ACT_LAST_MATCH:
+                                       /* This happens because yy_g_n_b()
+                                        * sees that we've accumulated a
+                                        * token and flags that we need to
+                                        * try matching the token before
+                                        * proceeding.  But for input(),
+                                        * there's no matching to consider.
+                                        * So convert the EOB_ACT_LAST_MATCH
+                                        * to EOB_ACT_END_OF_FILE.
+                                        */
+
+                                       /* Reset buffer status. */
+                                       surf_parse_restart(surf_parse_in );
+
+                                       /*FALLTHROUGH*/
+
+                               case EOB_ACT_END_OF_FILE:
+                                       {
+                                       if ( surf_parse_wrap( ) )
+                                               return EOF;
+
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
+#ifdef __cplusplus
+                                       return yyinput();
+#else
+                                       return input();
+#endif
+                                       }
+
+                               case EOB_ACT_CONTINUE_SCAN:
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
+                                       break;
+                               }
+                       }
+               }
+
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve surf_parse_text */
+       (yy_hold_char) = *++(yy_c_buf_p);
+
+       if ( c == '\n' )
+                  
+    surf_parse_lineno++;
+;
+
+       return c;
+}
+#endif /* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void surf_parse_restart  (FILE * input_file )
+{
+    
+       if ( ! YY_CURRENT_BUFFER ){
+        surf_parse_ensure_buffer_stack ();
+               YY_CURRENT_BUFFER_LVALUE =
+            surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE );
+       }
+
+       surf_parse__init_buffer(YY_CURRENT_BUFFER,input_file );
+       surf_parse__load_buffer_state( );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void surf_parse__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              surf_parse_pop_buffer_state();
+        *              surf_parse_push_buffer_state(new_buffer);
+     */
+       surf_parse_ensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
+               return;
+
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       surf_parse__load_buffer_state( );
+
+       /* We don't actually know whether we did this switch during
+        * EOF (surf_parse_wrap()) processing, but the only time this flag
+        * is looked at is after surf_parse_wrap() is called, so it's safe
+        * to go ahead and always set it.
+        */
+       (yy_did_buffer_switch_on_eof) = 1;
+}
+
+static void surf_parse__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;
+       surf_parse_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE surf_parse__create_buffer  (FILE * file, int  size )
+{
+       YY_BUFFER_STATE b;
+    
+       b = (YY_BUFFER_STATE) surf_parse_alloc(sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__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 *) surf_parse_alloc(b->yy_buf_size + 2  );
+       if ( ! b->yy_ch_buf )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__create_buffer()" );
+
+       b->yy_is_our_buffer = 1;
+
+       surf_parse__init_buffer(b,file );
+
+       return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with surf_parse__create_buffer()
+ * 
+ */
+    void surf_parse__delete_buffer (YY_BUFFER_STATE  b )
+{
+    
+       if ( ! b )
+               return;
+
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+       if ( b->yy_is_our_buffer )
+               surf_parse_free((void *) b->yy_ch_buf  );
+
+       surf_parse_free((void *) b  );
+}
+
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a surf_parse_restart() or at EOF.
+ */
+    static void surf_parse__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
+
+{
+       int oerrno = errno;
+    
+       surf_parse__flush_buffer(b );
+
+       b->yy_input_file = file;
+       b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then surf_parse__init_buffer was _probably_
+     * called from surf_parse_restart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+       errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void surf_parse__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 )
+               surf_parse__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 surf_parse_push_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+       if (new_buffer == NULL)
+               return;
+
+       surf_parse_ensure_buffer_stack();
+
+       /* This block is copied from surf_parse__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 surf_parse__switch_to_buffer. */
+       surf_parse__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 surf_parse_pop_buffer_state (void)
+{
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       surf_parse__delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               surf_parse__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 surf_parse_ensure_buffer_stack (void)
+{
+       int num_to_alloc;
+    
+       if (!(yy_buffer_stack)) {
+
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
+         */
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)surf_parse_alloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
+
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)surf_parse_realloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+
+               /* 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 surf_parse__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) surf_parse_alloc(sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__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;
+
+       surf_parse__switch_to_buffer(b  );
+
+       return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to surf_parse_lex() will
+ * scan from a @e copy of @a str.
+ * @param str 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
+ *       surf_parse__scan_bytes() instead.
+ */
+YY_BUFFER_STATE surf_parse__scan_string (yyconst char * yy_str )
+{
+    
+       return surf_parse__scan_bytes(yy_str,strlen(yy_str) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to surf_parse_lex() will
+ * scan from a @e copy of @a bytes.
+ * @param bytes the byte buffer to scan
+ * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE surf_parse__scan_bytes  (yyconst char * bytes, int  len )
+{
+       YY_BUFFER_STATE b;
+       char *buf;
+       yy_size_t n;
+       int i;
+    
+       /* Get memory for full buffer, including space for trailing EOB's. */
+       n = len + 2;
+       buf = (char *) surf_parse_alloc(n  );
+       if ( ! buf )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__scan_bytes()" );
+
+       for ( i = 0; i < len; ++i )
+               buf[i] = bytes[i];
+
+       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+       b = surf_parse__scan_buffer(buf,n );
+       if ( ! b )
+               YY_FATAL_ERROR( "bad buffer in surf_parse__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;
+}
+
+    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 );
+
+               if ( ! (yy_start_stack) )
+                       (yy_start_stack) = (int *) surf_parse_alloc(new_size  );
+
+               else
+                       (yy_start_stack) = (int *) surf_parse_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);
+}
+
+    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)]);
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yy_fatal_error (yyconst char* msg )
+{
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up surf_parse_text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               surf_parse_text[surf_parse_leng] = (yy_hold_char); \
+               (yy_c_buf_p) = surf_parse_text + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               surf_parse_leng = yyless_macro_arg; \
+               } \
+       while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the current line number.
+ * 
+ */
+int surf_parse_get_lineno  (void)
+{
+        
+    return surf_parse_lineno;
+}
+
+/** Get the input stream.
+ * 
+ */
+FILE *surf_parse_get_in  (void)
+{
+        return surf_parse_in;
+}
+
+/** Get the output stream.
+ * 
+ */
+FILE *surf_parse_get_out  (void)
+{
+        return surf_parse_out;
+}
+
+/** Get the length of the current token.
+ * 
+ */
+int surf_parse_get_leng  (void)
+{
+        return surf_parse_leng;
+}
+
+/** Get the current token.
+ * 
+ */
+
+char *surf_parse_get_text  (void)
+{
+        return surf_parse_text;
+}
+
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void surf_parse_set_lineno (int  line_number )
+{
+    
+    surf_parse_lineno = line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see surf_parse__switch_to_buffer
+ */
+void surf_parse_set_in (FILE *  in_str )
+{
+        surf_parse_in = in_str ;
+}
+
+void surf_parse_set_out (FILE *  out_str )
+{
+        surf_parse_out = out_str ;
+}
+
+int surf_parse_get_debug  (void)
+{
+        return surf_parse__flex_debug;
+}
+
+void surf_parse_set_debug (int  bdebug )
+{
+        surf_parse__flex_debug = bdebug ;
+}
+
+/* surf_parse_lex_destroy is for both reentrant and non-reentrant scanners. */
+int surf_parse_lex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+       while(YY_CURRENT_BUFFER){
+               surf_parse__delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               surf_parse_pop_buffer_state();
+       }
+
+       /* Destroy the stack itself. */
+       surf_parse_free((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
+
+    /* Destroy the start condition stack. */
+        surf_parse_free((yy_start_stack)  );
+        (yy_start_stack) = NULL;
+
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+{
+       register int i;
+       for ( i = 0; i < n; ++i )
+               s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * s )
+{
+       register int n;
+       for ( n = 0; s[n]; ++n )
+               ;
+
+       return n;
+}
+#endif
+
+void *surf_parse_alloc (yy_size_t  size )
+{
+       return (void *) malloc( size );
+}
+
+void *surf_parse_realloc  (void * ptr, yy_size_t  size )
+{
+       /* The cast to (char *) in the following accommodates both
+        * implementations that use char* generic pointers, and those
+        * that use void* generic pointers.  It works with the latter
+        * because both ANSI C and C++ allow castless assignment from
+        * any pointer type to void*, and deal with argument conversions
+        * as though doing an assignment.
+        */
+       return (void *) realloc( (char *) ptr, size );
+}
+
+void surf_parse_free (void * ptr )
+{
+       free( (char *) ptr );   /* see surf_parse_realloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef yytext_ptr
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+#line 792 "surf/surfxml.l"
+
+
+
+/* Element context stack lookup. */
+int element_context(int i)
+{
+  return (0<i && i<yy_start_stack_depth
+         ? yy_start_stack[yy_start_stack_ptr - i]
+         : 0);
+}
+
+#ifdef FLEX_DEBUG
+void print_yy_stack(char* fmt, ...)
+{
+  int i = 0; va_list ap; va_start(ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  for (i=1; i<yy_start_stack_ptr; i++)
+    fprintf(stderr, "%s/", statenames[yy_start_stack[i] ]);
+  fprintf(stderr,"%s\n", statenames[YY_START]);
+  va_end(ap);
+}
+
+static void debug_enter(int state, const char* statename) {
+  yy_push_state(state);
+  if (surf_parse__flex_debug) print_yy_stack("--ENTER(%s) : ",statename);
+}
+
+static void debug_leave(void) {
+  if (surf_parse__flex_debug) print_yy_stack("--LEAVE : ");
+  yy_pop_state();
+}
+
+static void debug_set(int state, const char* statename) {
+  BEGIN(state);
+  if (surf_parse__flex_debug) print_yy_stack("--SET(%s) : ",statename);
+}
+#endif
+
+enum {flexml_max_err_msg_size = 512};
+
+static char flexml_err_msg[flexml_max_err_msg_size];
+const char * parse_err_msg()
+{
+    return flexml_err_msg;
+}
+
+static void reset_parse_err_msg()
+{
+    flexml_err_msg[0] = '\0';
+}
+
+
+static int fail(const char* fmt, ...)
+{
+    int chars_left, used;
+    va_list ap; va_start(ap, fmt);
+#ifdef FLEXML_yylineno
+    used = sprintf(flexml_err_msg,
+                  "Invalid XML (XML input line %d, state %d): ",
+                  surf_parse_lineno, YY_START);
+#else
+    used = sprintf(flexml_err_msg,
+                  "Invalid XML (state %d): ",
+                  YY_START);
+#endif
+    chars_left = flexml_max_err_msg_size - used - 1;
+    vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
+    va_end(ap);
+
+#ifndef FLEXML_quiet_parser
+    /* print directly to sdterr */
+    fprintf(stderr, "%s\n", flexml_err_msg);
+    flexml_err_msg[0] = '\0';
+#endif
+   
+    return 1;
+}
+