Logo Search packages:      
Sourcecode: raptor version File versions  Download package

turtle_lexer.c

#ifdef HAVE_CONFIG_H
#include <raptor_config.h>
#endif

#ifdef WIN32
#include <win32_raptor_config.h>
#endif

#line 2 "turtle_lexer.c"

#line 4 "turtle_lexer.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 33
#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 __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
#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)

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

int turtle_lexer_lex_init (yyscan_t* scanner);

/* 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 yyg->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 ((yyg->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 turtle_lexer_restart(yyin ,yyscanner )

#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#define YY_BUF_SIZE 16384
#endif

/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2

    #define YY_LESS_LINENO(n)
    
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
      do \
            { \
            /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
            *yy_cp = yyg->yy_hold_char; \
            YY_RESTORE_YY_MORE_OFFSET \
            yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
            YY_DO_BEFORE_ACTION; /* set up yytext again */ \
            } \
      while ( 0 )

#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

/* 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 turtle_lexer_restart()), so that the user can continue scanning by
       * just pointing yyin at a new input file.
       */
#define YY_BUFFER_EOF_PENDING 2

      };
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* 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 ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

void turtle_lexer_restart (FILE *input_file ,yyscan_t yyscanner );
void turtle_lexer__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
YY_BUFFER_STATE turtle_lexer__create_buffer (FILE *file,int size ,yyscan_t yyscanner );
void turtle_lexer__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
void turtle_lexer__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
void turtle_lexer_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
void turtle_lexer_pop_buffer_state (yyscan_t yyscanner );

static void turtle_lexer_ensure_buffer_stack (yyscan_t yyscanner );
static void turtle_lexer__load_buffer_state (yyscan_t yyscanner );
static void turtle_lexer__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );

#define YY_FLUSH_BUFFER turtle_lexer__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)

YY_BUFFER_STATE turtle_lexer__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
YY_BUFFER_STATE turtle_lexer__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
YY_BUFFER_STATE turtle_lexer__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );

void *turtle_lexer_alloc (yy_size_t ,yyscan_t yyscanner );
void *turtle_lexer_realloc (void *,yy_size_t ,yyscan_t yyscanner );
void turtle_lexer_free (void * ,yyscan_t yyscanner );

#define yy_new_buffer turtle_lexer__create_buffer

#define yy_set_interactive(is_interactive) \
      { \
      if ( ! YY_CURRENT_BUFFER ){ \
        turtle_lexer_ensure_buffer_stack (yyscanner); \
            YY_CURRENT_BUFFER_LVALUE =    \
            turtle_lexer__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
      } \
      YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
      }

#define yy_set_bol(at_bol) \
      { \
      if ( ! YY_CURRENT_BUFFER ){\
        turtle_lexer_ensure_buffer_stack (yyscanner); \
            YY_CURRENT_BUFFER_LVALUE =    \
            turtle_lexer__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
      } \
      YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
      }

#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */

typedef unsigned char YY_CHAR;

typedef int yy_state_type;

#define yytext_ptr yytext_r

static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
static int yy_get_next_buffer (yyscan_t yyscanner );
static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
      yyg->yytext_ptr = yy_bp; \
      yyleng = (size_t) (yy_cp - yy_bp); \
      yyg->yy_hold_char = *yy_cp; \
      *yy_cp = '\0'; \
      yyg->yy_c_buf_p = yy_cp;

