#define YYBISON 1

#define YYBISON_VERSION "3.0.4"

#define YYSKELETON_NAME "yacc.c"

#define YYPURE 2

#define YYPUSH 0

#define YYPULL 1

#define YYSTYPE HSQL_STYPE

#define YYLTYPE HSQL_LTYPE

#define yyparse hsql_parse

#define yylex hsql_lex

#define yyerror hsql_error

#define yydebug hsql_debug

#define yynerrs hsql_nerrs

#line 1 "bison_parser.y" /* yacc.c:339 */

#include "bison_parser.h"

#include "flex_lexer.h"

#include <stdio.h>

using namespace hsql;

int yyerror(YYLTYPE* llocp, SQLParserResult** result, yyscan_t scanner, const char *msg) {

}

#line 109 "bison_parser.cpp" /* yacc.c:339 */

# ifndef YY_NULLPTR

# if defined __cplusplus && 201103L <= __cplusplus

# define YY_NULLPTR nullptr

# else

# define YY_NULLPTR 0

# endif

# endif

#ifdef YYERROR_VERBOSE

# undef YYERROR_VERBOSE

# define YYERROR_VERBOSE 1

#else

# define YYERROR_VERBOSE 1

#endif

#ifndef YY_HSQL_BISON_PARSER_H_INCLUDED

# define YY_HSQL_BISON_PARSER_H_INCLUDED

#ifndef HSQL_DEBUG

# if defined YYDEBUG

#if YYDEBUG

# define HSQL_DEBUG 1

# else

# define HSQL_DEBUG 0

# endif

# else /* ! defined YYDEBUG */

# define HSQL_DEBUG 0

# endif /* ! defined YYDEBUG */

#endif /* ! defined HSQL_DEBUG */

#if HSQL_DEBUG

extern int hsql_debug;

#endif

#line 41 "bison_parser.y" /* yacc.c:355 */

#include "../sql/statements.h"

#include "../SQLParserResult.h"

#include "parser_typedef.h"

#define YY_USER_ACTION \

yylloc->first_line = yylloc->last_line; \

yylloc->first_column = yylloc->last_column; \

for(int i = 0; yytext[i] != '\0'; i++) { \

yylloc->total_column++; \

if(yytext[i] == '\n') { \

yylloc->last_line++; \

yylloc->last_column = 0; \

} \

else { \

yylloc->last_column++; \

} \

}

#line 170 "bison_parser.cpp" /* yacc.c:355 */

#ifndef HSQL_TOKENTYPE

# define HSQL_TOKENTYPE

enum hsql_tokentype

};

#endif

#if ! defined HSQL_STYPE && ! defined HSQL_STYPE_IS_DECLARED

union HSQL_STYPE

{

#line 100 "bison_parser.y" /* yacc.c:355 */

double fval;

int64_t ival;

char* sval;

uintmax_t uval;

bool bval;

hsql::SQLStatement* statement;

hsql::SelectStatement* select_stmt;

hsql::ImportStatement* import_stmt;

hsql::CreateStatement* create_stmt;

hsql::InsertStatement* insert_stmt;

hsql::DeleteStatement* delete_stmt;

hsql::UpdateStatement* update_stmt;

hsql::DropStatement* drop_stmt;

hsql::PrepareStatement* prep_stmt;

hsql::ExecuteStatement* exec_stmt;

hsql::TableRef* table;

hsql::Expr* expr;

hsql::OrderDescription* order;

hsql::OrderType order_type;

hsql::LimitDescription* limit;

hsql::ColumnDefinition* column_t;

hsql::GroupByDescription* group_t;

hsql::UpdateClause* update_t;

hsql::SQLParserResult* stmt_list;

std::vector<char*>* str_vec;

std::vector<hsql::TableRef*>* table_vec;

std::vector<hsql::ColumnDefinition*>* column_vec;

std::vector<hsql::UpdateClause*>* update_vec;

std::vector<hsql::Expr*>* expr_vec;

std::vector<hsql::OrderDescription*>* order_vec;

#line 350 "bison_parser.cpp" /* yacc.c:355 */

};

typedef union HSQL_STYPE HSQL_STYPE;

# define HSQL_STYPE_IS_TRIVIAL 1