#define YY_NUM_RULES 34
#define YY_END_OF_BUFFER 35
/* 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[624] =
    {   0,
        0,    0,    0,    0,   20,   20,   35,   33,    2,    1,
        1,   33,   33,   33,   12,   13,   33,    5,    4,   25,
       22,    6,   33,   10,   31,    7,   33,    8,   33,   33,
        3,   31,   31,   29,   26,   28,   29,   20,   20,   20,
       20,    2,    1,    0,   17,    0,    0,   32,   32,    0,
       16,    0,    0,   25,   23,   23,    0,   22,    0,   30,
        0,   31,    0,   22,    0,   11,    0,   31,   31,   26,
        0,    0,   27,   20,   20,   20,    0,   20,   20,   20,
       20,   17,   18,    0,   23,    0,    0,   24,   22,    0,
        0,   21,   31,   31,   19,   20,    0,   20,   20,    0,

       20,    0,   24,    0,   24,    0,   21,    0,   31,   14,
       20,    0,   20,   20,   20,   20,   20,   20,    0,   20,
       20,   20,   20,   20,    0,   15,   20,    0,   20,   20,
       20,   20,   20,   20,    0,   20,   20,    0,   20,   20,
        0,   20,   20,   20,   20,   20,   20,    0,   20,   20,
        0,   20,    0,   20,    0,   20,   20,   20,   20,   20,
       20,    0,   20,   20,    0,   20,   20,    0,   20,   20,
       20,   20,   20,   20,    0,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,    9,   20,    0,   20,   20,

       20,   20,   20,   20,    0,   20,   20,    0,   20,   20,
        0,   20,   20,   20,   20,   20,   20,    0,   20,   20,
       20,   20,   20,   20,    0,   20,   20,   20,   20,   20,
       20,    0,   20,   20,    0,   20,   20,    0,   20,   20,
       20,   20,   20,   20,    0,   20,   20,    0,   20,   20,
        0,   20,   20,   20,   20,   20,   20,    0,   20,   20,
        0,   20,   20,    0,   20,   20,   20,   20,   20,   20,
        0,   20,   20,   20,   20,   20,   20,    0,   20,   20,
       20,   20,   20,   20,    0,   20,   20,    0,   20,   20,
        0,   20,   20,   20,   20,   20,   20,    0,   20,   20,

        0,   20,   20,    0,   20,   20,   20,   20,   20,   20,
        0,   20,   20,    0,   20,   20,    0,   20,   20,   20,
       20,   20,   20,    0,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,    0,   20,   20,   20,
       20,   20,   20,    0,   20,   20,    0,   20,   20,    0,
       20,   20,   20,   20,   20,   20,    0,   20,   20,   20,
       20,   20,   20,    0,   20,   20,   20,   20,   20,   20,
        0,   20,   20,    0,   20,   20,    0,   20,   20,   20,
       20,   20,   20,    0,   20,   20,    0,   20,   20,    0,

       20,   20,   20,   20,   20,   20,    0,   20,   20,    0,
       20,   20,    0,   20,   20,   20,   20,   20,   20,    0,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,    0,   20,   20,   20,   20,   20,   20,    0,
       20,   20,    0,   20,   20,    0,   20,   20,   20,   20,
       20,   20,    0,   20,   20,   20,   20,   20,   20,    0,
       20,   20,   20,   20,   20,   20,    0,   20,   20,    0,
       20,   20,    0,   20,   20,   20,   20,   20,   20,    0,
       20,   20,    0,   20,   20,   20,   20,   20,   20,   20,

       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,

       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,    0
    } ;

static yyconst flex_int32_t yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        2,    1,    4,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    5,    6,    1,    1,    1,    7,    8,
        9,    1,   10,   11,   12,   13,    1,   14,   14,   14,
       14,   14,   14,   14,   14,   14,   14,   15,   16,   17,
        1,   18,    1,   19,   20,   20,   20,   20,   21,   20,
       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
       20,   20,   20,   20,   22,   20,   20,   20,   20,   20,
       23,   24,   25,   26,   27,    1,   28,   20,   20,   20,

       29,   30,   20,   20,   31,   20,   20,   32,   20,   20,
       20,   33,   20,   34,   35,   36,   37,   20,   20,   38,
       20,   20,    1,    1,    1,    1,    1,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,

       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
       39,   39,   39,   39,   39
    } ;

static yyconst flex_int32_t yy_meta[40] =
    {   0,
        1,    1,    2,    3,    4,    1,    1,    1,    1,    1,
        1,    5,    5,    5,    6,    1,    1,    1,    1,    7,
        7,    7,    1,    7,    1,    1,    7,    7,    7,    7,
        7,    7,    7,    7,    7,    7,    7,    7,    7
    } ;

static yyconst flex_int16_t yy_base[1032] =
    {   0,
        0,    0,   39,    0,   76,   77,  617, 4901,  611, 4901,
      597,   78,   81,   79, 4901, 4901,   74, 4901,  584,   76,
        0, 4901,  573,  557,   80, 4901,   79, 4901,  551,  557,
       83,   93,   81, 4901,  561, 4901,   97,   96,  110,  555,
      111,  556, 4901,  106,  548,    0,  120, 4901,  543,  118,
     4901,    0,  530,  115,  117,  126,  127,  524,  504, 4901,
      485,  480,  130,    0,  136, 4901,    0,  122,   90,  497,
      143,  144, 4901,  149,  150,  157,  483,  158,  160,  161,
      164, 4901, 4901,  158,  157,  177,  471,  470,  453,  446,
      421,  430,  162,  147, 4901,  190,    0,  196,  197,    0,

      200,  426,  414,  407,  403,  372,  370,  369,  178,  328,
      205,    0,  206,  210,  214,  220,  236,  242,    0,  243,
      246,  247,  250,  251,  316,  318,  258,    0,  259,  273,
      274,  281,  285,  286,    0,  289,  290,    0,  297,  172,
      296,  301,  207,  312,  307,  317,  325,  329,  330,  334,
      321,  337,  278,  340,    0,  348,  345,  352,  357,  360,
      363,    0,  368,  372,    0,  375,  383,    0,  386,  390,
      395,  398,  401,  406,    0,  410,  413,  421,  424,  428,
      433,  436,  439,  446,  450,  451,  459,  462,  466,  473,
      474,  477,  488,  489,  497, 4901,  500,    0,  501,  504,

      511,  512,  515,  524,    0,  528,  527,    0,  537,  538,
        0,  542,  551,  552,  564,  565,  568,    0,  575,  578,
      579,  582,  590,  591,    0,  602,  605,  606,  613,  617,
      618,    0,  622,  628,    0,  629,  633,  304,  640,  644,
      651,  658,  655,  662,  270,  666,  667,  266,  678,  673,
        0,  682,  689,  693,  696,  702,  705,    0,  706,  711,
        0,  718,  722,    0,  729,  733,  734,  745,  744,  749,
        0,  756,  757,  760,  767,  771,  772,    0,  783,  782,
      787,  794,  795,  798,    0,  805,  809,    0,  810,  820,
      265,  821,  825,  832,  833,  836,  843,  255,  847,  848,

      233,  856,  859,    0,  863,  870,  871,  874,  883,  886,
        0,  894,  898,    0,  899,  903,    0,  910,  909,  914,
      921,  925,  932,    0,  937,  936,  941,  945,  948,  949,
      952,  959,  963,  974,  975,  981,  985,  986,  989,  997,
      990, 1001, 1012, 1013, 1021,  211,    0, 1006,  235, 1024,
     1018, 1028, 1036,    0, 1041, 1044,    0, 1048, 1051,    0,
     1059, 1056, 1064, 1068, 1071, 1074,    0, 1079, 1084, 1088,
     1097, 1094, 1101,    0, 1104, 1108, 1112, 1124, 1119, 1128,
        0, 1132, 1135,    0, 1142, 1139,  229, 1146, 1150, 1157,
     1162, 1168, 1172,  224, 1173, 1177,  223, 1182, 1185,    0,

     1200, 1188, 1197, 1208, 1211, 1212,    0, 1220, 1215,    0,
     1224, 1223,    0, 1228, 1235, 1238, 1246, 1250, 1251,    0,
     1255, 1261, 1264, 1273, 1277,  280, 1281, 1267, 1291, 1295,
     1303, 1304, 1308, 1309, 1313, 1317, 1318, 1326, 1331, 1341,
     1344, 1348,    0, 1353, 1356, 1357, 1361, 1364, 1368,    0,
     1371, 1379,    0, 1391, 1386,    0, 1394, 1397, 1401, 1402,
     1406, 1409,    0, 1414, 1417, 1424, 1432, 1429, 1437,    0,
     1440, 1441, 1444, 1452, 1447, 1455,    0, 1470, 1467,    0,
     1475, 1478,  201, 1479, 1482, 1485, 1493, 1490, 1505,  189,
     1515, 1508,  177, 1516, 1519, 1520, 1523, 1530, 1531, 1543,

     1546, 1553,  303, 1554, 1557, 1558, 1561, 1569, 1568, 1581,
     1584, 1592, 1593, 1596, 1597, 1604, 1607, 1620, 1608, 1619,
     1624, 1630, 1631, 1634, 1642, 1635,  465, 1646, 1647, 1657,
     1662, 1669, 1670, 1673, 1677, 1680, 1685, 1684, 1693, 1697,
     1708, 1700, 1709, 1713, 1720, 1723, 1724, 1731, 1735, 1736,
     1746, 1747, 1758, 1751, 1759, 1762, 1769, 1773, 1774, 1784,
     1785, 1789, 1796, 1797, 1800, 1807, 1811, 1812, 1823, 1822,
     1827, 1834, 1835, 1845, 1838, 1849, 1850, 1860, 1861, 1872,
     1865, 1873, 1876, 1883, 1896, 1887, 1888, 1899, 1900, 1903,
     1910, 1911, 1923, 1914, 1926, 1927, 1934, 1939, 1938, 1943,

     1949, 1950, 1954, 1963, 1967, 1972, 1976, 1977, 1985, 1989,
     1990, 1994, 2000, 2003, 2012, 2018, 2023, 2027, 2030, 2034,
     2041, 2038, 4901, 2078, 2085, 2092, 2099,  119, 2106, 2109,
     2112, 2115, 2122, 2129, 2132,   84, 2139, 2146, 2149, 2156,
     2163, 2170, 2177, 2184, 2191, 2198, 2205, 2212, 2219, 2226,
     2233, 2240, 2247, 2254, 2261, 2268, 2275, 2282, 2289, 2296,
     2303, 2310, 2317, 2324, 2331, 2338, 2345, 2352, 2359, 2366,
     2373, 2380, 2387, 2394, 2401, 2408, 2415, 2422, 2429, 2436,
     2443, 2450, 2457, 2464, 2471, 2478, 2485, 2492, 2499, 2506,
     2513, 2520, 2527, 2534, 2541, 2548, 2555, 2562, 2569, 2576,

     2583, 2590, 2597, 2604, 2611, 2618, 2625, 2632, 2639, 2646,
     2653, 2660, 2667, 2674, 2681, 2688, 2695, 2702, 2709, 2716,
     2723, 2730, 2737, 2744, 2751, 2758, 2765, 2772, 2779, 2786,
     2793, 2800, 2807, 2814, 2821, 2828, 2835, 2842, 2849, 2856,
     2863, 2870, 2877, 2884, 2891, 2898, 2905, 2912, 2919, 2926,
     2933, 2940, 2947, 2954, 2961, 2968, 2975, 2982, 2989, 2996,
     3003, 3010, 3017, 3024, 3031, 3038, 3045, 3052, 3059, 3066,
     3073, 3080, 3087, 3094, 3101, 3108, 3115, 3122, 3129, 3136,
     3143, 3150, 3157, 3164, 3171, 3178, 3185, 3192, 3199, 3206,
     3213, 3220, 3227, 3234, 3241, 3248, 3255, 3262, 3269, 3276,

     3283, 3290, 3297, 3304, 3311, 3318, 3325, 3332, 3339, 3346,
     3353, 3360, 3367, 3374, 3381, 3388, 3395, 3402, 3409, 3416,
     3423, 3430, 3437, 3444, 3451, 3458, 3465, 3472, 3479, 3486,
     3493, 3500, 3507, 3514, 3521, 3528, 3535, 3542, 3549, 3556,
     3563, 3570, 3577, 3584, 3591, 3598, 3605, 3612, 3619, 3626,
     3633, 3640, 3647, 3654, 3661, 3668, 3675, 3682, 3689, 3696,
     3703, 3710, 3717, 3724, 3731, 3738, 3745, 3752, 3759, 3766,
     3773, 3780, 3787, 3794, 3801, 3808, 3815, 3822, 3829, 3836,
     3843, 3850, 3857, 3864, 3871, 3878, 3885, 3892, 3899, 3906,
     3913, 3920, 3927, 3934, 3941, 3948, 3955, 3962, 3969, 3976,

     3983, 3990, 3997, 4004, 4011, 4018, 4025, 4032, 4039, 4046,
     4053, 4060, 4067, 4074, 4081, 4088, 4095, 4102, 4109, 4116,
     4123, 4130, 4137, 4144, 4151, 4158, 4165, 4172, 4179, 4186,
     4193, 4200, 4207, 4214, 4221, 4228, 4235, 4242, 4249, 4256,
     4263, 4270, 4277, 4284, 4291, 4298, 4305, 4312, 4319, 4326,
     4333, 4340, 4347, 4354, 4361, 4368, 4375, 4382, 4389, 4396,
     4403, 4410, 4417, 4424, 4431, 4438, 4445, 4452, 4459, 4466,
     4473, 4480, 4487, 4494, 4501, 4508, 4515, 4522, 4529, 4536,
     4543, 4550, 4557, 4564, 4571, 4578, 4585, 4592, 4599, 4606,
     4613, 4620, 4627, 4634, 4641, 4648, 4655, 4662, 4669, 4676,

     4683, 4690, 4697, 4704, 4711, 4718, 4725, 4732, 4739, 4746,
     4753, 4760, 4767, 4774, 4781, 4788, 4795, 4802, 4809, 4816,
     4823, 4830, 4837, 4844, 4851, 4858, 4865, 4872, 4879, 4886,
     4893
    } ;

static yyconst flex_int16_t yy_def[1032] =
    {   0,
      623,    1,  623,    3,  624,  624,  623,  623,  623,  623,
      623,  625,  626,  627,  623,  623,  623,  623,  623,  623,
      628,  623,  629,  623,  630,  623,  631,  623,  623,  623,
      630,  630,   32,  623,  623,  623,  632,  633,  633,  623,
      634,  623,  623,  625,  623,  625,  626,  623,  623,  627,
      623,  627,  623,  623,  623,  623,  623,  635,  629,  623,
      623,   32,  631,  628,  631,  623,  636,   32,   32,  623,
      632,  632,  623,  633,  633,  634,  623,  633,  637,  634,
      638,  623,  623,  623,  623,  623,  623,  623,  635,  635,
      623,  639,   32,   32,  623,  640,  641,  642,  643,  644,

      645,  623,  623,  623,  623,  623,  639,  639,   32,   32,
      646,  647,  648,  646,  649,  648,  650,  651,  652,  653,
      651,  654,  653,  655,  623,   32,  656,  657,  658,  656,
      659,  658,  660,  661,  662,  663,  664,  665,  666,  634,
      633,  667,  634,  668,  667,  669,  642,  640,  670,  645,
      643,  671,  623,  672,  673,  674,  672,  675,  674,  676,
      677,  678,  679,  680,  681,  682,  683,  684,  685,  683,
      686,  685,  687,  688,  689,  690,  688,  691,  690,  692,
      693,  634,  694,  640,  642,  643,  645,  695,  696,  697,
      698,  699,  700,  701,  702,  623,  703,  704,  705,  703,

      706,  705,  707,  708,  709,  710,  711,  712,  713,  714,
      715,  716,  714,  717,  716,  718,  719,  720,  721,  719,
      722,  721,  723,  724,  725,  726,  724,  727,  726,  728,
      729,  730,  731,  732,  733,  734,  705,  703,  735,  705,
      736,  735,  737,  710,  708,  738,  713,  711,  739,  740,
      741,  742,  740,  743,  742,  744,  745,  746,  747,  748,
      749,  750,  751,  752,  753,  751,  754,  753,  755,  756,
      757,  758,  756,  759,  758,  760,  761,  762,  763,  761,
      764,  763,  765,  766,  767,  768,  769,  770,  771,  742,
      740,  772,  742,  773,  772,  774,  747,  745,  775,  750,

      748,  776,  777,  778,  779,  777,  780,  779,  781,  782,
      783,  784,  785,  786,  787,  788,  789,  790,  788,  791,
      790,  792,  793,  794,  795,  793,  796,  795,  797,  740,
      798,  742,  799,  745,  747,  748,  750,  800,  801,  802,
      803,  804,  805,  806,  807,  808,  809,  810,  808,  811,
      810,  812,  813,  814,  815,  816,  817,  818,  819,  820,
      821,  819,  822,  821,  823,  824,  825,  826,  824,  827,
      826,  828,  829,  830,  831,  829,  832,  831,  833,  834,
      835,  836,  837,  838,  839,  810,  808,  840,  810,  841,
      840,  842,  815,  813,  843,  818,  816,  844,  845,  846,

      847,  845,  848,  847,  849,  850,  851,  852,  853,  854,
      855,  856,  857,  858,  856,  859,  858,  860,  861,  862,
      863,  861,  864,  863,  865,  808,  866,  810,  867,  813,
      815,  816,  818,  868,  869,  870,  871,  872,  873,  874,
      875,  876,  877,  878,  876,  879,  878,  880,  881,  882,
      883,  884,  885,  886,  887,  888,  889,  887,  890,  889,
      891,  892,  893,  894,  892,  895,  894,  896,  897,  898,
      899,  897,  900,  899,  901,  902,  903,  904,  905,  906,
      907,  878,  876,  908,  878,  909,  908,  910,  883,  881,
      911,  886,  884,  912,  913,  914,  915,  916,  917,  918,

      919,  920,  921,  922,  923,  924,  925,  926,  927,  928,
      929,  930,  931,  932,  933,  934,  935,  936,  937,  938,
      939,  940,  941,  942,  943,  944,  945,  946,  921,  947,
      948,  925,  949,  927,  950,  951,  952,  953,  954,  955,
      956,  957,  958,  959,  960,  961,  962,  963,  964,  965,
      966,  967,  968,  969,  970,  971,  972,  973,  974,  975,
      976,  977,  978,  979,  980,  981,  960,  982,  983,  984,
      963,  985,  965,  986,  987,  988,  989,  990,  991,  992,
      993,  994,  995,  996,  997,  998,  999, 1000, 1001, 1002,
     1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012,

     1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020,  995, 1021,
     1022,  999, 1023, 1001, 1024, 1025, 1026, 1027, 1028, 1029,
     1030, 1031,    0,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,

      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,

      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,

      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,

      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623
    } ;

static yyconst flex_int16_t yy_nxt[4941] =
    {   0,
        8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
       18,   17,   19,   20,   21,   22,   23,    8,   24,   25,
       25,   25,   26,   27,   28,   29,   30,   31,   25,   32,
       25,   25,   25,   25,   25,   33,   25,   25,   27,   34,
       35,   34,   34,   34,   34,   34,   34,   34,   34,   34,
       34,   34,   34,   36,   34,   34,   34,   34,   37,   37,
       37,   34,   37,   34,   34,   34,   37,   37,   37,   37,
       37,   37,   37,   37,   37,   37,   37,   37,   39,   39,
       40,   40,   45,   48,   49,   51,   53,   54,   56,   54,
       92,   63,   63,   64,   64,   63,   57,   64,   75,   41,

       41,   46,   52,   65,   57,   63,   65,   64,   62,   72,
       82,   73,   75,   78,   69,   74,   65,   62,   65,   76,
       68,   65,   48,   49,   51,   58,   94,   56,   54,   46,
       55,   65,   79,   76,   80,   57,   87,   84,   87,   85,
       88,   52,   63,   57,  623,   84,   86,   81,   63,   62,
       64,   75,   75,   93,   86,   72,   72,   73,  623,   78,
       75,   74,   75,   78,   97,   74,   75,  102,  100,  102,
       85,  103,   76,   76,   62,  110,   74,   86,   79,  623,
       80,   76,   79,   98,   80,   86,  104,  101,  104,   62,
      105,  623,   75,   81,  112,   80,  109,   81,   78,   75,

      111,  119,   78,  623,  118,   62,  126,   75,   78,  128,
      127,   74,   75,  113,  128,   74,   75,  115,  135,  116,
      120,  122,   78,  123,  127,  623,  623,  131,  129,  132,
       80,  623,  117,  129,   80,  623,  124,  136,   75,   74,
      138,  131,  133,  132,   75,   78,  141,  140,   75,   75,
      141,  148,   78,   75,  140,  151,  133,  623,   80,  139,
       75,   78,  155,  154,  144,  142,  145,  623,  623,  142,
      149,  144,  623,  145,  152,   75,   75,  155,  162,  146,
      158,  156,  159,   78,   74,  154,  146,   75,   75,  165,
      168,   78,   75,  167,  175,  160,  156,  163,  623,   78,

       74,  174,  158,   80,  159,   75,  623,   74,  166,  169,
      171,   75,  172,  176,   75,  196,   96,  160,  178,   75,
      179,   99,  181,  623,  182,  173,   80,   75,  181,  111,
      182,  623,   78,  180,  114,  185,   75,  183,  118,   78,
      187,  121,   75,  183,  198,   62,  153,   75,  116,  198,
       78,  189,  197,  190,   75,   62,  205,  123,  193,   78,
      194,  197,   75,  199,  208,   75,  191,  211,  199,  201,
       78,  202,  210,  195,   75,  206,  218,   78,  201,  217,
      202,  108,  108,  209,  203,   75,  212,  225,   78,  214,
      224,  215,   75,  203,  225,  219,  221,   75,  222,  232,

       78,  125,  224,   75,  216,  235,  226,  228,   75,  229,
      238,  223,   78,  226,  237,   75,  105,  238,  233,  228,
      105,  229,  230,   75,  236,  245,   78,  103,  237,  239,
       75,  241,  248,  242,  230,   75,  239,   97,   78,  103,
       74,   75,  108,  100,  246,  241,  243,  242,   75,  106,
      112,  249,   78,   75,  111,  119,   98,   79,   90,   80,
      243,   78,  101,  118,   75,   90,  128,   75,   75,  113,
      135,  115,   81,  116,  120,   78,   75,  127,  138,   75,
      122,  141,  123,   88,   88,  129,  117,   95,   76,  136,
       75,   78,  148,  140,  131,  124,  132,  139,   70,   75,

      142,  151,   75,   78,  251,  250,   75,   62,  251,  133,
      144,  149,  145,   75,   78,  258,  250,   75,   91,  261,
      152,   60,  254,  252,  255,  146,   75,  252,  264,   75,
       78,  271,  263,  254,  259,  255,   90,  256,  262,   78,
       75,  270,  278,   55,   78,   48,  277,  265,  256,  267,
      272,  268,   83,   75,   75,  278,  285,   42,  274,   77,
      275,  279,   70,  281,  269,  282,   78,   75,  277,  288,
       75,   67,  291,  276,  279,  286,   66,   78,  283,  290,
       75,   75,  291,  298,   78,  281,  290,  282,  289,   61,
       60,  292,   75,   75,  301,  304,  294,   55,  295,   43,

      283,  292,  299,  294,   78,  295,  303,   75,   75,  304,
      311,  296,   42,  302,  305,   78,  623,  303,  296,   75,
       75,  314,  317,  307,   78,  308,  316,  623,  305,  312,
       75,   78,  324,  323,  307,   75,  308,  250,  309,  623,
      315,  318,   78,  320,  253,  321,   75,  623,  250,  309,
      327,  325,  328,   75,  623,  257,  255,   75,  322,  260,
       78,  331,  253,  332,   75,  329,  263,  255,   78,   75,
      266,  270,  623,  623,  335,   75,  333,  347,  337,  331,
       78,  332,  273,  623,   78,  268,  346,  339,  623,  340,
      275,   75,  623,  347,  333,   75,  348,  354,   78,  343,

      346,  344,  341,  350,   75,  351,  357,   75,   78,  360,
      359,  623,  348,   75,  345,  367,  355,  350,  352,  351,
       78,  623,  366,  623,   75,  358,  374,  363,  361,  364,
      623,   78,  352,  373,  368,   75,   75,  374,  381,  370,
      623,  371,  365,  623,  623,  375,   75,   78,  384,  373,
      377,   75,  378,  387,  372,  623,  375,  382,   78,   75,
      386,  387,   75,  623,  394,  379,  377,  385,  378,   78,
      623,  386,  388,   75,   75,  397,  400,  390,  623,  391,
      388,  379,  623,  395,   75,   78,  400,  399,  390,   75,
      391,  407,  392,  623,  398,  401,   78,   75,  399,  410,

       75,  623,  413,  392,  403,  401,  404,   78,  623,  412,
      408,   75,   78,  420,  419,  403,  623,  404,  411,  405,
      623,  414,   75,   78,  346,  349,  416,   75,  417,  346,
      405,  423,  421,  424,   75,   78,  353,  349,   75,  623,
      356,  418,  427,  351,  428,   75,  425,  359,  351,   78,
       75,  362,  366,  623,  427,  431,  428,  429,   78,  433,
      369,   75,  623,  443,  623,   78,  364,  442,  435,  429,
      436,  371,   75,   75,  443,  450,   78,  439,  442,  440,
      623,  623,  444,  437,  446,   75,  447,  453,   75,  623,
      456,  623,  441,  444,  451,  446,   78,  447,  455,  448,

       75,   78,  463,  462,  623,   75,  454,  470,  623,  457,
      448,   75,   78,  470,  469,  459,   75,  460,  477,  623,
      466,  464,  467,   78,  623,  469,  471,   75,  623,  480,
      461,  473,  471,  474,   75,  468,  483,  478,   75,   78,
      483,  482,  473,   75,  474,  490,  475,   78,  481,  482,
       75,   75,  493,  347,   75,  484,  354,  475,  486,  484,
      487,   78,  623,  346,  491,   75,  486,  357,  487,  623,
      623,  494,  348,  488,  623,  355,   75,   78,  360,  359,
      350,  488,  351,   75,  623,  367,  358,   78,   75,  366,
      374,   75,   75,  381,  384,  352,  363,  361,  364,   78,

      623,  373,  623,   75,  368,  387,  370,  623,  371,  375,
       75,  365,  382,  385,   75,   78,  394,  386,  377,  623,
      378,  372,   75,   75,  388,  397,   75,  181,   96,  182,
       75,  623,   99,  379,  390,  395,  391,  623,   75,  181,
      111,  182,  183,   78,  398,  114,   75,  185,  118,  392,
       78,  187,  121,   75,  183,  127,  623,  623,   75,  116,
      127,   78,  189,  130,  190,  623,   75,  123,  134,  193,
       78,  194,  130,   75,  132,  137,   75,  191,  140,  132,
      496,   78,  497,  143,  195,  623,   75,  500,  140,  496,
       75,  497,  147,  623,  502,  498,   75,  145,  150,   78,

      504,  143,  505,   75,  498,  154,   78,  145,  157,  623,
       75,  508,  154,  623,   75,  506,  161,  510,  504,  623,
      505,   75,  623,  164,  159,  512,   78,  513,  157,  623,
       75,  159,  167,  506,   78,  516,  170,   75,  623,  174,
      514,   75,  518,   75,   78,  512,  177,  513,   78,  623,
       78,  172,   75,  520,   75,  521,  623,  623,  179,   75,
      514,  184,  182,  524,   78,  525,   78,  528,  522,  529,
       75,  623,  186,  182,   75,   78,  114,  188,  526,   75,
      532,  121,  530,  528,   78,  529,  192,   75,  623,  197,
       75,  534,  197,  623,  536,  190,  537,  623,  530,   75,

      194,  204,   78,  540,  200,  541,  623,  623,  202,  538,
       78,  202,  200,   75,   75,  207,  210,   75,  542,  217,
      548,  544,   78,  545,  213,   75,   78,  224,  220,  544,
       78,  545,  227,  623,  550,  215,  546,   75,  222,  224,
       75,  552,  231,  553,  546,  556,  229,  557,   78,  560,
      227,  561,   75,   75,  234,  237,  554,   78,  229,  240,
      558,  564,  623,   75,  562,  237,   75,  560,  244,  561,
      623,   75,  623,  566,  242,   78,  568,  240,  569,   75,
      623,  247,  562,   75,  242,   96,  623,  572,  181,  623,
      182,  570,  623,   75,  568,   99,  569,   75,  623,  111,

      574,  623,  623,  183,  185,   78,   75,  114,  118,  570,
       78,   75,  121,  127,  187,   75,  623,  134,  116,   78,
       75,  130,  137,  623,  189,  623,  190,  123,   75,  193,
      140,  194,  132,   75,  623,  147,  500,  623,  496,  191,
      497,  502,  623,   78,  195,  143,   75,  623,  150,  145,
       75,  623,  250,  498,  508,   78,  623,  253,   75,   75,
      250,  257,  504,   78,  505,  253,   75,  510,  260,  623,
       75,  255,  263,   78,  331,  266,  332,  506,  623,  255,
      335,   75,  331,  270,  332,  623,  623,  337,   75,  333,
      277,  268,  339,   78,  340,  273,   78,  333,  280,   75,

      623,  277,  275,   75,   78,  284,  280,  341,   75,  282,
      287,   75,  343,  290,  344,  576,   78,  577,  293,   75,
      282,  290,  623,  576,  580,  577,   75,  345,  297,  582,
      578,   75,  295,  300,   78,  584,  293,  585,  578,   75,
      295,  303,   78,   75,  306,  303,   75,  588,  310,   75,
      586,  313,  590,  584,   78,  585,  306,   75,  623,  316,
      308,  592,  623,  593,  308,  623,  623,  596,  586,   75,
      598,  323,   78,  592,  319,  593,  594,   78,  321,  326,
       75,   78,  253,  330,   75,  623,  253,   75,  594,  334,
      328,  600,   75,  601,  336,   78,  604,  330,  605,  623,

      608,  332,  609,  623,  623,  332,  602,   75,  612,  266,
       75,  606,  273,  614,  608,  610,  609,   78,   78,  338,
      342,   75,   75,  155,  162,   78,  623,  154,  340,  610,
      623,  344,   75,   75,  165,  168,  616,  620,  617,  621,
      623,  623,  156,  163,  158,   78,  159,  167,   75,  623,
      175,  618,  622,  166,  169,   78,   75,  174,   96,  160,
       75,   75,   99,   75,  171,  111,  172,  623,  623,  176,
       75,   78,  118,  114,  178,  623,  179,  185,  181,  173,
      182,  187,  623,   78,  116,  121,   75,  623,  198,  180,
      189,  123,  190,  183,   75,   78,  205,  197,   75,   75,

      208,  211,  193,  623,  194,  191,   78,  199,  210,   75,
       75,  218,  225,  623,  201,  206,  202,  195,  623,  209,
      212,   75,   78,  232,  217,  214,   78,  215,  224,  203,
      219,  226,   75,   75,  235,  238,   75,   75,  245,  248,
      216,  221,  233,  222,   78,  228,  237,  229,   75,   78,
       97,   74,  623,  236,  239,  623,  223,  246,  249,   75,
      230,  100,  623,  241,   75,  242,  112,  623,   79,   98,
       80,   78,   75,  111,  119,   78,  623,  118,  243,   75,
      101,  128,   75,   81,  135,  113,   75,   78,  138,  127,
      115,  623,  116,  120,  122,   75,  123,  141,  623,   75,

      129,  148,   75,  136,  151,  117,  131,  139,  132,  124,
       78,   75,  140,  251,  623,   75,  142,  258,  623,  623,
      149,  133,   78,  152,  250,   75,   75,  261,  264,  144,
      623,  145,  252,   78,  623,  263,  259,   75,   78,  271,
      270,  254,  623,  255,  146,  623,  262,  265,   75,   75,
      278,  285,  267,   75,  268,  288,  256,  274,  272,  275,
       78,   75,  277,  291,   75,  623,  298,  269,  623,  279,
      286,   78,  276,  290,  289,   75,   75,  301,  304,  281,
      623,  282,  292,  623,  623,  299,   75,   78,  311,  303,
      294,   75,  295,  314,  283,  623,  302,  305,   75,   78,

      317,  316,   75,  623,  324,  296,  307,  312,  308,   78,
      623,  323,  315,   75,   75,  250,  257,  623,  320,  318,
      321,  309,  623,  325,   75,   78,  260,  253,  327,   75,
      328,  263,  623,  322,  255,  335,   78,   75,  266,  270,
       75,  623,  400,  329,  331,  337,  332,   78,  623,  273,
      268,   75,   78,  407,  399,  339,  623,  340,  275,  333,
      623,  401,   75,   75,  410,  413,  343,   75,  344,  420,
      341,  403,  408,  404,   78,   78,  412,  419,   75,  623,
      346,  345,  623,  411,  414,   75,  405,  353,  421,   75,
       75,  356,  359,  416,  423,  417,  424,  623,   78,  351,

      349,   78,   75,  362,  366,   78,  431,  369,  418,  425,
      433,  364,   75,   75,  443,  450,   75,  427,  453,  428,
      435,  623,  436,  371,  439,   78,  440,  442,   75,   78,
      456,  455,  429,  444,  451,  437,   75,  454,  463,  441,
       75,   78,  470,  462,  446,   75,  447,  477,  459,  457,
      460,   78,   75,  469,  480,  623,   75,  464,  483,  448,
      466,  471,  467,  461,  623,   75,  478,  490,  623,   78,
      473,  482,  474,  481,   75,  468,  493,  484,   75,   75,
      347,  354,  623,  623,  623,  475,  491,   78,  486,  346,
      487,   75,   75,  357,  360,  494,   78,  623,  359,  348,

      355,  623,   75,  488,  367,   78,  350,  366,  351,  623,
      623,  623,  358,  361,   75,  363,  374,  364,  623,  623,
       75,  352,  381,  368,  370,   78,  371,  373,  623,   75,
      365,  384,   75,  623,  387,  375,   75,  623,  394,  372,
       75,  382,  397,   78,  377,  386,  378,  623,  623,  623,
      385,  623,  623,  388,  623,  623,  623,  395,  623,  379,
      623,  398,  390,  623,  391,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  392,   38,   38,
       38,   38,   38,   38,   38,   44,  623,  623,   44,   44,
       44,   44,   47,   47,   47,   47,   47,   47,   47,   50,

      623,  623,   50,   50,   50,   50,   59,   59,   59,   59,
       59,   59,   59,   62,   62,   62,   65,   65,   65,   71,
       71,   71,   74,   74,   74,  623,   74,   74,   74,   75,
       75,   75,   75,   75,   75,   75,   89,  623,   89,   96,
       96,   96,   96,   96,   96,   96,   99,   99,   99,   99,
       99,   99,   99,  107,  623,  107,  111,  111,  111,  111,
      111,  111,  111,  112,  623,  112,  112,  112,  112,  112,
      114,  114,  114,  114,  114,  114,  114,  118,  118,  118,
      118,  118,  118,  118,  119,  623,  119,  119,  119,  119,
      119,  121,  121,  121,  121,  121,  121,  121,  127,  127,

      127,  127,  127,  127,  127,  128,  623,  128,  128,  128,
      128,  128,  130,  130,  130,  130,  130,  130,  130,  134,
      134,  134,  134,  134,  134,  134,  137,  137,  137,  137,
      137,  137,  137,  140,  140,  140,  140,  140,  140,  140,
      141,  623,  141,  141,  141,  141,  141,  143,  143,  143,
      143,  143,  143,  143,  147,  147,  147,  147,  147,  147,
      147,  150,  150,  150,  150,  150,  150,  150,  154,  154,
      154,  154,  154,  154,  154,  155,  623,  155,  155,  155,
      155,  155,  157,  157,  157,  157,  157,  157,  157,  161,
      161,  161,  161,  161,  161,  161,  164,  164,  164,  164,

      164,  164,  164,  167,  167,  167,  167,  167,  167,  167,
      168,  623,  168,  168,  168,  168,  168,  170,  170,  170,
      170,  170,  170,  170,  174,  174,  174,  174,  174,  174,
      174,  175,  623,  175,  175,  175,  175,  175,  177,  177,
      177,  177,  177,  177,  177,   78,   78,   78,   78,   78,
       78,   78,  184,  184,  184,  184,  184,  184,  184,  186,
      186,  186,  186,  186,  186,  186,  188,  188,  188,  188,
      188,  188,  188,  192,  192,  192,  192,  192,  192,  192,
      197,  197,  197,  197,  197,  197,  197,  198,  623,  198,
      198,  198,  198,  198,  200,  200,  200,  200,  200,  200,

      200,  204,  204,  204,  204,  204,  204,  204,  207,  207,
      207,  207,  207,  207,  207,  210,  210,  210,  210,  210,
      210,  210,  211,  623,  211,  211,  211,  211,  211,  213,
      213,  213,  213,  213,  213,  213,  217,  217,  217,  217,
      217,  217,  217,  218,  623,  218,  218,  218,  218,  218,
      220,  220,  220,  220,  220,  220,  220,  224,  224,  224,
      224,  224,  224,  224,  225,  623,  225,  225,  225,  225,
      225,  227,  227,  227,  227,  227,  227,  227,  231,  231,
      231,  231,  231,  231,  231,  234,  234,  234,  234,  234,
      234,  234,  237,  237,  237,  237,  237,  237,  237,  238,

      623,  238,  238,  238,  238,  238,  240,  240,  240,  240,
      240,  240,  240,  244,  244,  244,  244,  244,  244,  244,
      247,  247,  247,  247,  247,  247,  247,   96,   96,   96,
       96,   96,   96,   96,   99,   99,   99,   99,   99,   99,
       99,  127,  127,  127,  127,  127,  127,  127,  134,  134,
      134,  134,  134,  134,  134,  130,  130,  130,  130,  130,
      130,  130,  137,  137,  137,  137,  137,  137,  137,  140,
      140,  140,  140,  140,  140,  140,  147,  147,  147,  147,
      147,  147,  147,  143,  143,  143,  143,  143,  143,  143,
      150,  150,  150,  150,  150,  150,  150,  250,  250,  250,

      250,  250,  250,  250,  251,  623,  251,  251,  251,  251,
      251,  253,  253,  253,  253,  253,  253,  253,  257,  257,
      257,  257,  257,  257,  257,  260,  260,  260,  260,  260,
      260,  260,  263,  263,  263,  263,  263,  263,  263,  264,
      623,  264,  264,  264,  264,  264,  266,  266,  266,  266,
      266,  266,  266,  270,  270,  270,  270,  270,  270,  270,
      271,  623,  271,  271,  271,  271,  271,  273,  273,  273,
      273,  273,  273,  273,  277,  277,  277,  277,  277,  277,
      277,  278,  623,  278,  278,  278,  278,  278,  280,  280,
      280,  280,  280,  280,  280,  284,  284,  284,  284,  284,

      284,  284,  287,  287,  287,  287,  287,  287,  287,  290,
      290,  290,  290,  290,  290,  290,  291,  623,  291,  291,
      291,  291,  291,  293,  293,  293,  293,  293,  293,  293,
      297,  297,  297,  297,  297,  297,  297,  300,  300,  300,
      300,  300,  300,  300,  303,  303,  303,  303,  303,  303,
      303,  304,  623,  304,  304,  304,  304,  304,  306,  306,
      306,  306,  306,  306,  306,  310,  310,  310,  310,  310,
      310,  310,  313,  313,  313,  313,  313,  313,  313,  316,
      316,  316,  316,  316,  316,  316,  317,  623,  317,  317,
      317,  317,  317,  319,  319,  319,  319,  319,  319,  319,

      323,  323,  323,  323,  323,  323,  323,  324,  623,  324,
      324,  324,  324,  324,  326,  326,  326,  326,  326,  326,
      326,  330,  330,  330,  330,  330,  330,  330,  334,  334,
      334,  334,  334,  334,  334,  336,  336,  336,  336,  336,
      336,  336,  338,  338,  338,  338,  338,  338,  338,  342,
      342,  342,  342,  342,  342,  342,  346,  346,  346,  346,
      346,  346,  346,  347,  623,  347,  347,  347,  347,  347,
      349,  349,  349,  349,  349,  349,  349,  353,  353,  353,
      353,  353,  353,  353,  356,  356,  356,  356,  356,  356,
      356,  359,  359,  359,  359,  359,  359,  359,  360,  623,

      360,  360,  360,  360,  360,  362,  362,  362,  362,  362,
      362,  362,  366,  366,  366,  366,  366,  366,  366,  367,
      623,  367,  367,  367,  367,  367,  369,  369,  369,  369,
      369,  369,  369,  373,  373,  373,  373,  373,  373,  373,
      374,  623,  374,  374,  374,  374,  374,  376,  376,  376,
      376,  376,  376,  376,  380,  380,  380,  380,  380,  380,
      380,  383,  383,  383,  383,  383,  383,  383,  386,  386,
      386,  386,  386,  386,  386,  387,  623,  387,  387,  387,
      387,  387,  389,  389,  389,  389,  389,  389,  389,  393,
      393,  393,  393,  393,  393,  393,  396,  396,  396,  396,

      396,  396,  396,  399,  399,  399,  399,  399,  399,  399,
      400,  623,  400,  400,  400,  400,  400,  402,  402,  402,
      402,  402,  402,  402,  406,  406,  406,  406,  406,  406,
      406,  409,  409,  409,  409,  409,  409,  409,  412,  412,
      412,  412,  412,  412,  412,  413,  623,  413,  413,  413,
      413,  413,  415,  415,  415,  415,  415,  415,  415,  419,
      419,  419,  419,  419,  419,  419,  420,  623,  420,  420,
      420,  420,  420,  422,  422,  422,  422,  422,  422,  422,
      426,  426,  426,  426,  426,  426,  426,  430,  430,  430,
      430,  430,  430,  430,  432,  432,  432,  432,  432,  432,

      432,  434,  434,  434,  434,  434,  434,  434,  438,  438,
      438,  438,  438,  438,  438,  442,  442,  442,  442,  442,
      442,  442,  443,  623,  443,  443,  443,  443,  443,  445,
      445,  445,  445,  445,  445,  445,  449,  449,  449,  449,
      449,  449,  449,  452,  452,  452,  452,  452,  452,  452,
      455,  455,  455,  455,  455,  455,  455,  456,  623,  456,
      456,  456,  456,  456,  458,  458,  458,  458,  458,  458,
      458,  462,  462,  462,  462,  462,  462,  462,  463,  623,
      463,  463,  463,  463,  463,  465,  465,  465,  465,  465,
      465,  465,  469,  469,  469,  469,  469,  469,  469,  470,

      623,  470,  470,  470,  470,  470,  472,  472,  472,  472,
      472,  472,  472,  476,  476,  476,  476,  476,  476,  476,
      479,  479,  479,  479,  479,  479,  479,  482,  482,  482,
      482,  482,  482,  482,  483,  623,  483,  483,  483,  483,
      483,  485,  485,  485,  485,  485,  485,  485,  489,  489,
      489,  489,  489,  489,  489,  492,  492,  492,  492,  492,
      492,  492,  353,  353,  353,  353,  353,  353,  353,  356,
      356,  356,  356,  356,  356,  356,  373,  373,  373,  373,
      373,  373,  373,  380,  380,  380,  380,  380,  380,  380,
      376,  376,  376,  376,  376,  376,  376,  383,  383,  383,

      383,  383,  383,  383,  386,  386,  386,  386,  386,  386,
      386,  393,  393,  393,  393,  393,  393,  393,  389,  389,
      389,  389,  389,  389,  389,  396,  396,  396,  396,  396,
      396,  396,   75,   75,   75,   75,   75,   75,   75,   74,
      623,   74,   74,   74,   74,   74,   78,   78,   78,   78,
       78,   78,   78,  184,  184,  184,  184,  184,  184,  184,
      186,  186,  186,  186,  186,  186,  186,  114,  114,  114,
      114,  114,  114,  114,  111,  623,  111,  111,  111,  111,
      111,  188,  188,  188,  188,  188,  188,  188,  121,  121,
      121,  121,  121,  121,  121,  118,  623,  118,  118,  118,

      118,  118,  192,  192,  192,  192,  192,  192,  192,  130,
      130,  130,  130,  130,  130,  130,  127,  623,  127,  127,
      127,  127,  127,  495,  495,  495,  495,  495,  495,  495,
      499,  499,  499,  499,  499,  499,  499,  501,  501,  501,
      501,  501,  501,  501,  143,  143,  143,  143,  143,  143,
      143,  140,  623,  140,  140,  140,  140,  140,  503,  503,
      503,  503,  503,  503,  503,  507,  507,  507,  507,  507,
      507,  507,  509,  509,  509,  509,  509,  509,  509,  157,
      157,  157,  157,  157,  157,  157,  154,  623,  154,  154,
      154,  154,  154,  511,  511,  511,  511,  511,  511,  511,

      515,  515,  515,  515,  515,  515,  515,  517,  517,  517,
      517,  517,  517,  517,  170,  170,  170,  170,  170,  170,
      170,  167,  623,  167,  167,  167,  167,  167,  519,  519,
      519,  519,  519,  519,  519,  177,  177,  177,  177,  177,
      177,  177,  174,  623,  174,  174,  174,  174,  174,  523,
      523,  523,  523,  523,  523,  523,  527,  527,  527,  527,
      527,  527,  527,  531,  531,  531,  531,  531,  531,  531,
      533,  533,  533,  533,  533,  533,  533,  535,  535,  535,
      535,  535,  535,  535,  539,  539,  539,  539,  539,  539,
      539,  200,  200,  200,  200,  200,  200,  200,  197,  623,

      197,  197,  197,  197,  197,  543,  543,  543,  543,  543,
      543,  543,  547,  547,  547,  547,  547,  547,  547,  549,
      549,  549,  549,  549,  549,  549,  213,  213,  213,  213,
      213,  213,  213,  210,  623,  210,  210,  210,  210,  210,
      551,  551,  551,  551,  551,  551,  551,  220,  220,  220,
      220,  220,  220,  220,  217,  623,  217,  217,  217,  217,
      217,  555,  555,  555,  555,  555,  555,  555,  227,  227,
      227,  227,  227,  227,  227,  224,  623,  224,  224,  224,
      224,  224,  559,  559,  559,  559,  559,  559,  559,  563,
      563,  563,  563,  563,  563,  563,  565,  565,  565,  565,

      565,  565,  565,  240,  240,  240,  240,  240,  240,  240,
      237,  623,  237,  237,  237,  237,  237,  567,  567,  567,
      567,  567,  567,  567,  571,  571,  571,  571,  571,  571,
      571,  573,  573,  573,  573,  573,  573,  573,  184,  184,
      184,  184,  184,  184,  184,  186,  186,  186,  186,  186,
      186,  186,  130,  130,  130,  130,  130,  130,  130,  499,
      499,  499,  499,  499,  499,  499,  495,  495,  495,  495,
      495,  495,  495,  501,  501,  501,  501,  501,  501,  501,
      143,  143,  143,  143,  143,  143,  143,  507,  507,  507,
      507,  507,  507,  507,  503,  503,  503,  503,  503,  503,

      503,  509,  509,  509,  509,  509,  509,  509,  253,  253,
      253,  253,  253,  253,  253,  250,  623,  250,  250,  250,
      250,  250,  330,  330,  330,  330,  330,  330,  330,  334,
      334,  334,  334,  334,  334,  334,  336,  336,  336,  336,
      336,  336,  336,  266,  266,  266,  266,  266,  266,  266,
      263,  623,  263,  263,  263,  263,  263,  338,  338,  338,
      338,  338,  338,  338,  273,  273,  273,  273,  273,  273,
      273,  270,  623,  270,  270,  270,  270,  270,  342,  342,
      342,  342,  342,  342,  342,  280,  280,  280,  280,  280,
      280,  280,  277,  623,  277,  277,  277,  277,  277,  575,

      575,  575,  575,  575,  575,  575,  579,  579,  579,  579,
      579,  579,  579,  581,  581,  581,  581,  581,  581,  581,
      293,  293,  293,  293,  293,  293,  293,  290,  623,  290,
      290,  290,  290,  290,  583,  583,  583,  583,  583,  583,
      583,  587,  587,  587,  587,  587,  587,  587,  589,  589,
      589,  589,  589,  589,  589,  306,  306,  306,  306,  306,
      306,  306,  303,  623,  303,  303,  303,  303,  303,  591,
      591,  591,  591,  591,  591,  591,  595,  595,  595,  595,
      595,  595,  595,  597,  597,  597,  597,  597,  597,  597,
      319,  319,  319,  319,  319,  319,  319,  316,  623,  316,

      316,  316,  316,  316,  599,  599,  599,  599,  599,  599,
      599,  326,  326,  326,  326,  326,  326,  326,  323,  623,
      323,  323,  323,  323,  323,  603,  603,  603,  603,  603,
      603,  603,  607,  607,  607,  607,  607,  607,  607,  611,
      611,  611,  611,  611,  611,  611,  613,  613,  613,  613,
      613,  613,  613,  615,  615,  615,  615,  615,  615,  615,
      619,  619,  619,  619,  619,  619,  619,  154,  154,  154,
      154,  154,  154,  154,  161,  161,  161,  161,  161,  161,
      161,  157,  157,  157,  157,  157,  157,  157,  164,  164,
      164,  164,  164,  164,  164,  167,  167,  167,  167,  167,

      167,  167,  170,  170,  170,  170,  170,  170,  170,  174,
      174,  174,  174,  174,  174,  174,  177,  177,  177,  177,
      177,  177,  177,   75,   75,   75,   75,   75,   75,   75,
      184,  184,  184,  184,  184,  184,  184,   78,   78,   78,
       78,   78,   78,   78,  186,  186,  186,  186,  186,  186,
      186,  114,  114,  114,  114,  114,  114,  114,  188,  188,
      188,  188,  188,  188,  188,  121,  121,  121,  121,  121,
      121,  121,  192,  192,  192,  192,  192,  192,  192,  197,
      197,  197,  197,  197,  197,  197,  204,  204,  204,  204,
      204,  204,  204,  200,  200,  200,  200,  200,  200,  200,

      207,  207,  207,  207,  207,  207,  207,  210,  210,  210,
      210,  210,  210,  210,  213,  213,  213,  213,  213,  213,
      213,  217,  217,  217,  217,  217,  217,  217,  220,  220,
      220,  220,  220,  220,  220,  224,  224,  224,  224,  224,
      224,  224,  231,  231,  231,  231,  231,  231,  231,  227,
      227,  227,  227,  227,  227,  227,  234,  234,  234,  234,
      234,  234,  234,  237,  237,  237,  237,  237,  237,  237,
      244,  244,  244,  244,  244,  244,  244,  240,  240,  240,
      240,  240,  240,  240,  247,  247,  247,  247,  247,  247,
      247,   74,   74,   74,  623,   74,   74,   74,   96,   96,

       96,   96,   96,   96,   96,   99,   99,   99,   99,   99,
       99,   99,  111,  111,  111,  111,  111,  111,  111,  118,
      118,  118,  118,  118,  118,  118,  127,  127,  127,  127,
      127,  127,  127,  134,  134,  134,  134,  134,  134,  134,
      130,  130,  130,  130,  130,  130,  130,  137,  137,  137,
      137,  137,  137,  137,  140,  140,  140,  140,  140,  140,
      140,  147,  147,  147,  147,  147,  147,  147,  143,  143,
      143,  143,  143,  143,  143,  150,  150,  150,  150,  150,
      150,  150,  250,  250,  250,  250,  250,  250,  250,  257,
      257,  257,  257,  257,  257,  257,  253,  253,  253,  253,

      253,  253,  253,  260,  260,  260,  260,  260,  260,  260,
      263,  263,  263,  263,  263,  263,  263,  266,  266,  266,
      266,  266,  266,  266,  270,  270,  270,  270,  270,  270,
      270,  273,  273,  273,  273,  273,  273,  273,  277,  277,
      277,  277,  277,  277,  277,  284,  284,  284,  284,  284,
      284,  284,  280,  280,  280,  280,  280,  280,  280,  287,
      287,  287,  287,  287,  287,  287,  290,  290,  290,  290,
      290,  290,  290,  297,  297,  297,  297,  297,  297,  297,
      293,  293,  293,  293,  293,  293,  293,  300,  300,  300,
      300,  300,  300,  300,  303,  303,  303,  303,  303,  303,

      303,  310,  310,  310,  310,  310,  310,  310,  306,  306,
      306,  306,  306,  306,  306,  313,  313,  313,  313,  313,
      313,  313,  316,  316,  316,  316,  316,  316,  316,  319,
      319,  319,  319,  319,  319,  319,  323,  323,  323,  323,
      323,  323,  323,  326,  326,  326,  326,  326,  326,  326,
      334,  334,  334,  334,  334,  334,  334,  330,  330,  330,
      330,  330,  330,  330,  336,  336,  336,  336,  336,  336,
      336,  338,  338,  338,  338,  338,  338,  338,  342,  342,
      342,  342,  342,  342,  342,  399,  399,  399,  399,  399,
      399,  399,  406,  406,  406,  406,  406,  406,  406,  402,

      402,  402,  402,  402,  402,  402,  409,  409,  409,  409,
      409,  409,  409,  412,  412,  412,  412,  412,  412,  412,
      415,  415,  415,  415,  415,  415,  415,  419,  419,  419,
      419,  419,  419,  419,  422,  422,  422,  422,  422,  422,
      422,  349,  349,  349,  349,  349,  349,  349,  430,  430,
      430,  430,  430,  430,  430,  426,  426,  426,  426,  426,
      426,  426,  432,  432,  432,  432,  432,  432,  432,  362,
      362,  362,  362,  362,  362,  362,  434,  434,  434,  434,
      434,  434,  434,  369,  369,  369,  369,  369,  369,  369,
      438,  438,  438,  438,  438,  438,  438,  442,  442,  442,

      442,  442,  442,  442,  449,  449,  449,  449,  449,  449,
      449,  445,  445,  445,  445,  445,  445,  445,  452,  452,
      452,  452,  452,  452,  452,  455,  455,  455,  455,  455,
      455,  455,  458,  458,  458,  458,  458,  458,  458,  462,
      462,  462,  462,  462,  462,  462,  465,  465,  465,  465,
      465,  465,  465,  469,  469,  469,  469,  469,  469,  469,
      476,  476,  476,  476,  476,  476,  476,  472,  472,  472,
      472,  472,  472,  472,  479,  479,  479,  479,  479,  479,
      479,  482,  482,  482,  482,  482,  482,  482,  489,  489,
      489,  489,  489,  489,  489,  485,  485,  485,  485,  485,

      485,  485,  492,  492,  492,  492,  492,  492,  492,  346,
      346,  346,  346,  346,  346,  346,  353,  353,  353,  353,
      353,  353,  353,  356,  356,  356,  356,  356,  356,  356,
      359,  359,  359,  359,  359,  359,  359,  366,  366,  366,
      366,  366,  366,  366,  373,  373,  373,  373,  373,  373,
      373,  380,  380,  380,  380,  380,  380,  380,  376,  376,
      376,  376,  376,  376,  376,  383,  383,  383,  383,  383,
      383,  383,  386,  386,  386,  386,  386,  386,  386,  393,
      393,  393,  393,  393,  393,  393,  389,  389,  389,  389,
      389,  389,  389,  396,  396,  396,  396,  396,  396,  396,

        7,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623
    } ;

static yyconst flex_int16_t yy_chk[4941] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    3,
        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
        3,    3,    3,    3,    3,    3,    3,    3,    5,    6,
        5,    6,   12,   13,   13,   14,   17,   17,   20,   20,
      636,   27,   25,   27,   25,   31,   20,   31,   38,    5,

        6,   12,   14,   25,   20,   32,   31,   32,   33,   37,
       44,   37,   39,   41,   33,   41,   32,   69,   25,   38,
       32,   31,   47,   47,   50,  628,   69,   54,   54,   44,
       55,   32,   41,   39,   41,   54,   57,   55,   57,   56,
       57,   50,   63,   54,   63,   55,   56,   41,   65,   68,
       65,   74,   75,   68,   56,   71,   72,   71,   72,   76,
       78,   76,   79,   80,   79,   80,   81,   84,   81,   84,
       85,   84,   74,   75,   94,   94,  140,   85,   76,  493,
       76,   78,   80,   79,   80,   85,   86,   81,   86,   93,
       86,  490,   96,   76,   96,  140,   93,   80,   98,   99,

       98,   99,  101,  483,  101,  109,  109,  111,  113,  111,
      113,  143,  114,   96,  114,  346,  115,   98,  115,   98,
       99,  101,  116,  101,  116,  397,  394,  113,  111,  113,
      143,  387,   98,  114,  346,  301,  101,  115,  117,  349,
      117,  116,  113,  116,  118,  120,  118,  120,  121,  122,
      121,  122,  123,  124,  123,  124,  116,  298,  349,  117,
      127,  129,  127,  129,  120,  118,  120,  291,  248,  121,
      122,  123,  245,  123,  124,  130,  131,  130,  131,  120,
      129,  127,  129,  132,  426,  132,  123,  133,  134,  133,
      134,  136,  137,  136,  137,  129,  130,  131,  141,  139,

      141,  139,  132,  426,  132,  142,  238,  503,  133,  134,
      136,  145,  136,  137,  144,  153,  144,  132,  139,  146,
      139,  146,  142,  151,  142,  136,  503,  147,  145,  147,
      145,  148,  149,  139,  149,  144,  150,  142,  150,  152,
      146,  152,  154,  145,  154,  126,  125,  157,  147,  157,
      156,  149,  156,  149,  158,  110,  158,  150,  152,  159,
      152,  159,  160,  154,  160,  161,  149,  161,  157,  156,
      163,  156,  163,  152,  164,  158,  164,  166,  159,  166,
      159,  108,  107,  160,  156,  167,  161,  167,  169,  163,
      169,  163,  170,  159,  170,  164,  166,  171,  166,  171,

      172,  106,  172,  173,  163,  173,  167,  169,  174,  169,
      174,  166,  176,  170,  176,  177,  105,  177,  171,  172,
      104,  172,  169,  178,  173,  178,  179,  103,  179,  174,
      180,  176,  180,  176,  172,  181,  177,  181,  182,  102,
      182,  183,   92,  183,  178,  179,  176,  179,  184,   91,
      184,  180,  185,  186,  185,  186,  181,  182,   90,  182,
      179,  187,  183,  187,  188,   89,  188,  527,  189,  184,
      189,  185,  182,  185,  186,  190,  191,  190,  191,  192,
      187,  192,  187,   88,   87,  188,  185,   77,  527,  189,
      193,  194,  193,  194,  190,  187,  190,  191,   70,  195,

      192,  195,  197,  199,  197,  199,  200,   62,  200,  190,
      194,  193,  194,  201,  202,  201,  202,  203,   61,  203,
      195,   59,  199,  197,  199,  194,  204,  200,  204,  207,
      206,  207,  206,  202,  201,  202,   58,  199,  203,  209,
      210,  209,  210,   53,  212,   49,  212,  204,  202,  206,
      207,  206,   45,  213,  214,  213,  214,   42,  209,   40,
      209,  210,   35,  212,  206,  212,  215,  216,  215,  216,
      217,   30,  217,  209,  213,  214,   29,  219,  212,  219,
      220,  221,  220,  221,  222,  215,  222,  215,  216,   24,
       23,  217,  223,  224,  223,  224,  219,   19,  219,   11,

      215,  220,  221,  222,  226,  222,  226,  227,  228,  227,
      228,  219,    9,  223,  224,  229,    7,  229,  222,  230,
      231,  230,  231,  226,  233,  226,  233,    0,  227,  228,
      234,  236,  234,  236,  229,  237,  229,  237,  226,    0,
      230,  231,  239,  233,  239,  233,  240,    0,  240,  229,
      236,  234,  236,  241,    0,  241,  237,  243,  233,  243,
      242,  239,  242,  239,  244,  236,  244,  240,  246,  247,
      246,  247,    0,    0,  241,  250,  239,  250,  243,  242,
      249,  242,  249,    0,  252,  244,  252,  246,    0,  246,
      247,  253,    0,  253,  242,  254,  250,  254,  255,  249,

      255,  249,  246,  252,  256,  252,  256,  257,  259,  257,
      259,    0,  253,  260,  249,  260,  254,  255,  252,  255,
      262,    0,  262,    0,  263,  256,  263,  259,  257,  259,
        0,  265,  255,  265,  260,  266,  267,  266,  267,  262,
        0,  262,  259,    0,    0,  263,  269,  268,  269,  268,
      265,  270,  265,  270,  262,    0,  266,  267,  272,  273,
      272,  273,  274,    0,  274,  265,  268,  269,  268,  275,
        0,  275,  270,  276,  277,  276,  277,  272,    0,  272,
      273,  268,    0,  274,  280,  279,  280,  279,  275,  281,
      275,  281,  272,    0,  276,  277,  282,  283,  282,  283,

      284,    0,  284,  275,  279,  280,  279,  286,    0,  286,
      281,  287,  289,  287,  289,  282,    0,  282,  283,  279,
        0,  284,  290,  292,  290,  292,  286,  293,  286,  293,
      282,  289,  287,  289,  294,  295,  294,  295,  296,    0,
      296,  286,  292,  290,  292,  297,  289,  297,  293,  299,
      300,  299,  300,    0,  295,  294,  295,  292,  302,  296,
      302,  303,    0,  303,    0,  305,  297,  305,  299,  295,
      299,  300,  306,  307,  306,  307,  308,  302,  308,  302,
        0,    0,  303,  299,  305,  309,  305,  309,  310,    0,
      310,    0,  302,  306,  307,  308,  312,  308,  312,  305,

      313,  315,  313,  315,    0,  316,  309,  316,    0,  310,
      308,  319,  318,  319,  318,  312,  320,  312,  320,    0,
      315,  313,  315,  321,    0,  321,  316,  322,    0,  322,
      312,  318,  319,  318,  323,  315,  323,  320,  326,  325,
      326,  325,  321,  327,  321,  327,  318,  328,  322,  328,
      329,  330,  329,  330,  331,  323,  331,  321,  325,  326,
      325,  332,    0,  332,  327,  333,  328,  333,  328,    0,
        0,  329,  330,  325,    0,  331,  334,  335,  334,  335,
      332,  328,  332,  336,    0,  336,  333,  337,  338,  337,
      338,  339,  341,  339,  341,  332,  335,  334,  335,  340,

        0,  340,    0,  342,  336,  342,  337,    0,  337,  338,
      348,  335,  339,  341,  343,  344,  343,  344,  340,    0,
      340,  337,  351,  345,  342,  345,  350,  348,  350,  348,
      352,    0,  352,  340,  344,  343,  344,    0,  353,  351,
      353,  351,  348,  355,  345,  355,  356,  350,  356,  344,
      358,  352,  358,  359,  351,  359,    0,    0,  362,  353,
      362,  361,  355,  361,  355,    0,  363,  356,  363,  358,
      364,  358,  364,  365,  359,  365,  366,  355,  366,  362,
      361,  368,  361,  368,  358,    0,  369,  363,  369,  364,
      370,  364,  370,    0,  365,  361,  372,  366,  372,  371,

      368,  371,  368,  373,  364,  373,  375,  369,  375,    0,
      376,  370,  376,    0,  377,  368,  377,  372,  371,    0,
      371,  379,    0,  379,  373,  375,  378,  375,  378,    0,
      380,  376,  380,  371,  382,  377,  382,  383,    0,  383,
      375,  386,  379,  386,  385,  378,  385,  378,  388,    0,
      388,  380,  389,  382,  389,  382,    0,    0,  383,  390,
      378,  390,  386,  385,  391,  385,  391,  388,  382,  388,
      392,    0,  392,  389,  393,  395,  393,  395,  385,  396,
      390,  396,  388,  391,  398,  391,  398,  399,    0,  399,
      402,  392,  402,    0,  395,  393,  395,    0,  391,  403,

      396,  403,  401,  398,  401,  398,    0,    0,  399,  395,
      404,  402,  404,  405,  406,  405,  406,  409,  398,  409,
      403,  401,  408,  401,  408,  412,  411,  412,  411,  404,
      414,  404,  414,    0,  405,  406,  401,  415,  409,  415,
      416,  408,  416,  408,  404,  411,  412,  411,  417,  414,
      417,  414,  418,  419,  418,  419,  408,  421,  415,  421,
      411,  416,    0,  422,  414,  422,  423,  417,  423,  417,
        0,  428,    0,  418,  419,  424,  421,  424,  421,  425,
        0,  425,  417,  427,  422,  427,    0,  423,  428,    0,
      428,  421,    0,  429,  424,  429,  424,  430,    0,  430,

      425,    0,    0,  428,  427,  431,  432,  431,  432,  424,
      433,  434,  433,  434,  429,  435,    0,  435,  430,  436,
      437,  436,  437,    0,  431,    0,  431,  432,  438,  433,
      438,  433,  434,  439,    0,  439,  435,    0,  436,  431,
      436,  437,    0,  440,  433,  440,  441,    0,  441,  438,
      442,    0,  442,  436,  439,  444,    0,  444,  445,  446,
      445,  446,  440,  447,  440,  447,  448,  441,  448,    0,
      449,  442,  449,  451,  444,  451,  444,  440,    0,  445,
      446,  452,  447,  452,  447,    0,    0,  448,  455,  444,
      455,  449,  451,  454,  451,  454,  457,  447,  457,  458,

        0,  458,  452,  459,  460,  459,  460,  451,  461,  455,
      461,  462,  454,  462,  454,  457,  464,  457,  464,  465,
      458,  465,    0,  460,  459,  460,  466,  454,  466,  461,
      457,  468,  462,  468,  467,  464,  467,  464,  460,  469,
      465,  469,  471,  472,  471,  472,  473,  466,  473,  475,
      464,  475,  468,  467,  474,  467,  474,  476,    0,  476,
      469,  471,    0,  471,  472,    0,    0,  473,  467,  479,
      475,  479,  478,  474,  478,  474,  471,  481,  476,  481,
      482,  484,  482,  484,  485,    0,  485,  486,  474,  486,
      479,  478,  488,  478,  488,  487,  481,  487,  481,    0,

      484,  482,  484,    0,    0,  485,  478,  489,  486,  489,
      492,  481,  492,  488,  487,  484,  487,  491,  494,  491,
      494,  495,  496,  495,  496,  497,    0,  497,  489,  487,
        0,  492,  498,  499,  498,  499,  491,  494,  491,  494,
        0,    0,  495,  496,  497,  500,  497,  500,  501,    0,
      501,  491,  494,  498,  499,  502,  504,  502,  504,  497,
      506,  505,  506,  507,  500,  507,  500,    0,    0,  501,
      509,  508,  509,  508,  502,    0,  502,  504,  505,  500,
      505,  506,    0,  510,  507,  510,  511,    0,  511,  502,
      508,  509,  508,  505,  512,  513,  512,  513,  514,  515,

      514,  515,  510,    0,  510,  508,  516,  511,  516,  517,
      519,  517,  519,    0,  513,  512,  513,  510,    0,  514,
      515,  520,  518,  520,  518,  516,  521,  516,  521,  513,
      517,  519,  522,  523,  522,  523,  524,  526,  524,  526,
      516,  518,  520,  518,  525,  521,  525,  521,  528,  529,
      528,  529,    0,  522,  523,    0,  518,  524,  526,  530,
      521,  530,    0,  525,  531,  525,  531,    0,  529,  528,
      529,  532,  533,  532,  533,  534,    0,  534,  525,  535,
      530,  535,  536,  529,  536,  531,  538,  537,  538,  537,
      532,    0,  532,  533,  534,  539,  534,  539,    0,  540,

      535,  540,  542,  536,  542,  532,  537,  538,  537,  534,
      541,  543,  541,  543,    0,  544,  539,  544,    0,    0,
      540,  537,  545,  542,  545,  546,  547,  546,  547,  541,
        0,  541,  543,  548,    0,  548,  544,  549,  550,  549,
      550,  545,    0,  545,  541,    0,  546,  547,  551,  552,
      551,  552,  548,  554,  548,  554,  545,  550,  549,  550,
      553,  555,  553,  555,  556,    0,  556,  548,    0,  551,
      552,  557,  550,  557,  554,  558,  559,  558,  559,  553,
        0,  553,  555,    0,    0,  556,  560,  561,  560,  561,
      557,  562,  557,  562,  553,    0,  558,  559,  563,  564,

      563,  564,  565,    0,  565,  557,  561,  560,  561,  566,
        0,  566,  562,  567,  568,  567,  568,    0,  564,  563,
      564,  561,    0,  565,  570,  569,  570,  569,  566,  571,
      566,  571,    0,  564,  567,  568,  572,  573,  572,  573,
      575,    0,  575,  566,  569,  570,  569,  574,    0,  574,
      571,  576,  577,  576,  577,  572,    0,  572,  573,  569,
        0,  575,  578,  579,  578,  579,  574,  581,  574,  581,
      572,  577,  576,  577,  580,  582,  580,  582,  583,    0,
      583,  574,    0,  578,  579,  584,  577,  584,  581,  586,
      587,  586,  587,  580,  582,  580,  582,    0,  585,  583,

      585,  588,  589,  588,  589,  590,  584,  590,  580,  582,
      586,  587,  591,  592,  591,  592,  594,  585,  594,  585,
      588,    0,  588,  589,  590,  593,  590,  593,  595,  596,
      595,  596,  585,  591,  592,  588,  597,  594,  597,  590,
      599,  598,  599,  598,  593,  600,  593,  600,  596,  595,
      596,  601,  602,  601,  602,    0,  603,  597,  603,  593,
      598,  599,  598,  596,    0,  604,  600,  604,    0,  605,
      601,  605,  601,  602,  606,  598,  606,  603,  607,  608,
      607,  608,    0,    0,    0,  601,  604,  609,  605,  609,
      605,  610,  611,  610,  611,  606,  612,    0,  612,  607,

      608,    0,  613,  605,  613,  614,  609,  614,  609,    0,
        0,    0,  610,  611,  615,  612,  615,  612,    0,    0,
      616,  609,  616,  613,  614,  617,  614,  617,    0,  618,
      612,  618,  619,    0,  619,  615,  620,    0,  620,  614,
      622,  616,  622,  621,  617,  621,  617,    0,    0,    0,
      618,    0,    0,  619,    0,    0,    0,  620,    0,  617,
        0,  622,  621,    0,  621,    0,    0,    0,    0,    0,
        0,    0,    0,    0,    0,    0,    0,  621,  624,  624,
      624,  624,  624,  624,  624,  625,    0,    0,  625,  625,
      625,  625,  626,  626,  626,  626,  626,  626,  626,  627,

        0,    0,  627,  627,  627,  627,  629,  629,  629,  629,
      629,  629,  629,  630,  630,  630,  631,  631,  631,  632,
      632,  632,  633,  633,  633,    0,  633,  633,  633,  634,
      634,  634,  634,  634,  634,  634,  635,    0,  635,  637,
      637,  637,  637,  637,  637,  637,  638,  638,  638,  638,
      638,  638,  638,  639,    0,  639,  640,  640,  640,  640,
      640,  640,  640,  641,    0,  641,  641,  641,  641,  641,
      642,  642,  642,  642,  642,  642,  642,  643,  643,  643,
      643,  643,  643,  643,  644,    0,  644,  644,  644,  644,
      644,  645,  645,  645,  645,  645,  645,  645,  646,  646,

      646,  646,  646,  646,  646,  647,    0,  647,  647,  647,
      647,  647,  648,  648,  648,  648,  648,  648,  648,  649,
      649,  649,  649,  649,  649,  649,  650,  650,  650,  650,
      650,  650,  650,  651,  651,  651,  651,  651,  651,  651,
      652,    0,  652,  652,  652,  652,  652,  653,  653,  653,
      653,  653,  653,  653,  654,  654,  654,  654,  654,  654,
      654,  655,  655,  655,  655,  655,  655,  655,  656,  656,
      656,  656,  656,  656,  656,  657,    0,  657,  657,  657,
      657,  657,  658,  658,  658,  658,  658,  658,  658,  659,
      659,  659,  659,  659,  659,  659,  660,  660,  660,  660,

      660,  660,  660,  661,  661,  661,  661,  661,  661,  661,
      662,    0,  662,  662,  662,  662,  662,  663,  663,  663,
      663,  663,  663,  663,  664,  664,  664,  664,  664,  664,
      664,  665,    0,  665,  665,  665,  665,  665,  666,  666,
      666,  666,  666,  666,  666,  667,  667,  667,  667,  667,
      667,  667,  668,  668,  668,  668,  668,  668,  668,  669,
      669,  669,  669,  669,  669,  669,  670,  670,  670,  670,
      670,  670,  670,  671,  671,  671,  671,  671,  671,  671,
      672,  672,  672,  672,  672,  672,  672,  673,    0,  673,
      673,  673,  673,  673,  674,  674,  674,  674,  674,  674,

      674,  675,  675,  675,  675,  675,  675,  675,  676,  676,
      676,  676,  676,  676,  676,  677,  677,  677,  677,  677,
      677,  677,  678,    0,  678,  678,  678,  678,  678,  679,
      679,  679,  679,  679,  679,  679,  680,  680,  680,  680,
      680,  680,  680,  681,    0,  681,  681,  681,  681,  681,
      682,  682,  682,  682,  682,  682,  682,  683,  683,  683,
      683,  683,  683,  683,  684,    0,  684,  684,  684,  684,
      684,  685,  685,  685,  685,  685,  685,  685,  686,  686,
      686,  686,  686,  686,  686,  687,  687,  687,  687,  687,
      687,  687,  688,  688,  688,  688,  688,  688,  688,  689,

        0,  689,  689,  689,  689,  689,  690,  690,  690,  690,
      690,  690,  690,  691,  691,  691,  691,  691,  691,  691,
      692,  692,  692,  692,  692,  692,  692,  693,  693,  693,
      693,  693,  693,  693,  694,  694,  694,  694,  694,  694,
      694,  695,  695,  695,  695,  695,  695,  695,  696,  696,
      696,  696,  696,  696,  696,  697,  697,  697,  697,  697,
      697,  697,  698,  698,  698,  698,  698,  698,  698,  699,
      699,  699,  699,  699,  699,  699,  700,  700,  700,  700,
      700,  700,  700,  701,  701,  701,  701,  701,  701,  701,
      702,  702,  702,  702,  702,  702,  702,  703,  703,  703,

      703,  703,  703,  703,  704,    0,  704,  704,  704,  704,
      704,  705,  705,  705,  705,  705,  705,  705,  706,  706,
      706,  706,  706,  706,  706,  707,  707,  707,  707,  707,
      707,  707,  708,  708,  708,  708,  708,  708,  708,  709,
        0,  709,  709,  709,  709,  709,  710,  710,  710,  710,
      710,  710,  710,  711,  711,  711,  711,  711,  711,  711,
      712,    0,  712,  712,  712,  712,  712,  713,  713,  713,
      713,  713,  713,  713,  714,  714,  714,  714,  714,  714,
      714,  715,    0,  715,  715,  715,  715,  715,  716,  716,
      716,  716,  716,  716,  716,  717,  717,  717,  717,  717,

      717,  717,  718,  718,  718,  718,  718,  718,  718,  719,
      719,  719,  719,  719,  719,  719,  720,    0,  720,  720,
      720,  720,  720,  721,  721,  721,  721,  721,  721,  721,
      722,  722,  722,  722,  722,  722,  722,  723,  723,  723,
      723,  723,  723,  723,  724,  724,  724,  724,  724,  724,
      724,  725,    0,  725,  725,  725,  725,  725,  726,  726,
      726,  726,  726,  726,  726,  727,  727,  727,  727,  727,
      727,  727,  728,  728,  728,  728,  728,  728,  728,  729,
      729,  729,  729,  729,  729,  729,  730,    0,  730,  730,
      730,  730,  730,  731,  731,  731,  731,  731,  731,  731,

      732,  732,  732,  732,  732,  732,  732,  733,    0,  733,
      733,  733,  733,  733,  734,  734,  734,  734,  734,  734,
      734,  735,  735,  735,  735,  735,  735,  735,  736,  736,
      736,  736,  736,  736,  736,  737,  737,  737,  737,  737,
      737,  737,  738,  738,  738,  738,  738,  738,  738,  739,
      739,  739,  739,  739,  739,  739,  740,  740,  740,  740,
      740,  740,  740,  741,    0,  741,  741,  741,  741,  741,
      742,  742,  742,  742,  742,  742,  742,  743,  743,  743,
      743,  743,  743,  743,  744,  744,  744,  744,  744,  744,
      744,  745,  745,  745,  745,  745,  745,  745,  746,    0,

      746,  746,  746,  746,  746,  747,  747,  747,  747,  747,
      747,  747,  748,  748,  748,  748,  748,  748,  748,  749,
        0,  749,  749,  749,  749,  749,  750,  750,  750,  750,
      750,  750,  750,  751,  751,  751,  751,  751,  751,  751,
      752,    0,  752,  752,  752,  752,  752,  753,  753,  753,
      753,  753,  753,  753,  754,  754,  754,  754,  754,  754,
      754,  755,  755,  755,  755,  755,  755,  755,  756,  756,
      756,  756,  756,  756,  756,  757,    0,  757,  757,  757,
      757,  757,  758,  758,  758,  758,  758,  758,  758,  759,
      759,  759,  759,  759,  759,  759,  760,  760,  760,  760,

      760,  760,  760,  761,  761,  761,  761,  761,  761,  761,
      762,    0,  762,  762,  762,  762,  762,  763,  763,  763,
      763,  763,  763,  763,  764,  764,  764,  764,  764,  764,
      764,  765,  765,  765,  765,  765,  765,  765,  766,  766,
      766,  766,  766,  766,  766,  767,    0,  767,  767,  767,
      767,  767,  768,  768,  768,  768,  768,  768,  768,  769,
      769,  769,  769,  769,  769,  769,  770,    0,  770,  770,
      770,  770,  770,  771,  771,  771,  771,  771,  771,  771,
      772,  772,  772,  772,  772,  772,  772,  773,  773,  773,
      773,  773,  773,  773,  774,  774,  774,  774,  774,  774,

      774,  775,  775,  775,  775,  775,  775,  775,  776,  776,
      776,  776,  776,  776,  776,  777,  777,  777,  777,  777,
      777,  777,  778,    0,  778,  778,  778,  778,  778,  779,
      779,  779,  779,  779,  779,  779,  780,  780,  780,  780,
      780,  780,  780,  781,  781,  781,  781,  781,  781,  781,
      782,  782,  782,  782,  782,  782,  782,  783,    0,  783,
      783,  783,  783,  783,  784,  784,  784,  784,  784,  784,
      784,  785,  785,  785,  785,  785,  785,  785,  786,    0,
      786,  786,  786,  786,  786,  787,  787,  787,  787,  787,
      787,  787,  788,  788,  788,  788,  788,  788,  788,  789,

        0,  789,  789,  789,  789,  789,  790,  790,  790,  790,
      790,  790,  790,  791,  791,  791,  791,  791,  791,  791,
      792,  792,  792,  792,  792,  792,  792,  793,  793,  793,
      793,  793,  793,  793,  794,    0,  794,  794,  794,  794,
      794,  795,  795,  795,  795,  795,  795,  795,  796,  796,
      796,  796,  796,  796,  796,  797,  797,  797,  797,  797,
      797,  797,  798,  798,  798,  798,  798,  798,  798,  799,
      799,  799,  799,  799,  799,  799,  800,  800,  800,  800,
      800,  800,  800,  801,  801,  801,  801,  801,  801,  801,
      802,  802,  802,  802,  802,  802,  802,  803,  803,  803,

      803,  803,  803,  803,  804,  804,  804,  804,  804,  804,
      804,  805,  805,  805,  805,  805,  805,  805,  806,  806,
      806,  806,  806,  806,  806,  807,  807,  807,  807,  807,
      807,  807,  808,  808,  808,  808,  808,  808,  808,  809,
        0,  809,  809,  809,  809,  809,  810,  810,  810,  810,
      810,  810,  810,  811,  811,  811,  811,  811,  811,  811,
      812,  812,  812,  812,  812,  812,  812,  813,  813,  813,
      813,  813,  813,  813,  814,    0,  814,  814,  814,  814,
      814,  815,  815,  815,  815,  815,  815,  815,  816,  816,
      816,  816,  816,  816,  816,  817,    0,  817,  817,  817,

      817,  817,  818,  818,  818,  818,  818,  818,  818,  819,
      819,  819,  819,  819,  819,  819,  820,    0,  820,  820,
      820,  820,  820,  821,  821,  821,  821,  821,  821,  821,
      822,  822,  822,  822,  822,  822,  822,  823,  823,  823,
      823,  823,  823,  823,  824,  824,  824,  824,  824,  824,
      824,  825,    0,  825,  825,  825,  825,  825,  826,  826,
      826,  826,  826,  826,  826,  827,  827,  827,  827,  827,
      827,  827,  828,  828,  828,  828,  828,  828,  828,  829,
      829,  829,  829,  829,  829,  829,  830,    0,  830,  830,
      830,  830,  830,  831,  831,  831,  831,  831,  831,  831,

      832,  832,  832,  832,  832,  832,  832,  833,  833,  833,
      833,  833,  833,  833,  834,  834,  834,  834,  834,  834,
      834,  835,    0,  835,  835,  835,  835,  835,  836,  836,
      836,  836,  836,  836,  836,  837,  837,  837,  837,  837,
      837,  837,  838,    0,  838,  838,  838,  838,  838,  839,
      839,  839,  839,  839,  839,  839,  840,  840,  840,  840,
      840,  840,  840,  841,  841,  841,  841,  841,  841,  841,
      842,  842,  842,  842,  842,  842,  842,  843,  843,  843,
      843,  843,  843,  843,  844,  844,  844,  844,  844,  844,
      844,  845,  845,  845,  845,  845,  845,  845,  846,    0,

      846,  846,  846,  846,  846,  847,  847,  847,  847,  847,
      847,  847,  848,  848,  848,  848,  848,  848,  848,  849,
      849,  849,  849,  849,  849,  849,  850,  850,  850,  850,
      850,  850,  850,  851,    0,  851,  851,  851,  851,  851,
      852,  852,  852,  852,  852,  852,  852,  853,  853,  853,
      853,  853,  853,  853,  854,    0,  854,  854,  854,  854,
      854,  855,  855,  855,  855,  855,  855,  855,  856,  856,
      856,  856,  856,  856,  856,  857,    0,  857,  857,  857,
      857,  857,  858,  858,  858,  858,  858,  858,  858,  859,
      859,  859,  859,  859,  859,  859,  860,  860,  860,  860,

      860,  860,  860,  861,  861,  861,  861,  861,  861,  861,
      862,    0,  862,  862,  862,  862,  862,  863,  863,  863,
      863,  863,  863,  863,  864,  864,  864,  864,  864,  864,
      864,  865,  865,  865,  865,  865,  865,  865,  866,  866,
      866,  866,  866,  866,  866,  867,  867,  867,  867,  867,
      867,  867,  868,  868,  868,  868,  868,  868,  868,  869,
      869,  869,  869,  869,  869,  869,  870,  870,  870,  870,
      870,  870,  870,  871,  871,  871,  871,  871,  871,  871,
      872,  872,  872,  872,  872,  872,  872,  873,  873,  873,
      873,  873,  873,  873,  874,  874,  874,  874,  874,  874,

      874,  875,  875,  875,  875,  875,  875,  875,  876,  876,
      876,  876,  876,  876,  876,  877,    0,  877,  877,  877,
      877,  877,  878,  878,  878,  878,  878,  878,  878,  879,
      879,  879,  879,  879,  879,  879,  880,  880,  880,  880,
      880,  880,  880,  881,  881,  881,  881,  881,  881,  881,
      882,    0,  882,  882,  882,  882,  882,  883,  883,  883,
      883,  883,  883,  883,  884,  884,  884,  884,  884,  884,
      884,  885,    0,  885,  885,  885,  885,  885,  886,  886,
      886,  886,  886,  886,  886,  887,  887,  887,  887,  887,
      887,  887,  888,    0,  888,  888,  888,  888,  888,  889,

      889,  889,  889,  889,  889,  889,  890,  890,  890,  890,
      890,  890,  890,  891,  891,  891,  891,  891,  891,  891,
      892,  892,  892,  892,  892,  892,  892,  893,    0,  893,
      893,  893,  893,  893,  894,  894,  894,  894,  894,  894,
      894,  895,  895,  895,  895,  895,  895,  895,  896,  896,
      896,  896,  896,  896,  896,  897,  897,  897,  897,  897,
      897,  897,  898,    0,  898,  898,  898,  898,  898,  899,
      899,  899,  899,  899,  899,  899,  900,  900,  900,  900,
      900,  900,  900,  901,  901,  901,  901,  901,  901,  901,
      902,  902,  902,  902,  902,  902,  902,  903,    0,  903,

      903,  903,  903,  903,  904,  904,  904,  904,  904,  904,
      904,  905,  905,  905,  905,  905,  905,  905,  906,    0,
      906,  906,  906,  906,  906,  907,  907,  907,  907,  907,
      907,  907,  908,  908,  908,  908,  908,  908,  908,  909,
      909,  909,  909,  909,  909,  909,  910,  910,  910,  910,
      910,  910,  910,  911,  911,  911,  911,  911,  911,  911,
      912,  912,  912,  912,  912,  912,  912,  913,  913,  913,
      913,  913,  913,  913,  914,  914,  914,  914,  914,  914,
      914,  915,  915,  915,  915,  915,  915,  915,  916,  916,
      916,  916,  916,  916,  916,  917,  917,  917,  917,  917,

      917,  917,  918,  918,  918,  918,  918,  918,  918,  919,
      919,  919,  919,  919,  919,  919,  920,  920,  920,  920,
      920,  920,  920,  921,  921,  921,  921,  921,  921,  921,
      922,  922,  922,  922,  922,  922,  922,  923,  923,  923,
      923,  923,  923,  923,  924,  924,  924,  924,  924,  924,
      924,  925,  925,  925,  925,  925,  925,  925,  926,  926,
      926,  926,  926,  926,  926,  927,  927,  927,  927,  927,
      927,  927,  928,  928,  928,  928,  928,  928,  928,  929,
      929,  929,  929,  929,  929,  929,  930,  930,  930,  930,
      930,  930,  930,  931,  931,  931,  931,  931,  931,  931,

      932,  932,  932,  932,  932,  932,  932,  933,  933,  933,
      933,  933,  933,  933,  934,  934,  934,  934,  934,  934,
      934,  935,  935,  935,  935,  935,  935,  935,  936,  936,
      936,  936,  936,  936,  936,  937,  937,  937,  937,  937,
      937,  937,  938,  938,  938,  938,  938,  938,  938,  939,
      939,  939,  939,  939,  939,  939,  940,  940,  940,  940,
      940,  940,  940,  941,  941,  941,  941,  941,  941,  941,
      942,  942,  942,  942,  942,  942,  942,  943,  943,  943,
      943,  943,  943,  943,  944,  944,  944,  944,  944,  944,
      944,  945,  945,  945,    0,  945,  945,  945,  946,  946,

      946,  946,  946,  946,  946,  947,  947,  947,  947,  947,
      947,  947,  948,  948,  948,  948,  948,  948,  948,  949,
      949,  949,  949,  949,  949,  949,  950,  950,  950,  950,
      950,  950,  950,  951,  951,  951,  951,  951,  951,  951,
      952,  952,  952,  952,  952,  952,  952,  953,  953,  953,
      953,  953,  953,  953,  954,  954,  954,  954,  954,  954,
      954,  955,  955,  955,  955,  955,  955,  955,  956,  956,
      956,  956,  956,  956,  956,  957,  957,  957,  957,  957,
      957,  957,  958,  958,  958,  958,  958,  958,  958,  959,
      959,  959,  959,  959,  959,  959,  960,  960,  960,  960,

      960,  960,  960,  961,  961,  961,  961,  961,  961,  961,
      962,  962,  962,  962,  962,  962,  962,  963,  963,  963,
      963,  963,  963,  963,  964,  964,  964,  964,  964,  964,
      964,  965,  965,  965,  965,  965,  965,  965,  966,  966,
      966,  966,  966,  966,  966,  967,  967,  967,  967,  967,
      967,  967,  968,  968,  968,  968,  968,  968,  968,  969,
      969,  969,  969,  969,  969,  969,  970,  970,  970,  970,
      970,  970,  970,  971,  971,  971,  971,  971,  971,  971,
      972,  972,  972,  972,  972,  972,  972,  973,  973,  973,
      973,  973,  973,  973,  974,  974,  974,  974,  974,  974,

      974,  975,  975,  975,  975,  975,  975,  975,  976,  976,
      976,  976,  976,  976,  976,  977,  977,  977,  977,  977,
      977,  977,  978,  978,  978,  978,  978,  978,  978,  979,
      979,  979,  979,  979,  979,  979,  980,  980,  980,  980,
      980,  980,  980,  981,  981,  981,  981,  981,  981,  981,
      982,  982,  982,  982,  982,  982,  982,  983,  983,  983,
      983,  983,  983,  983,  984,  984,  984,  984,  984,  984,
      984,  985,  985,  985,  985,  985,  985,  985,  986,  986,
      986,  986,  986,  986,  986,  987,  987,  987,  987,  987,
      987,  987,  988,  988,  988,  988,  988,  988,  988,  989,

      989,  989,  989,  989,  989,  989,  990,  990,  990,  990,
      990,  990,  990,  991,  991,  991,  991,  991,  991,  991,
      992,  992,  992,  992,  992,  992,  992,  993,  993,  993,
      993,  993,  993,  993,  994,  994,  994,  994,  994,  994,
      994,  995,  995,  995,  995,  995,  995,  995,  996,  996,
      996,  996,  996,  996,  996,  997,  997,  997,  997,  997,
      997,  997,  998,  998,  998,  998,  998,  998,  998,  999,
      999,  999,  999,  999,  999,  999, 1000, 1000, 1000, 1000,
     1000, 1000, 1000, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
     1002, 1002, 1002, 1002, 1002, 1002, 1002, 1003, 1003, 1003,

     1003, 1003, 1003, 1003, 1004, 1004, 1004, 1004, 1004, 1004,
     1004, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1006, 1006,
     1006, 1006, 1006, 1006, 1006, 1007, 1007, 1007, 1007, 1007,
     1007, 1007, 1008, 1008, 1008, 1008, 1008, 1008, 1008, 1009,
     1009, 1009, 1009, 1009, 1009, 1009, 1010, 1010, 1010, 1010,
     1010, 1010, 1010, 1011, 1011, 1011, 1011, 1011, 1011, 1011,
     1012, 1012, 1012, 1012, 1012, 1012, 1012, 1013, 1013, 1013,
     1013, 1013, 1013, 1013, 1014, 1014, 1014, 1014, 1014, 1014,
     1014, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1016, 1016,
     1016, 1016, 1016, 1016, 1016, 1017, 1017, 1017, 1017, 1017,

     1017, 1017, 1018, 1018, 1018, 1018, 1018, 1018, 1018, 1019,
     1019, 1019, 1019, 1019, 1019, 1019, 1020, 1020, 1020, 1020,
     1020, 1020, 1020, 1021, 1021, 1021, 1021, 1021, 1021, 1021,
     1022, 1022, 1022, 1022, 1022, 1022, 1022, 1023, 1023, 1023,
     1023, 1023, 1023, 1023, 1024, 1024, 1024, 1024, 1024, 1024,
     1024, 1025, 1025, 1025, 1025, 1025, 1025, 1025, 1026, 1026,
     1026, 1026, 1026, 1026, 1026, 1027, 1027, 1027, 1027, 1027,
     1027, 1027, 1028, 1028, 1028, 1028, 1028, 1028, 1028, 1029,
     1029, 1029, 1029, 1029, 1029, 1029, 1030, 1030, 1030, 1030,
     1030, 1030, 1030, 1031, 1031, 1031, 1031, 1031, 1031, 1031,

      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623,
      623,  623,  623,  623,  623,  623,  623,  623,  623,  623
    } ;

/* 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
#line 1 "./turtle_lexer.l"
/* -*- Mode: c; c-basic-offset: 2 -*-
 *
 * turtle_lexer.l - Raptor Turtle lexer - making tokens for turtle grammar generator
 *
 * Copyright (C) 2003-2006, David Beckett http://purl.org/net/dajobe/
 * Copyright (C) 2003-2005, University of Bristol, UK http://www.bristol.ac.uk/
 * 
 * This package is Free Software and part of Redland http://librdf.org/
 * 
 * It is licensed under the following three licenses as alternatives:
 *   1. GNU Lesser General Public License (LGPL) V2.1 or any newer version
 *   2. GNU General Public License (GPL) V2 or any newer version
 *   3. Apache License, V2.0 or any newer version
 * 
 * You may not use this file except in compliance with at least one of
 * the above three licenses.
 * 
 * See LICENSE.html or LICENSE.txt at the top of this package for the
 * complete terms and further detail along with the license texts for
 * the licenses in COPYING.LIB, COPYING and LICENSE-2.0.txt respectively.
 * 
 * 
 * Turtle is defined in http://www.dajobe.org/2004/01/turtle/
 *
 * To generate the C files from this source, rather than use the
 * shipped turtle_lexer.c/.h needs a patched version of flex 2.5.31 such
 * as the one available in Debian GNU/Linux.   Details below
 * near the %option descriptions.
 *
 */
/* recognise 8-bits */
/* all symbols prefixed by this */
/* This is not needed, flex is invoked -oturtle_lexer.c */
/* %option outfile="turtle_lexer.c" */
/* Emit a C header file for prototypes
 * Only available in flex 2.5.13 or newer.
 * It was renamed to header-file in flex 2.5.19
 */
/* Do not emit #include <unistd.h>
 * Only available in flex 2.5.7 or newer.
 * Broken in flex 2.5.31 without patches.
 */
#define YY_NO_UNISTD_H 1
/* Never interactive */
/*  No isatty() check */
/* Batch scanner */
/* Never use yyunput */
/* definitions */
#line 71 "./turtle_lexer.l"

/* NOTE: These headers are NOT included here but are inserted by
 * fix-flex since otherwise it appears far too late in the generated C
 */

/*
#ifdef HAVE_CONFIG_H
#include <raptor_config.h>
#endif

#ifdef WIN32
#include <win32_raptor_config.h>
#endif
*/

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#include <raptor.h>
#include <raptor_internal.h>

#include <turtle_parser.h>

#include <turtle_common.h>


/* Prototypes */ 
static unsigned char *turtle_copy_token(unsigned char *text, size_t len);
static unsigned char *turtle_copy_string_token(raptor_parser* rdf_parser, unsigned char *text, size_t len, int delim);
void turtle_lexer_syntax_error(void* ctx, const char *message, ...) RAPTOR_PRINTF_FORMAT(2, 3);