# define HSQL_STYPE_IS_DECLARED 1

#endif

#if ! defined HSQL_LTYPE && ! defined HSQL_LTYPE_IS_DECLARED

typedef struct HSQL_LTYPE HSQL_LTYPE;

struct HSQL_LTYPE

};

# define HSQL_LTYPE_IS_DECLARED 1

# define HSQL_LTYPE_IS_TRIVIAL 1

#endif

int hsql_parse (hsql::SQLParserResult** result, yyscan_t scanner);

#endif /* !YY_HSQL_BISON_PARSER_H_INCLUDED */

#line 380 "bison_parser.cpp" /* yacc.c:358 */

#ifdef short

# undef short

#endif

#ifdef YYTYPE_UINT8

typedef YYTYPE_UINT8 yytype_uint8;

#else

typedef unsigned char yytype_uint8;

#endif

#ifdef YYTYPE_INT8

typedef YYTYPE_INT8 yytype_int8;

#else

typedef signed char yytype_int8;

#endif

#ifdef YYTYPE_UINT16

typedef YYTYPE_UINT16 yytype_uint16;

#else

typedef unsigned short int yytype_uint16;

#endif

#ifdef YYTYPE_INT16

typedef YYTYPE_INT16 yytype_int16;

#else

typedef short int yytype_int16;

#endif

#ifndef YYSIZE_T

# ifdef __SIZE_TYPE__

# define YYSIZE_T __SIZE_TYPE__

# elif defined size_t

# define YYSIZE_T size_t

# elif ! defined YYSIZE_T

# include <stddef.h> /* INFRINGES ON USER NAME SPACE */

# define YYSIZE_T size_t

# else

# define YYSIZE_T unsigned int

# endif

#endif

#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

#ifndef YY_

# if defined YYENABLE_NLS && YYENABLE_NLS

# if ENABLE_NLS

# include <libintl.h> /* INFRINGES ON USER NAME SPACE */

# define YY_(Msgid) dgettext ("bison-runtime", Msgid)

# endif

# endif

# ifndef YY_

# define YY_(Msgid) Msgid

# endif

#endif

#ifndef YY_ATTRIBUTE

# if (defined __GNUC__ \

&& (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \

|| defined __SUNPRO_C && 0x5110 <= __SUNPRO_C

# define YY_ATTRIBUTE(Spec) __attribute__(Spec)

# else

# define YY_ATTRIBUTE(Spec) /* empty */

# endif

#endif

#ifndef YY_ATTRIBUTE_PURE

# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))

#endif

#ifndef YY_ATTRIBUTE_UNUSED

# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))

#endif

#if !defined _Noreturn \

&& (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)

# if defined _MSC_VER && 1200 <= _MSC_VER

# define _Noreturn __declspec (noreturn)

# else

# define _Noreturn YY_ATTRIBUTE ((__noreturn__))

# endif

#endif

#if ! defined lint || defined __GNUC__

# define YYUSE(E) ((void) (E))

#else

# define YYUSE(E) /* empty */

#endif

#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__

# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \

_Pragma ("GCC diagnostic push") \

_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\

_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")

# define YY_IGNORE_MAYBE_UNINITIALIZED_END \

_Pragma ("GCC diagnostic pop")

#else

# define YY_INITIAL_VALUE(Value) Value

#endif

#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

# define YY_IGNORE_MAYBE_UNINITIALIZED_END

#endif

#ifndef YY_INITIAL_VALUE

# define YY_INITIAL_VALUE(Value) /* Nothing. */

#endif

#if ! defined yyoverflow || YYERROR_VERBOSE

# ifdef YYSTACK_USE_ALLOCA

# if YYSTACK_USE_ALLOCA

# ifdef __GNUC__

# define YYSTACK_ALLOC __builtin_alloca

# elif defined __BUILTIN_VA_ARG_INCR

# include <alloca.h> /* INFRINGES ON USER NAME SPACE */

# elif defined _AIX

# define YYSTACK_ALLOC __alloca

# elif defined _MSC_VER

# include <malloc.h> /* INFRINGES ON USER NAME SPACE */

# define alloca _alloca

# else

# define YYSTACK_ALLOC alloca

# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS

# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

/* Use EXIT_SUCCESS as a witness for stdlib.h. */

# ifndef EXIT_SUCCESS

# define EXIT_SUCCESS 0

# endif

# endif

# endif

# endif

# endif

# ifdef YYSTACK_ALLOC

/* Pacify GCC's 'empty if-body' warning. */

# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)

# ifndef YYSTACK_ALLOC_MAXIMUM

/* The OS might guarantee only one guard page at the bottom of the stack,

# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */

# endif

# else

# define YYSTACK_ALLOC YYMALLOC

# define YYSTACK_FREE YYFREE

# ifndef YYSTACK_ALLOC_MAXIMUM

# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM

# endif

# if (defined __cplusplus && ! defined EXIT_SUCCESS \

&& ! ((defined YYMALLOC || defined malloc) \

&& (defined YYFREE || defined free)))

# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

# ifndef EXIT_SUCCESS

# define EXIT_SUCCESS 0

# endif

# endif

# ifndef YYMALLOC

# define YYMALLOC malloc

# if ! defined malloc && ! defined EXIT_SUCCESS

void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */

# endif

# endif

# ifndef YYFREE

# define YYFREE free

# if ! defined free && ! defined EXIT_SUCCESS

void free (void *); /* INFRINGES ON USER NAME SPACE */

# endif

# endif

# endif

#endif /* ! defined yyoverflow || YYERROR_VERBOSE */

#if (! defined yyoverflow \

&& (! defined __cplusplus \

|| (defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL \

&& defined HSQL_STYPE_IS_TRIVIAL && HSQL_STYPE_IS_TRIVIAL)))

union yyalloc

{

yytype_int16 yyss_alloc;

YYSTYPE yyvs_alloc;

YYLTYPE yyls_alloc;

};

# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

# define YYSTACK_BYTES(N) \

((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \

+ 2 * YYSTACK_GAP_MAXIMUM)

# define YYCOPY_NEEDED 1

# define YYSTACK_RELOCATE(Stack_alloc, Stack) \

do \

{ \

YYSIZE_T yynewbytes; \

YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \

Stack = &yyptr->Stack_alloc; \

yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

yyptr += yynewbytes / sizeof (*yyptr); \

} \

while (0)

#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED

# ifndef YYCOPY

# if defined __GNUC__ && 1 < __GNUC__

# define YYCOPY(Dst, Src, Count) \

__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))

# else

# define YYCOPY(Dst, Src, Count) \

do \

{ \

YYSIZE_T yyi; \

for (yyi = 0; yyi < (Count); yyi++) \

(Dst)[yyi] = (Src)[yyi]; \

} \

while (0)

# endif

# endif

#endif /* !YYCOPY_NEEDED */

#define YYFINAL 48

#define YYLAST 457

#define YYNTOKENS 151

#define YYNNTS 76

#define YYNRULES 172

#define YYNSTATES 322

#define YYUNDEFTOK 2

#define YYMAXUTOK 385

#define YYTRANSLATE(YYX) \