#ifdef RAPTOR_DEBUG
const char * turtle_token_print(int token, YYSTYPE *lval);
#endif

int turtle_lexer_lex (YYSTYPE *turtle_parser_lval, yyscan_t yyscanner);
#define YY_DECL int turtle_lexer_lex (YYSTYPE *turtle_parser_lval, yyscan_t yyscanner)

#ifdef __cplusplus
#define INPUT_FN yyinput
#else
#define INPUT_FN input
#endif


/* Missing turtle_lexer.c/h prototypes */
int turtle_lexer_get_column(yyscan_t yyscanner);
void turtle_lexer_set_column(int  column_no , yyscan_t yyscanner);

/* from SPARQL */
/* similar to SPARQL but no need for <= check here */

#line 1925 "turtle_lexer.c"

#define INITIAL 0
#define PREF 1
#define LITERAL 2

#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.
 */
#ifndef YY_NO_UNISTD_H
#include <unistd.h>
#endif
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Holds the entire state of the reentrant scanner. */
struct yyguts_t
    {

    /* User-defined. Not touched by flex. */
    YY_EXTRA_TYPE yyextra_r;

    /* The rest are the same as the globals declared in the non-reentrant scanner. */
    FILE *yyin_r, *yyout_r;
    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
    char yy_hold_char;
    int yy_n_chars;
    int yyleng_r;
    char *yy_c_buf_p;
    int yy_init;
    int yy_start;
    int yy_did_buffer_switch_on_eof;
    int yy_start_stack_ptr;
    int yy_start_stack_depth;
    int *yy_start_stack;
    yy_state_type yy_last_accepting_state;
    char* yy_last_accepting_cpos;

    int yylineno_r;
    int yy_flex_debug_r;

    char *yytext_r;
    int yy_more_flag;
    int yy_more_len;

    }; /* end struct yyguts_t */

static int yy_init_globals (yyscan_t yyscanner );

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int turtle_lexer_lex_destroy (yyscan_t yyscanner );

int turtle_lexer_get_debug (yyscan_t yyscanner );

void turtle_lexer_set_debug (int debug_flag ,yyscan_t yyscanner );

YY_EXTRA_TYPE turtle_lexer_get_extra (yyscan_t yyscanner );

void turtle_lexer_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );

FILE *turtle_lexer_get_in (yyscan_t yyscanner );

void turtle_lexer_set_in  (FILE * in_str ,yyscan_t yyscanner );

FILE *turtle_lexer_get_out (yyscan_t yyscanner );

void turtle_lexer_set_out  (FILE * out_str ,yyscan_t yyscanner );

int turtle_lexer_get_leng (yyscan_t yyscanner );

char *turtle_lexer_get_text (yyscan_t yyscanner );

int turtle_lexer_get_lineno (yyscan_t yyscanner );

void turtle_lexer_set_lineno (int line_number ,yyscan_t yyscanner );

/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int turtle_lexer_wrap (yyscan_t yyscanner );
#else
extern int turtle_lexer_wrap (yyscan_t yyscanner );
#endif
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT

#ifdef __cplusplus
static int yyinput (yyscan_t yyscanner );
#else
static int input (yyscan_t yyscanner );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
#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( yyin )) != EOF && c != '\n'; ++n ) \
                  buf[n] = (char) c; \
            if ( c == '\n' ) \
                  buf[n++] = (char) c; \
            if ( c == EOF && ferror( yyin ) ) \
                  YY_FATAL_ERROR( "input in flex scanner failed" ); \
            result = n; \
            } \
      else \
            { \
            errno=0; \
            while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
                  { \
                  if( errno != EINTR) \
                        { \
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
                        break; \
                        } \
                  errno=0; \
                  clearerr(yyin); \
                  } \
            }\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * 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 , yyscanner)