((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

static const yytype_uint8 yytranslate[] =

{

0, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 137, 2, 2,

142, 143, 135, 133, 149, 134, 144, 136, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 146, 145,

128, 126, 129, 150, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 140, 2, 141, 138, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 147, 2, 148, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 1, 2, 3, 4,

5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 26, 27, 28, 29, 30, 31, 32, 33, 34,

35, 36, 37, 38, 39, 40, 41, 42, 43, 44,

45, 46, 47, 48, 49, 50, 51, 52, 53, 54,

55, 56, 57, 58, 59, 60, 61, 62, 63, 64,

65, 66, 67, 68, 69, 70, 71, 72, 73, 74,

75, 76, 77, 78, 79, 80, 81, 82, 83, 84,

85, 86, 87, 88, 89, 90, 91, 92, 93, 94,

95, 96, 97, 98, 99, 100, 101, 102, 103, 104,

105, 106, 107, 108, 109, 110, 111, 112, 113, 114,

115, 116, 117, 118, 119, 120, 121, 122, 123, 124,

125, 127, 130, 131, 132, 139

};

#if HSQL_DEBUG

/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */

static const yytype_uint16 yyrline[] =

{

0, 245, 245, 252, 253, 257, 262, 267, 268, 269,

270, 271, 272, 273, 274, 275, 283, 288, 296, 300,

312, 320, 324, 334, 340, 346, 356, 357, 361, 362,

366, 373, 374, 375, 376, 386, 390, 394, 406, 414,

426, 432, 442, 443, 453, 462, 463, 467, 479, 480,

484, 485, 489, 499, 513, 527, 528, 529, 533, 545,

546, 550, 554, 559, 560, 564, 569, 573, 574, 577,

578, 582, 583, 587, 591, 592, 593, 599, 600, 604,

605, 606, 613, 614, 618, 619, 623, 630, 631, 632,

633, 634, 635, 639, 640, 641, 642, 643, 644, 648,

649, 650, 654, 655, 659, 660, 661, 662, 663, 664,

665, 666, 667, 671, 672, 676, 677, 678, 679, 684,

688, 689, 693, 694, 695, 696, 697, 698, 702, 706,

710, 711, 715, 716, 717, 721, 726, 727, 731, 735,

739, 750, 751, 761, 762, 768, 773, 774, 779, 789,

797, 798, 803, 804, 808, 809, 817, 829, 830, 831,

832, 833, 834, 835, 836, 837, 843, 849, 853, 862,

863, 868, 869

};

#endif

#if HSQL_DEBUG || YYERROR_VERBOSE || 1

static const char *const yytname[] =

{

"$end", "error", "$undefined", "IDENTIFIER", "STRING", "FLOATVAL",

"INTVAL", "NOTEQUALS", "LESSEQ", "GREATEREQ", "DEALLOCATE", "PARAMETERS",

"INTERSECT", "TEMPORARY", "TIMESTAMP", "DISTINCT", "NVARCHAR",

"RESTRICT", "TRUNCATE", "ANALYZE", "BETWEEN", "CASCADE", "COLUMNS",

"CONTROL", "DEFAULT", "EXECUTE", "EXPLAIN", "HISTORY", "INTEGER",

"NATURAL", "PREPARE", "PRIMARY", "SCHEMAS", "SPATIAL", "VIRTUAL",

"BEFORE", "COLUMN", "CREATE", "DELETE", "DIRECT", "DOUBLE", "ESCAPE",

"EXCEPT", "EXISTS", "GLOBAL", "HAVING", "IMPORT", "INSERT", "ISNULL",

"OFFSET", "RENAME", "SCHEMA", "SELECT", "SORTED", "TABLES", "UNIQUE",

"UNLOAD", "UPDATE", "VALUES", "AFTER", "ALTER", "CROSS", "DELTA",

"GROUP", "INDEX", "INNER", "LIMIT", "LOCAL", "MERGE", "MINUS", "ORDER",

"OUTER", "RIGHT", "TABLE", "UNION", "USING", "WHERE", "CALL", "CASE",

"DATE", "DESC", "DROP", "ELSE", "FILE", "FROM", "FULL", "HASH", "HINT",

"INTO", "JOIN", "LEFT", "LIKE", "LOAD", "NULL", "PART", "PLAN", "SHOW",

"TEXT", "THEN", "TIME", "VIEW", "WHEN", "WITH", "ADD", "ALL", "AND",

"ASC", "CSV", "END", "FOR", "INT", "KEY", "NOT", "OFF", "SET", "TBL",

"TOP", "AS", "BY", "IF", "IN", "IS", "OF", "ON", "OR", "TO", "'='",

"EQUALS", "'<'", "'>'", "LESS", "GREATER", "NOTNULL", "'+'", "'-'",

"'*'", "'/'", "'%'", "'^'", "UMINUS", "'['", "']'", "'('", "')'", "'.'",

"';'", "':'", "'{'", "'}'", "','", "'?'", "$accept", "input",

"statement_list", "statement", "preparable_statement",

"prepare_statement", "execute_statement", "import_statement",

"import_file_type", "file_path", "create_statement", "opt_not_exists",

"column_def_commalist", "column_def", "column_type", "drop_statement",

"delete_statement", "truncate_statement", "insert_statement",

"opt_column_list", "update_statement", "update_clause_commalist",

"update_clause", "select_statement", "select_with_paren",

"select_no_paren", "set_operator", "select_clause", "opt_distinct",

"select_list", "from_clause", "opt_where", "opt_group", "opt_having",

"opt_order", "order_list", "order_desc", "opt_order_type", "opt_top",

"opt_limit", "expr_list", "literal_list", "expr_alias", "expr",

"operand", "scalar_expr", "unary_expr", "binary_expr", "logic_expr",

"in_expr", "case_expr", "exists_expr", "comp_expr", "function_expr",

"between_expr", "column_name", "literal", "string_literal",

"num_literal", "int_literal", "star_expr", "placeholder_expr",

"table_ref", "table_ref_atomic", "table_ref_commalist", "table_ref_name",

"table_ref_name_no_alias", "table_name", "alias", "opt_alias",

"join_clause", "opt_join_type", "join_table", "join_condition",

"opt_semicolon", "ident_commalist", YY_NULLPTR

};

#endif

# ifdef YYPRINT

static const yytype_uint16 yytoknum[] =

{

0, 256, 257, 258, 259, 260, 261, 262, 263, 264,

265, 266, 267, 268, 269, 270, 271, 272, 273, 274,

275, 276, 277, 278, 279, 280, 281, 282, 283, 284,

285, 286, 287, 288, 289, 290, 291, 292, 293, 294,

295, 296, 297, 298, 299, 300, 301, 302, 303, 304,

305, 306, 307, 308, 309, 310, 311, 312, 313, 314,

315, 316, 317, 318, 319, 320, 321, 322, 323, 324,

325, 326, 327, 328, 329, 330, 331, 332, 333, 334,

335, 336, 337, 338, 339, 340, 341, 342, 343, 344,

345, 346, 347, 348, 349, 350, 351, 352, 353, 354,

355, 356, 357, 358, 359, 360, 361, 362, 363, 364,

365, 366, 367, 368, 369, 370, 371, 372, 373, 374,

375, 376, 377, 378, 379, 380, 61, 381, 60, 62,

382, 383, 384, 43, 45, 42, 47, 37, 94, 385,

91, 93, 40, 41, 46, 59, 58, 123, 125, 44,

63

};

# endif

#define YYPACT_NINF -248

#define yypact_value_is_default(Yystate) \

(!!((Yystate) == (-248)))

#define YYTABLE_NINF -168

#define yytable_value_is_error(Yytable_value) \

(!!((Yytable_value) == (-168)))

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

static const yytype_int16 yypact[] =

{

169, 1, 53, 68, 91, -57, 19, 45, 38, 15,

53, 37, -37, 118, -7, -248, -248, -248, -248, -248,

-248, -248, -248, -248, -248, -248, -248, -248, -248, 66,

140, 32, -248, 5, 43, 27, 27, 53, 50, 53,

146, 154, 72, -248, 53, 53, 52, 59, -248, 169,

-248, -248, -248, 99, -248, -37, 156, -248, 216, 13,

202, 169, 116, 53, 53, 161, -248, 158, 102, -248,

-248, -248, 46, 242, -248, -248, -248, -248, -248, 46,

177, 177, 146, -248, -248, -248, -248, -248, -29, -248,

-248, -248, -248, -248, -248, -7, 215, -50, 102, 46,

-248, 256, 258, 55, -104, 120, 162, 63, 20, -248,

96, 185, 119, -248, 4, 164, -248, -248, -248, -248,

-248, -248, -248, -248, -248, -248, -248, -248, -248, 144,

-54, -248, 122, -248, 105, 156, 156, 224, -248, 13,

126, -248, 163, 274, 168, -69, 191, -248, -248, -26,

145, -248, 154, 283, 236, 46, 149, 20, 257, 30,

160, 6, 2, 161, 46, -248, 46, 302, 46, -248,

-248, 20, 20, 20, 20, 20, -61, 167, 20, 20,

20, 20, 20, 20, 20, 20, 20, 13, 242, -248,

46, -248, -248, -248, -248, -248, 146, -248, -248, 223,

25, -16, -248, -37, 53, -248, 320, 13, 46, -248,

181, -63, 236, 234, -248, -248, -37, -248, 178, 153,

8, -248, 367, 263, -248, -248, -248, 226, 273, 286,

286, 184, 273, 20, 186, 96, 273, 286, 286, 30,

30, 192, 192, 192, -248, -248, -248, -248, -248, 256,

-248, -248, -248, -248, -248, -248, 274, -248, -248, -248,

7, 10, -248, 20, 193, 195, 2, -248, -248, -248,

-248, -248, 268, 269, 240, 227, -248, 20, 273, 96,

198, 34, -248, -248, -248, -248, 225, -248, 8, -248,

194, -248, -248, 3, 46, 257, 199, 60, -248, -248,

20, 243, -248, 2, -37, -248, 211, -33, -248, -248,

244, -248, 203, 46, 46, -248, -248, 8, -69, -248,

-69, -248

};

/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.

static const yytype_uint8 yydefact[] =

{

0, 0, 0, 0, 0, 0, 0, 0, 0, 78,

0, 0, 0, 0, 170, 3, 6, 5, 15, 8,

9, 14, 11, 12, 10, 13, 7, 48, 49, 70,

0, 150, 39, 18, 0, 27, 27, 0, 0, 0,

0, 60, 0, 149, 0, 0, 0, 0, 1, 169,

2, 56, 57, 0, 55, 0, 81, 37, 0, 0,

0, 0, 0, 0, 0, 64, 21, 0, 43, 138,

77, 59, 0, 0, 35, 36, 51, 50, 4, 0,

70, 70, 0, 52, 151, 135, 136, 140, 0, 84,

132, 133, 137, 134, 16, 170, 0, 0, 43, 0,

38, 0, 0, 0, 130, 0, 0, 0, 0, 139,

0, 0, 61, 82, 155, 87, 94, 95, 96, 89,

92, 91, 90, 104, 97, 88, 99, 101, 100, 0,

64, 45, 69, 71, 76, 81, 81, 79, 19, 0,

0, 26, 0, 0, 0, 63, 0, 22, 171, 0,

0, 41, 60, 0, 0, 0, 0, 0, 103, 102,

0, 0, 0, 64, 0, 153, 0, 0, 0, 154,

86, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 44,

0, 75, 74, 73, 54, 53, 0, 85, 17, 0,

0, 0, 28, 0, 0, 42, 0, 0, 0, 131,

0, 0, 0, 0, 98, 93, 0, 62, 141, 143,

155, 145, 165, 66, 83, 113, 152, 114, 123, 126,

127, 0, 111, 0, 0, 0, 122, 124, 125, 106,

105, 108, 107, 109, 110, 47, 46, 72, 80, 0,

32, 33, 34, 31, 30, 24, 0, 25, 20, 172,

0, 0, 120, 0, 0, 0, 0, 148, 164, 163,

157, 158, 162, 161, 0, 0, 58, 0, 112, 0,

0, 0, 23, 29, 40, 128, 0, 121, 155, 146,

142, 160, 159, 0, 0, 129, 0, 0, 117, 115,

0, 154, 144, 0, 0, 167, 0, 68, 118, 116,

0, 147, 0, 0, 0, 65, 119, 0, 168, 156,

67, 166

};

/* YYPGOTO[NTERM-NUM]. */

static const yytype_int16 yypgoto[] =

{

-248, -248, 288, 298, 290, -248, -248, -248, -248, 106,

-248, 321, -248, 109, -248, -248, -248, -248, -248, 270,

-248, -248, 179, -189, 42, -12, -248, 311, 219, -248,

-248, -101, -248, -248, 176, -248, 197, -248, -248, -88,

-175, 182, 210, -78, -99, -248, -248, -248, -248, -248,

-248, -248, -248, -248, -248, -248, -46, -98, -248, -36,

-248, -248, -248, -246, -248, 82, -248, 0, -247, -192,

-248, -248, 83, -248, 289, -248

};

/* YYDEFGOTO[NTERM-NUM]. */

static const yytype_int16 yydefgoto[] =

{

-1, 13, 14, 15, 16, 17, 18, 19, 67, 146,

20, 63, 201, 202, 254, 21, 22, 23, 24, 103,

25, 130, 131, 26, 27, 28, 55, 29, 72, 111,

163, 100, 276, 315, 56, 132, 133, 193, 41, 83,

112, 88, 113, 114, 115, 116, 117, 118, 119, 120,

121, 122, 123, 124, 125, 126, 127, 90, 91, 92,

128, 93, 217, 218, 290, 219, 42, 220, 169, 170,

221, 274, 222, 319, 50, 149

};

/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If

static const yytype_int16 yytable[] =

{

47, 134, 32, 147, 70, 31, 31, 165, 158, 159,

43, 165, 314, 89, 257, 9, 35, 85, 86, 69,

289, 145, 99, 104, 85, 86, 69, 265, 267, 189,

233, 30, 161, 261, 142, 263, 166, 65, 152, 68,

153, 301, 166, 36, 74, 75, 137, 194, 195, 104,

85, 86, 69, 250, 46, 168, 31, 311, 158, 234,

281, 168, 223, 97, 98, 251, 104, 85, 86, 69,

321, 33, 228, 229, 230, 231, 232, 211, 51, 236,

237, 238, 239, 240, 241, 242, 243, 244, 225, 105,

227, 151, 143, 197, 34, 188, 302, 80, 160, 104,

85, 86, 69, 37, 297, 12, 156, 9, 52, 166,

44, 166, 134, 150, 138, 312, 164, 205, 48, 307,

139, 167, 252, 206, 106, 167, 39, 255, 168, 38,

168, 40, 157, 256, 278, 253, 53, 45, 49, 105,

54, 245, 210, 57, 216, 304, 62, 59, 9, 215,

284, 147, 69, 285, 108, 109, 139, 66, 107, 164,

248, 89, 110, 87, 286, 183, 184, 185, 186, 71,

87, 171, 172, 173, 106, 157, 58, 299, 295, 1,

108, 109, -167, 164, 174, 191, 73, 2, 110, 60,

61, 171, 172, 173, 3, 76, 87, 108, 109, 4,

264, 310, 77, 309, 258, 110, 5, 6, 107, 164,

166, 192, 1, 87, -167, 7, 8, 79, -167, 84,

2, 9, 82, 280, -167, -167, 10, 3, 96, 168,

108, 109, 171, 172, 173, 318, 320, 99, 110, 5,

6, 101, -167, -167, 102, 129, 87, 53, 7, 8,

11, 171, 172, 173, 9, 175, 135, 136, 141, 10,

85, 148, 154, 155, 171, 172, 173, 296, 164, 162,

187, 190, -166, 196, 198, 175, 176, 200, 199, 204,

171, 172, 173, 11, 177, 203, 209, 207, 9, 277,

178, 212, 179, 180, -168, -168, 213, 181, 182, 183,

184, 185, 186, 214, -166, 226, 249, 300, -166, 235,

178, 12, 179, 180, -166, -166, 175, 181, 182, 183,

184, 185, 186, 259, 262, 233, 275, 266, 279, 293,

186, 166, -166, -166, 313, 175, 287, 213, 288, 291,

292, 298, 308, 303, 12, 294, 317, 78, 175, 95,

94, 178, 316, 179, 180, 282, 213, 64, 181, 182,

183, 184, 185, 186, 175, 283, 81, 246, 144, 213,

178, 208, 179, 180, 224, 305, 306, 181, 182, 183,

184, 185, 186, 178, 140, 179, 180, 247, 0, 260,

181, 182, 183, 184, 185, 186, 268, 0, 0, 178,

0, 179, 180, 0, 0, 0, 181, 182, 183, 184,

185, 186, 0, 0, -168, -168, 0, 0, 0, 181,

182, 183, 184, 185, 186, 0, 0, 0, 269, 0,

0, 0, 270, 0, 0, 0, 0, 0, 271, 272,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 273

};

static const yytype_int16 yycheck[] =

{

12, 79, 2, 101, 40, 3, 3, 3, 107, 108,

10, 3, 45, 59, 203, 52, 73, 4, 5, 6,

266, 99, 76, 3, 4, 5, 6, 216, 220, 130,

91, 30, 110, 208, 84, 98, 105, 37, 142, 39,

144, 288, 105, 100, 44, 45, 82, 135, 136, 3,

4, 5, 6, 28, 12, 124, 3, 303, 157, 120,