#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 turtle_lexer_lex (yyscan_t yyscanner);

#define YY_DECL int turtle_lexer_lex (yyscan_t yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif

#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;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

#line 150 "./turtle_lexer.l"

  /* rules */

  raptor_parser *rdf_parser=(raptor_parser*)yyextra;
  raptor_turtle_parser* turtle_parser=(raptor_turtle_parser*)rdf_parser->context;

#line 2149 "turtle_lexer.c"

      if ( !yyg->yy_init )
            {
            yyg->yy_init = 1;

#ifdef YY_USER_INIT
            YY_USER_INIT;
#endif

            if ( ! yyg->yy_start )
                  yyg->yy_start = 1;      /* first start state */

            if ( ! yyin )
                  yyin = stdin;

            if ( ! yyout )
                  yyout = stdout;

            if ( ! YY_CURRENT_BUFFER ) {
                  turtle_lexer_ensure_buffer_stack (yyscanner);
                  YY_CURRENT_BUFFER_LVALUE =
                        turtle_lexer__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
            }

            turtle_lexer__load_buffer_state(yyscanner );
            }

      while ( 1 )       /* loops until end-of-file is reached */
            {
            yy_cp = yyg->yy_c_buf_p;

            /* Support of yytext. */
            *yy_cp = yyg->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 = yyg->yy_start;
yy_match:
            do
                  {
                  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                  if ( yy_accept[yy_current_state] )
                        {
                        yyg->yy_last_accepting_state = yy_current_state;
                        yyg->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 >= 624 )
                              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_current_state != 623 );
            yy_cp = yyg->yy_last_accepting_cpos;
            yy_current_state = yyg->yy_last_accepting_state;

yy_find_action:
            yy_act = yy_accept[yy_current_state];

            YY_DO_BEFORE_ACTION;

do_action:  /* This label is used only to access EOF actions. */

            switch ( yy_act )
      { /* beginning of action switch */
                  case 0: /* must back up */
                  /* undo the effects of YY_DO_BEFORE_ACTION */
                  *yy_cp = yyg->yy_hold_char;
                  yy_cp = yyg->yy_last_accepting_cpos;
                  yy_current_state = yyg->yy_last_accepting_state;
                  goto yy_find_action;

case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
#line 156 "./turtle_lexer.l"
{ turtle_parser->lineno++; }
      YY_BREAK
case 2:
YY_RULE_SETUP
#line 158 "./turtle_lexer.l"
{ /* empty */ }
      YY_BREAK
case 3:
YY_RULE_SETUP
#line 161 "./turtle_lexer.l"
{ return A; }
      YY_BREAK
case 4:
YY_RULE_SETUP
#line 163 "./turtle_lexer.l"
{ return DOT; } 
      YY_BREAK
case 5:
YY_RULE_SETUP
#line 164 "./turtle_lexer.l"
{ return COMMA; } 
      YY_BREAK
case 6:
YY_RULE_SETUP
#line 165 "./turtle_lexer.l"
{ return SEMICOLON; }
      YY_BREAK
case 7:
YY_RULE_SETUP
#line 166 "./turtle_lexer.l"
{ return LEFT_SQUARE; }
      YY_BREAK
case 8:
YY_RULE_SETUP
#line 167 "./turtle_lexer.l"
{ return RIGHT_SQUARE; }
      YY_BREAK
case 9:
YY_RULE_SETUP
#line 168 "./turtle_lexer.l"
{ BEGIN(PREF); return PREFIX; }
      YY_BREAK
case 10:
YY_RULE_SETUP
#line 169 "./turtle_lexer.l"
{ return AT; }
      YY_BREAK
case 11:
YY_RULE_SETUP
#line 170 "./turtle_lexer.l"
{ return HAT; }
      YY_BREAK
case 12:
YY_RULE_SETUP
#line 171 "./turtle_lexer.l"
{ return LEFT_ROUND; }
      YY_BREAK
case 13:
YY_RULE_SETUP
#line 172 "./turtle_lexer.l"
{ return RIGHT_ROUND; }
      YY_BREAK
case 14:
YY_RULE_SETUP
#line 173 "./turtle_lexer.l"
{ return TRUE; }
      YY_BREAK
case 15:
YY_RULE_SETUP
#line 174 "./turtle_lexer.l"
{ return FALSE; }
      YY_BREAK
case 16:
YY_RULE_SETUP
#line 177 "./turtle_lexer.l"
{ turtle_parser_lval->string=turtle_copy_string_token(rdf_parser, (unsigned char*)yytext+1, yyleng-2, '\"'); /* ' */
                               return STRING_LITERAL; }
      YY_BREAK
case 17:
YY_RULE_SETUP
#line 180 "./turtle_lexer.l"
{ turtle_parser_lval->string=turtle_copy_string_token(rdf_parser, (unsigned char*)yytext+1, yyleng-2, '"'); /* ' */
                                return STRING_LITERAL; }
      YY_BREAK
case 18:
YY_RULE_SETUP
#line 183 "./turtle_lexer.l"
{ BEGIN(LITERAL); 
                                  turtle_parser->sb=raptor_new_stringbuffer();
                          }
      YY_BREAK
case 19:
YY_RULE_SETUP
#line 187 "./turtle_lexer.l"
{
              size_t len;
     
              BEGIN(INITIAL);
                  len=raptor_stringbuffer_length(turtle_parser->sb);
                  turtle_parser_lval->string=(unsigned char *)RAPTOR_MALLOC(cstring, len+1);
                  raptor_stringbuffer_copy_to_string(turtle_parser->sb, (unsigned char*)turtle_parser_lval->string, len);
                  turtle_parser_lval->string[len]='\0';

                  raptor_free_stringbuffer(turtle_parser->sb);
                  turtle_parser->sb=NULL;
                  return STRING_LITERAL; }
      YY_BREAK
case 20:
/* rule 20 can match eol */
YY_RULE_SETUP
#line 200 "./turtle_lexer.l"
{
              if (*yytext == EOF) {
                    BEGIN(INITIAL);
                    turtle_syntax_error(rdf_parser, "End of file in middle of literal");
                    raptor_free_stringbuffer(turtle_parser->sb);
                    turtle_parser->sb=NULL;
                    return EOF;
                  }

                  if(raptor_stringbuffer_append_turtle_string(turtle_parser->sb, (unsigned char*)yytext, yyleng, '"', (raptor_simple_message_handler)turtle_lexer_syntax_error, rdf_parser)) { /* " */
                    BEGIN(INITIAL);
                    raptor_free_stringbuffer(turtle_parser->sb);
                    turtle_parser->sb=NULL;
                    yyterminate();
                  }
                  
   }
      YY_BREAK
case 21:
YY_RULE_SETUP
#line 218 "./turtle_lexer.l"
{ turtle_parser_lval->string=turtle_copy_token((unsigned char*)yytext+2, yyleng-2);
                          return BLANK_LITERAL; }
      YY_BREAK
case 22:
YY_RULE_SETUP
#line 221 "./turtle_lexer.l"
{ turtle_parser_lval->uri=turtle_qname_to_uri(rdf_parser, (unsigned char*)yytext, yyleng);
                          return QNAME_LITERAL; }
      YY_BREAK
case 23:
YY_RULE_SETUP
#line 224 "./turtle_lexer.l"
{ turtle_parser_lval->string=turtle_copy_token((unsigned char*)yytext, yyleng);
                        return DECIMAL_LITERAL;
}
      YY_BREAK
case 24:
YY_RULE_SETUP
#line 228 "./turtle_lexer.l"
{
                        double d;
                        int n;
                        
                        n=sscanf((const char*)yytext, "%lf", &d);
                        if(n != 1) {
                          turtle_syntax_error(rdf_parser, "TURTLE syntax error - Illegal floating point constant %s", yytext);
                          yyterminate();
                        }
                        turtle_parser_lval->floating=d;
                        return FLOATING_LITERAL;
}
      YY_BREAK
case 25:
YY_RULE_SETUP
#line 241 "./turtle_lexer.l"
{ turtle_parser_lval->integer=atoi(yytext);
                          return INTEGER_LITERAL; }
      YY_BREAK
case 26:
YY_RULE_SETUP
#line 244 "./turtle_lexer.l"
{ /* eat up leading whitespace */ }
      YY_BREAK
case 27:
YY_RULE_SETUP
#line 245 "./turtle_lexer.l"
{ turtle_parser_lval->string=turtle_copy_token((unsigned char*)yytext, yyleng);
                          BEGIN(INITIAL);
                          return IDENTIFIER; }
      YY_BREAK
case 28:
YY_RULE_SETUP
#line 248 "./turtle_lexer.l"
{ BEGIN(INITIAL);
              turtle_parser_lval->string=turtle_copy_token((unsigned char*)yytext, 0);
                  return IDENTIFIER; }
      YY_BREAK
case 29:
/* rule 29 can match eol */
YY_RULE_SETUP
#line 252 "./turtle_lexer.l"
{ BEGIN(INITIAL);
              if (*yytext == EOF)
                    return EOF;

                  turtle_syntax_error(rdf_parser, "syntax error at '%c'", *yytext);
                  yyterminate();  }
      YY_BREAK
case 30:
/* rule 30 can match eol */
YY_RULE_SETUP
#line 260 "./turtle_lexer.l"
{ if(yyleng == 2) 
                turtle_parser_lval->uri=raptor_uri_copy(rdf_parser->base_uri);
              else {
                yytext[yyleng-1]='\0';
                turtle_parser_lval->uri=raptor_new_uri_relative_to_base(rdf_parser->base_uri, (const unsigned char*)yytext+1);
              }
              return URI_LITERAL; }
      YY_BREAK
case 31:
YY_RULE_SETUP
#line 268 "./turtle_lexer.l"
{ turtle_parser_lval->string=turtle_copy_token((unsigned char*)yytext, yyleng);
                          return IDENTIFIER; }
      YY_BREAK
case 32:
/* rule 32 can match eol */
YY_RULE_SETUP
#line 271 "./turtle_lexer.l"
{ /* # comment */
            turtle_parser->lineno++;
                }
      YY_BREAK
case 33:
YY_RULE_SETUP
#line 275 "./turtle_lexer.l"
{ if (*yytext == EOF)
                    return EOF;

                  turtle_syntax_error(rdf_parser, "syntax error at '%c'", *yytext);
                  yyterminate();
            }
      YY_BREAK
case 34:
YY_RULE_SETUP
#line 282 "./turtle_lexer.l"
YY_FATAL_ERROR( "flex scanner jammed" );
      YY_BREAK
#line 2473 "turtle_lexer.c"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(PREF):
case YY_STATE_EOF(LITERAL):
      yyterminate();

      case YY_END_OF_BUFFER:
            {
            /* Amount of text matched not including the EOB char. */
            int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

            /* Undo the effects of YY_DO_BEFORE_ACTION. */
            *yy_cp = yyg->yy_hold_char;
            YY_RESTORE_YY_MORE_OFFSET

            if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                  {
                  /* We're scanning a new file or input source.  It's
                   * possible that this happened because the user
                   * just pointed yyin at a new source and called
                   * turtle_lexer_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.
                   */
                  yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
                  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
                  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                  }

            /* Note that here we test for yy_c_buf_p "<=" to the position
             * of the first EOB in the buffer, since yy_c_buf_p will
             * already have been incremented past the NUL character
             * (since all states make transitions on EOB to the
             * end-of-buffer state).  Contrast this with the test
             * in input().
             */
            if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
                  { /* This was really a NUL. */
                  yy_state_type yy_next_state;

                  yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

                  yy_current_state = yy_get_previous_state( yyscanner );

                  /* 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 , yyscanner);

                  yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

                  if ( yy_next_state )
                        {
                        /* Consume the NUL. */
                        yy_cp = ++yyg->yy_c_buf_p;
                        yy_current_state = yy_next_state;
                        goto yy_match;
                        }

                  else
                        {
                        yy_cp = yyg->yy_last_accepting_cpos;
                        yy_current_state = yyg->yy_last_accepting_state;
                        goto yy_find_action;
                        }
                  }

            else switch ( yy_get_next_buffer( yyscanner ) )
                  {
                  case EOB_ACT_END_OF_FILE:
                        {
                        yyg->yy_did_buffer_switch_on_eof = 0;

                        if ( turtle_lexer_wrap(yyscanner ) )
                              {
                              /* Note: because we've taken care in
                               * yy_get_next_buffer() to have set up
                               * yytext, we can now set up
                               * yy_c_buf_p so that if some total
                               * hoser (like flex itself) wants to
                               * call the scanner after we return the
                               * YY_NULL, it'll still work - another
                               * YY_NULL will get returned.
                               */
                              yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

                              yy_act = YY_STATE_EOF(YY_START);
                              goto do_action;
                              }

                        else
                              {
                              if ( ! yyg->yy_did_buffer_switch_on_eof )
                                    YY_NEW_FILE;
                              }
                        break;
                        }

                  case EOB_ACT_CONTINUE_SCAN:
                        yyg->yy_c_buf_p =
                              yyg->yytext_ptr + yy_amount_of_matched_text;

                        yy_current_state = yy_get_previous_state( yyscanner );

                        yy_cp = yyg->yy_c_buf_p;
                        yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
                        goto yy_match;

                  case EOB_ACT_LAST_MATCH:
                        yyg->yy_c_buf_p =
                        &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

                        yy_current_state = yy_get_previous_state( yyscanner );

                        yy_cp = yyg->yy_c_buf_p;
                        yy_bp = yyg->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 turtle_lexer_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 (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
      register char *source = yyg->yytext_ptr;
      register int number_to_move, i;
      int ret_val;

      if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;

      else
            {
                  int 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) (yyg->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. */
                              turtle_lexer_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
                        }
                  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" );

                  yyg->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]),
                  yyg->yy_n_chars, (size_t) num_to_read );

            YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
            }

      if ( yyg->yy_n_chars == 0 )
            {
            if ( number_to_move == YY_MORE_ADJ )
                  {
                  ret_val = EOB_ACT_END_OF_FILE;
                  turtle_lexer_restart(yyin  ,yyscanner);
                  }

            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;

      yyg->yy_n_chars += number_to_move;
      YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
      YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

      yyg->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 (yyscan_t yyscanner)
{
      register yy_state_type yy_current_state;
      register char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      yy_current_state = yyg->yy_start;

      for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->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] )
                  {
                  yyg->yy_last_accepting_state = yy_current_state;
                  yyg->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 >= 624 )
                        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 , yyscan_t yyscanner)
{
      register int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
      register char *yy_cp = yyg->yy_c_buf_p;

      register YY_CHAR yy_c = 1;
      if ( yy_accept[yy_current_state] )
            {
            yyg->yy_last_accepting_state = yy_current_state;
            yyg->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 >= 624 )
                  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 == 623);

      return yy_is_jam ? 0 : yy_current_state;
}

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int yyinput (yyscan_t yyscanner)
#else
    static int input  (yyscan_t yyscanner)
#endif

{
      int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      *yyg->yy_c_buf_p = yyg->yy_hold_char;

      if ( *yyg->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 ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
                  /* This was really a NUL. */
                  *yyg->yy_c_buf_p = '\0';

            else
                  { /* need more input */
                  int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
                  ++yyg->yy_c_buf_p;

                  switch ( yy_get_next_buffer( yyscanner ) )
                        {
                        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. */
                              turtle_lexer_restart(yyin ,yyscanner);

                              /*FALLTHROUGH*/

                        case EOB_ACT_END_OF_FILE:
                              {
                              if ( turtle_lexer_wrap(yyscanner ) )
                                    return EOF;

                              if ( ! yyg->yy_did_buffer_switch_on_eof )
                                    YY_NEW_FILE;
#ifdef __cplusplus
                              return yyinput(yyscanner);
#else
                              return input(yyscanner);
#endif
                              }

                        case EOB_ACT_CONTINUE_SCAN:
                              yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
                              break;
                        }
                  }
            }

      c = *(unsigned char *) yyg->yy_c_buf_p;   /* cast for 8-bit char's */
      *yyg->yy_c_buf_p = '\0';      /* preserve yytext */
      yyg->yy_hold_char = *++yyg->yy_c_buf_p;

      return c;
}
#endif      /* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void turtle_lexer_restart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      if ( ! YY_CURRENT_BUFFER ){
        turtle_lexer_ensure_buffer_stack (yyscanner);
            YY_CURRENT_BUFFER_LVALUE =
            turtle_lexer__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
      }

      turtle_lexer__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
      turtle_lexer__load_buffer_state(yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param yyscanner The scanner object.
 */
    void turtle_lexer__switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      /* TODO. We should be able to replace this entire function body
       * with
       *          turtle_lexer_pop_buffer_state();
       *          turtle_lexer_push_buffer_state(new_buffer);
     */
      turtle_lexer_ensure_buffer_stack (yyscanner);
      if ( YY_CURRENT_BUFFER == new_buffer )
            return;

      if ( YY_CURRENT_BUFFER )
            {
            /* Flush out information for old buffer. */
            *yyg->yy_c_buf_p = yyg->yy_hold_char;
            YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
            YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
            }

      YY_CURRENT_BUFFER_LVALUE = new_buffer;
      turtle_lexer__load_buffer_state(yyscanner );

      /* We don't actually know whether we did this switch during
       * EOF (turtle_lexer_wrap()) processing, but the only time this flag
       * is looked at is after turtle_lexer_wrap() is called, so it's safe
       * to go ahead and always set it.
       */
      yyg->yy_did_buffer_switch_on_eof = 1;
}

static void turtle_lexer__load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
      yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
      yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
      yyg->yy_hold_char = *yyg->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.
 * @param yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE turtle_lexer__create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
      YY_BUFFER_STATE b;
    
      b = (YY_BUFFER_STATE) turtle_lexer_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
      if ( ! b )
            YY_FATAL_ERROR( "out of dynamic memory in turtle_lexer__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 *) turtle_lexer_alloc(b->yy_buf_size + 2 ,yyscanner );
      if ( ! b->yy_ch_buf )
            YY_FATAL_ERROR( "out of dynamic memory in turtle_lexer__create_buffer()" );

      b->yy_is_our_buffer = 1;

      turtle_lexer__init_buffer(b,file ,yyscanner);

      return b;
}

/** Destroy the buffer.
 * @param b a buffer created with turtle_lexer__create_buffer()
 * @param yyscanner The scanner object.
 */
    void turtle_lexer__delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      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 )
            turtle_lexer_free((void *) b->yy_ch_buf ,yyscanner );

      turtle_lexer_free((void *) b ,yyscanner );
}

/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a turtle_lexer_restart() or at EOF.
 */
    static void turtle_lexer__init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
      int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      turtle_lexer__flush_buffer(b ,yyscanner);

      b->yy_input_file = file;
      b->yy_fill_buffer = 1;

    /* If b is the current buffer, then turtle_lexer__init_buffer was _probably_
     * called from turtle_lexer_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 = 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.
 * @param yyscanner The scanner object.
 */
    void turtle_lexer__flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      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 )
            turtle_lexer__load_buffer_state(yyscanner );
}

/** 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.
 *  @param yyscanner The scanner object.
 */
void turtle_lexer_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      if (new_buffer == NULL)
            return;

      turtle_lexer_ensure_buffer_stack(yyscanner);

      /* This block is copied from turtle_lexer__switch_to_buffer. */
      if ( YY_CURRENT_BUFFER )
            {
            /* Flush out information for old buffer. */
            *yyg->yy_c_buf_p = yyg->yy_hold_char;
            YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
            YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
            }

      /* Only push if top exists. Otherwise, replace top. */
      if (YY_CURRENT_BUFFER)
            yyg->yy_buffer_stack_top++;
      YY_CURRENT_BUFFER_LVALUE = new_buffer;

      /* copied from turtle_lexer__switch_to_buffer. */
      turtle_lexer__load_buffer_state(yyscanner );
      yyg->yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param yyscanner The scanner object.
 */
void turtle_lexer_pop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      if (!YY_CURRENT_BUFFER)
            return;

      turtle_lexer__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
      YY_CURRENT_BUFFER_LVALUE = NULL;
      if (yyg->yy_buffer_stack_top > 0)
            --yyg->yy_buffer_stack_top;

      if (YY_CURRENT_BUFFER) {
            turtle_lexer__load_buffer_state(yyscanner );
            yyg->yy_did_buffer_switch_on_eof = 1;
      }
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void turtle_lexer_ensure_buffer_stack (yyscan_t yyscanner)
{
      int num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

      if (!yyg->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;
            yyg->yy_buffer_stack = (struct yy_buffer_state**)turtle_lexer_alloc
                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                                , yyscanner);
            
            memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                        
            yyg->yy_buffer_stack_max = num_to_alloc;
            yyg->yy_buffer_stack_top = 0;
            return;
      }

      if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

            /* Increase the buffer to prepare for a possible push. */
            int grow_size = 8 /* arbitrary grow size */;

            num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
            yyg->yy_buffer_stack = (struct yy_buffer_state**)turtle_lexer_realloc
                                                (yyg->yy_buffer_stack,
                                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                                , yyscanner);

            /* zero only the new slots.*/
            memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
            yyg->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
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object. 
 */
YY_BUFFER_STATE turtle_lexer__scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
{
      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) turtle_lexer_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
      if ( ! b )
            YY_FATAL_ERROR( "out of dynamic memory in turtle_lexer__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;

      turtle_lexer__switch_to_buffer(b ,yyscanner );

      return b;
}

/** Setup the input buffer state to scan a string. The next call to turtle_lexer_lex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       turtle_lexer__scan_bytes() instead.
 */
YY_BUFFER_STATE turtle_lexer__scan_string (yyconst char * yystr , yyscan_t yyscanner)
{
    
      return turtle_lexer__scan_bytes(yystr,strlen(yystr) ,yyscanner);
}

/** Setup the input buffer state to scan the given bytes. The next call to turtle_lexer_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.
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE turtle_lexer__scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
{
      YY_BUFFER_STATE b;
      char *buf;
      yy_size_t n;
      int i;
    
      /* Get memory for full buffer, including space for trailing EOB's. */
      n = _yybytes_len + 2;
      buf = (char *) turtle_lexer_alloc(n ,yyscanner );
      if ( ! buf )
            YY_FATAL_ERROR( "out of dynamic memory in turtle_lexer__scan_bytes()" );

      for ( i = 0; i < _yybytes_len; ++i )
            buf[i] = yybytes[i];

      buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

      b = turtle_lexer__scan_buffer(buf,n ,yyscanner);
      if ( ! b )
            YY_FATAL_ERROR( "bad buffer in turtle_lexer__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;
}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
{
      (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 yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
            yytext[yyleng] = yyg->yy_hold_char; \
            yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
            yyg->yy_hold_char = *yyg->yy_c_buf_p; \
            *yyg->yy_c_buf_p = '\0'; \
            yyleng = yyless_macro_arg; \
            } \
      while ( 0 )

/* Accessor  methods (get/set functions) to struct members. */

/** Get the user-defined data for this scanner.
 * @param yyscanner The scanner object.
 */
YY_EXTRA_TYPE turtle_lexer_get_extra  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

/** Get the current line number.
 * @param yyscanner The scanner object.
 */
int turtle_lexer_get_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    
        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

/** Get the current column number.
 * @param yyscanner The scanner object.
 */
int turtle_lexer_get_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    
        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

/** Get the input stream.
 * @param yyscanner The scanner object.
 */
FILE *turtle_lexer_get_in  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

/** Get the output stream.
 * @param yyscanner The scanner object.
 */
FILE *turtle_lexer_get_out  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

/** Get the length of the current token.
 * @param yyscanner The scanner object.
 */
int turtle_lexer_get_leng  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

/** Get the current token.
 * @param yyscanner The scanner object.
 */

char *turtle_lexer_get_text  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * @param yyscanner The scanner object.
 */
void turtle_lexer_set_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

/** Set the current line number.
 * @param line_number
 * @param yyscanner The scanner object.
 */
void turtle_lexer_set_lineno (int  line_number , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           yy_fatal_error( "turtle_lexer_set_lineno called with no buffer" , yyscanner); 
    
    yylineno = line_number;
}

/** Set the current column.
 * @param line_number
 * @param yyscanner The scanner object.
 */
void turtle_lexer_set_column (int  column_no , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           yy_fatal_error( "turtle_lexer_set_column called with no buffer" , yyscanner); 
    
    yycolumn = column_no;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param in_str A readable stream.
 * @param yyscanner The scanner object.
 * @see turtle_lexer__switch_to_buffer
 */
void turtle_lexer_set_in (FILE *  in_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = in_str ;
}

void turtle_lexer_set_out (FILE *  out_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = out_str ;
}

int turtle_lexer_get_debug  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

void turtle_lexer_set_debug (int  bdebug , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = bdebug ;
}

/* Accessor methods for yylval and yylloc */

/* User-visible API */

/* turtle_lexer_lex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */

int turtle_lexer_lex_init(yyscan_t* ptr_yy_globals)

{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) turtle_lexer_alloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

static int yy_init_globals (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from turtle_lexer_lex_destroy(), so don't allocate here.
     */

    yyg->yy_buffer_stack = 0;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = (char *) 0;
    yyg->yy_init = 0;
    yyg->yy_start = 0;

    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = (FILE *) 0;
    yyout = (FILE *) 0;
#endif

    /* For future reference: Set errno on error, since we are called by
     * turtle_lexer_lex_init()
     */
    return 0;
}

/* turtle_lexer_lex_destroy is for both reentrant and non-reentrant scanners. */
int turtle_lexer_lex_destroy  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    /* Pop the buffer stack, destroying each element. */
      while(YY_CURRENT_BUFFER){
            turtle_lexer__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
            YY_CURRENT_BUFFER_LVALUE = NULL;
            turtle_lexer_pop_buffer_state(yyscanner);
      }

      /* Destroy the stack itself. */
      turtle_lexer_free(yyg->yy_buffer_stack ,yyscanner);
      yyg->yy_buffer_stack = NULL;

    /* Destroy the start condition stack. */
        turtle_lexer_free(yyg->yy_start_stack ,yyscanner );
        yyg->yy_start_stack = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * turtle_lexer_lex() is called, initialization will occur. */
    yy_init_globals( yyscanner);

    /* Destroy the main struct (reentrant only). */
    turtle_lexer_free ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

/*
 * Internal utility routines.
 */

#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
{
      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 , yyscan_t yyscanner)
{
      register int n;
      for ( n = 0; s[n]; ++n )
            ;

      return n;
}
#endif

void *turtle_lexer_alloc (yy_size_t  size , yyscan_t yyscanner)
{
      return (void *) malloc( size );
}

void *turtle_lexer_realloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
{
      /* 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 turtle_lexer_free (void * ptr , yyscan_t yyscanner)
{
      if(ptr) free( (char *) ptr ); /* see turtle_lexer_realloc() for (char *) cast */
}

#define YYTABLES_NAME "yytables"

#line 282 "./turtle_lexer.l"


  /* user code */

int
turtle_lexer_wrap (yyscan_t yyscanner) {
  return 1;
}


static unsigned char *
turtle_copy_token(unsigned char *text, size_t len)
{
  unsigned char *s;
  if(!len)
    len=strlen((const char*)text);
  s=(unsigned char *)RAPTOR_MALLOC(cstring, len+1);

  strncpy((char*)s, (const char*)text, len);
  s[len] = '\0';
  return s;
}


static unsigned char *
turtle_copy_string_token(raptor_parser* rdf_parser, 
                         unsigned char *string, size_t len, int delim)
{
  raptor_stringbuffer* sb=NULL;
  int rc;
  
  if(len) {
    sb=raptor_new_stringbuffer();
    if(!sb)
      return NULL;
    
    rc=raptor_stringbuffer_append_turtle_string(sb, string, len, delim,
                                                (raptor_simple_message_handler)turtle_lexer_syntax_error,
                                                rdf_parser);
    if(rc) {
      raptor_free_stringbuffer(sb);
      return NULL;
    }

    len=raptor_stringbuffer_length(sb);
  }
  
  string=(unsigned char *)RAPTOR_MALLOC(cstring, len+1);

  if(sb) {
    raptor_stringbuffer_copy_to_string(sb, string, len+1);
    raptor_free_stringbuffer(sb);
  }
  string[len]='\0';
  
  return string;
}


void
turtle_lexer_syntax_error(void* ctx, const char *message, ...)
{
  raptor_parser* rdf_parser=(raptor_parser *)ctx;
  raptor_turtle_parser* turtle_parser=(raptor_turtle_parser*)rdf_parser->context;
  va_list arguments;
  
  rdf_parser->locator.line=turtle_parser->lineno;
#ifdef RAPTOR_TURTLE_USE_ERROR_COLUMNS
  rdf_parser->locator.column=turtle_lexer_get_column(yyscanner);
#endif

  va_start(arguments, message);
  raptor_parser_error_varargs(((raptor_parser*)rdf_parser), message, arguments);

  va_end(arguments);
}


#ifdef RAPTOR_DEBUG

const char *
turtle_token_print(int token, YYSTYPE *lval)
{
  static char buffer[2048];

  if(!token)
    return "<<EOF>>";
  
  switch(token) {
    case PREFIX:
      return "PREFIX";

    case A:
      return "A";

    case DOT:
      return "DOT";

    case COMMA:
      return "COMMA";

    case SEMICOLON:
      return "SEMICOLON";

    case LEFT_SQUARE:
      return "LEFT_SQUARE";

    case RIGHT_SQUARE:
      return "RIGHT_SQUARE";

    case AT:
      return "AT";

    case HAT:
      return "HAT";

    case STRING_LITERAL:
      sprintf(buffer, "STRING_LITERAL(%s)", lval->string);
      return buffer;

    case URI_LITERAL:
      sprintf(buffer, "URI_LITERAL(%s)", 
              (lval->uri ? (char*)raptor_uri_as_string(lval->uri) : ""));
      return buffer;

    case BLANK_LITERAL:
      sprintf(buffer, "BLANK_LITERAL(%s)", lval->string);
      return buffer;

    case QNAME_LITERAL:
      sprintf(buffer, "QNAME_LITERAL(%s)", 
              (lval->uri ? (char*)raptor_uri_as_string(lval->uri) : ""));
      return buffer;

    case INTEGER_LITERAL:
      sprintf(buffer, "INTEGER_LITERAL(%d)", lval->integer);
      return buffer;

    case FLOATING_LITERAL:
      sprintf(buffer, "FLOATING_LITERAL(%1g)", lval->floating);
      return buffer;

    case IDENTIFIER:
      sprintf(buffer, "IDENTIFIER(%s)", 
              (lval->string ? (char*)lval->string : ""));
      return buffer;

    case DECIMAL_LITERAL:
      sprintf(buffer, "DECIMAL_LITERAL(%s)", lval->string);
      return buffer;

    case ERROR_TOKEN:
      return "ERROR";

   default:
     fprintf(stderr, "turtle_token_print: UNKNOWN token %d - add a new case\n", token);
     abort();
  }
}
#endif



#ifdef STANDALONE

static void
turtle_token_free(int token, YYSTYPE *lval)
{
  if(!token)
    return;

  switch(token) {
    case STRING_LITERAL:
    case BLANK_LITERAL:
    case IDENTIFIER:
      if(lval->string)
        RAPTOR_FREE(cstring, lval->string);
      break;

    case URI_LITERAL:
    case QNAME_LITERAL:
      if(lval->uri)
        raptor_free_uri(lval->uri);
      break;
    default:
      break;
  }
}


int
main(int argc, char *argv[]) 
{
  raptor_parser rdf_parser;
  raptor_turtle_parser turtle_parser;
  yyscan_t scanner;
  int token=EOF;
  FILE *fh;
  YYSTYPE lval;
  const unsigned char *uri_string;
  char *filename=NULL;
  
  raptor_init();
  
  if(argc > 1) {
    filename=argv[1];
    fh=fopen(filename, "r");
    if(!fh) {
      fprintf(stderr, "%s: Cannot open file %s - %s\n", argv[0], filename,
              strerror(errno));
      exit(1);
    }
  } else {
    filename="<stdin>";
    fh=stdin;
  }

  memset(&rdf_parser, 0, sizeof(raptor_parser));
  memset(&turtle_parser, 0, sizeof(raptor_turtle_parser));

  turtle_lexer_lex_init(&turtle_parser.scanner);
  scanner=turtle_parser.scanner;
  turtle_lexer_set_in(fh, scanner);
  turtle_lexer_set_extra(&rdf_parser, scanner);

  /* Initialise enough of the parser and locator to get error messages */
  rdf_parser.context=&turtle_parser;
  turtle_parser.lineno=1;
  rdf_parser.locator.file=filename;
  rdf_parser.locator.column= -1;

  uri_string=raptor_uri_filename_to_uri_string(filename);
  rdf_parser.base_uri=raptor_new_uri(uri_string);
  RAPTOR_FREE(cstring, (void*)uri_string);
  
  while(1) {
    memset(&lval, 0, sizeof(YYSTYPE));
    if(turtle_lexer_get_text(scanner) != NULL)
      printf("yyinput '%s'\n", turtle_lexer_get_text(scanner));
    token=turtle_lexer_lex(&lval,scanner);
#ifdef RAPTOR_DEBUG
    printf("token %s\n", turtle_token_print(token, &lval));
#else
    printf("token %d\n", token);
#endif
    turtle_token_free(token, &lval);
    if(!token || token == EOF || token == ERROR_TOKEN)
      break;
  }

  turtle_lexer_lex_destroy(scanner);

  raptor_free_uri(rdf_parser.base_uri);

  raptor_finish();


  if(token == ERROR_TOKEN)
    return 1;
 
  return 0;
}
#endif


Generated by  Doxygen 1.6.0   Back to index