mbed I/F binding for mruby
Dependents: mruby_mbed_web mirb_mbed
mbed-mruby
How to use
Class
Diff: src/parse.c
- Revision:
- 0:158c61bb030f
diff -r 000000000000 -r 158c61bb030f src/parse.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/parse.c Wed Mar 25 17:36:16 2015 +0000 @@ -0,0 +1,12601 @@ +/* A Bison parser, made by GNU Bison 2.4.2. */ + +/* Skeleton implementation for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software + Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.4.2" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Copy the first part of user declarations. */ + +/* Line 189 of yacc.c */ +#line 7 "src/parse.y" + +#undef PARSER_DEBUG + +#define YYDEBUG 1 +#define YYERROR_VERBOSE 1 +/* + * Force yacc to use our memory management. This is a little evil because + * the macros assume that "parser_state *p" is in scope + */ +#define YYMALLOC(n) mrb_malloc(p->mrb, (n)) +#define YYFREE(o) mrb_free(p->mrb, (o)) +#define YYSTACK_USE_ALLOCA 0 + +#include <ctype.h> +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include "mruby.h" +#include "mruby/compile.h" +#include "mruby/proc.h" +#include "mruby/error.h" +#include "node.h" +#include "mrb_throw.h" + +#define YYLEX_PARAM p + +typedef mrb_ast_node node; +typedef struct mrb_parser_state parser_state; +typedef struct mrb_parser_heredoc_info parser_heredoc_info; + +static int yyparse(parser_state *p); +static int yylex(void *lval, parser_state *p); +static void yyerror(parser_state *p, const char *s); +static void yywarn(parser_state *p, const char *s); +static void yywarning(parser_state *p, const char *s); +static void backref_error(parser_state *p, node *n); +static void tokadd(parser_state *p, int32_t c); + +#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c)) + +typedef unsigned int stack_type; + +#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1)) +#define BITSTACK_POP(stack) ((stack) = (stack) >> 1) +#define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1)) +#define BITSTACK_SET_P(stack) ((stack)&1) + +#define COND_PUSH(n) BITSTACK_PUSH(p->cond_stack, (n)) +#define COND_POP() BITSTACK_POP(p->cond_stack) +#define COND_LEXPOP() BITSTACK_LEXPOP(p->cond_stack) +#define COND_P() BITSTACK_SET_P(p->cond_stack) + +#define CMDARG_PUSH(n) BITSTACK_PUSH(p->cmdarg_stack, (n)) +#define CMDARG_POP() BITSTACK_POP(p->cmdarg_stack) +#define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack) +#define CMDARG_P() BITSTACK_SET_P(p->cmdarg_stack) + +#define SET_LINENO(c,n) ((c)->lineno = (n)) +#define NODE_LINENO(c,n) do {\ + if (n) {\ + (c)->filename_index = (n)->filename_index;\ + (c)->lineno = (n)->lineno;\ + }\ +} while (0) + +#define sym(x) ((mrb_sym)(intptr_t)(x)) +#define nsym(x) ((node*)(intptr_t)(x)) + +static inline mrb_sym +intern_cstr_gen(parser_state *p, const char *s) +{ + return mrb_intern_cstr(p->mrb, s); +} +#define intern_cstr(s) intern_cstr_gen(p,(s)) + +static inline mrb_sym +intern_gen(parser_state *p, const char *s, size_t len) +{ + return mrb_intern(p->mrb, s, len); +} +#define intern(s,len) intern_gen(p,(s),(len)) + +static inline mrb_sym +intern_gen_c(parser_state *p, const char c) +{ + return mrb_intern(p->mrb, &c, 1); +} +#define intern_c(c) intern_gen_c(p,(c)) + +static void +cons_free_gen(parser_state *p, node *cons) +{ + cons->cdr = p->cells; + p->cells = cons; +} +#define cons_free(c) cons_free_gen(p, (c)) + +static void* +parser_palloc(parser_state *p, size_t size) +{ + void *m = mrb_pool_alloc(p->pool, size); + + if (!m) { + MRB_THROW(p->jmp); + } + return m; +} + +static node* +cons_gen(parser_state *p, node *car, node *cdr) +{ + node *c; + + if (p->cells) { + c = p->cells; + p->cells = p->cells->cdr; + } + else { + c = (node *)parser_palloc(p, sizeof(mrb_ast_node)); + } + + c->car = car; + c->cdr = cdr; + c->lineno = p->lineno; + c->filename_index = p->current_filename_index; + return c; +} +#define cons(a,b) cons_gen(p,(a),(b)) + +static node* +list1_gen(parser_state *p, node *a) +{ + return cons(a, 0); +} +#define list1(a) list1_gen(p, (a)) + +static node* +list2_gen(parser_state *p, node *a, node *b) +{ + return cons(a, cons(b,0)); +} +#define list2(a,b) list2_gen(p, (a),(b)) + +static node* +list3_gen(parser_state *p, node *a, node *b, node *c) +{ + return cons(a, cons(b, cons(c,0))); +} +#define list3(a,b,c) list3_gen(p, (a),(b),(c)) + +static node* +list4_gen(parser_state *p, node *a, node *b, node *c, node *d) +{ + return cons(a, cons(b, cons(c, cons(d, 0)))); +} +#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d)) + +static node* +list5_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e) +{ + return cons(a, cons(b, cons(c, cons(d, cons(e, 0))))); +} +#define list5(a,b,c,d,e) list5_gen(p, (a),(b),(c),(d),(e)) + +static node* +list6_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e, node *f) +{ + return cons(a, cons(b, cons(c, cons(d, cons(e, cons(f, 0)))))); +} +#define list6(a,b,c,d,e,f) list6_gen(p, (a),(b),(c),(d),(e),(f)) + +static node* +append_gen(parser_state *p, node *a, node *b) +{ + node *c = a; + + if (!a) return b; + while (c->cdr) { + c = c->cdr; + } + if (b) { + c->cdr = b; + } + return a; +} +#define append(a,b) append_gen(p,(a),(b)) +#define push(a,b) append_gen(p,(a),list1(b)) + +static char* +parser_strndup(parser_state *p, const char *s, size_t len) +{ + char *b = (char *)parser_palloc(p, len+1); + + memcpy(b, s, len); + b[len] = '\0'; + return b; +} +#define strndup(s,len) parser_strndup(p, s, len) + +static char* +parser_strdup(parser_state *p, const char *s) +{ + return parser_strndup(p, s, strlen(s)); +} +#undef strdup +#define strdup(s) parser_strdup(p, s) + +/* xxx ----------------------------- */ + +static node* +local_switch(parser_state *p) +{ + node *prev = p->locals; + + p->locals = cons(0, 0); + return prev; +} + +static void +local_resume(parser_state *p, node *prev) +{ + p->locals = prev; +} + +static void +local_nest(parser_state *p) +{ + p->locals = cons(0, p->locals); +} + +static void +local_unnest(parser_state *p) +{ + p->locals = p->locals->cdr; +} + +static mrb_bool +local_var_p(parser_state *p, mrb_sym sym) +{ + node *l = p->locals; + + while (l) { + node *n = l->car; + while (n) { + if (sym(n->car) == sym) return TRUE; + n = n->cdr; + } + l = l->cdr; + } + return FALSE; +} + +static void +local_add_f(parser_state *p, mrb_sym sym) +{ + p->locals->car = push(p->locals->car, nsym(sym)); +} + +static void +local_add(parser_state *p, mrb_sym sym) +{ + if (!local_var_p(p, sym)) { + local_add_f(p, sym); + } +} + +/* (:scope (vars..) (prog...)) */ +static node* +new_scope(parser_state *p, node *body) +{ + return cons((node*)NODE_SCOPE, cons(p->locals->car, body)); +} + +/* (:begin prog...) */ +static node* +new_begin(parser_state *p, node *body) +{ + if (body) { + return list2((node*)NODE_BEGIN, body); + } + return cons((node*)NODE_BEGIN, 0); +} + +#define newline_node(n) (n) + +/* (:rescue body rescue else) */ +static node* +new_rescue(parser_state *p, node *body, node *resq, node *els) +{ + return list4((node*)NODE_RESCUE, body, resq, els); +} + +/* (:ensure body ensure) */ +static node* +new_ensure(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_ENSURE, cons(a, cons(0, b))); +} + +/* (:nil) */ +static node* +new_nil(parser_state *p) +{ + return list1((node*)NODE_NIL); +} + +/* (:true) */ +static node* +new_true(parser_state *p) +{ + return list1((node*)NODE_TRUE); +} + +/* (:false) */ +static node* +new_false(parser_state *p) +{ + return list1((node*)NODE_FALSE); +} + +/* (:alias new old) */ +static node* +new_alias(parser_state *p, mrb_sym a, mrb_sym b) +{ + return cons((node*)NODE_ALIAS, cons(nsym(a), nsym(b))); +} + +/* (:if cond then else) */ +static node* +new_if(parser_state *p, node *a, node *b, node *c) +{ + return list4((node*)NODE_IF, a, b, c); +} + +/* (:unless cond then else) */ +static node* +new_unless(parser_state *p, node *a, node *b, node *c) +{ + return list4((node*)NODE_IF, a, c, b); +} + +/* (:while cond body) */ +static node* +new_while(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_WHILE, cons(a, b)); +} + +/* (:until cond body) */ +static node* +new_until(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_UNTIL, cons(a, b)); +} + +/* (:for var obj body) */ +static node* +new_for(parser_state *p, node *v, node *o, node *b) +{ + return list4((node*)NODE_FOR, v, o, b); +} + +/* (:case a ((when ...) body) ((when...) body)) */ +static node* +new_case(parser_state *p, node *a, node *b) +{ + node *n = list2((node*)NODE_CASE, a); + node *n2 = n; + + while (n2->cdr) { + n2 = n2->cdr; + } + n2->cdr = b; + return n; +} + +/* (:postexe a) */ +static node* +new_postexe(parser_state *p, node *a) +{ + return cons((node*)NODE_POSTEXE, a); +} + +/* (:self) */ +static node* +new_self(parser_state *p) +{ + return list1((node*)NODE_SELF); +} + +/* (:call a b c) */ +static node* +new_call(parser_state *p, node *a, mrb_sym b, node *c) +{ + node *n = list4((node*)NODE_CALL, a, nsym(b), c); + NODE_LINENO(n, a); + return n; +} + +/* (:fcall self mid args) */ +static node* +new_fcall(parser_state *p, mrb_sym b, node *c) +{ + node *n = new_self(p); + NODE_LINENO(n, c); + n = list4((node*)NODE_FCALL, n, nsym(b), c); + NODE_LINENO(n, c); + return n; +} + +/* (:super . c) */ +static node* +new_super(parser_state *p, node *c) +{ + return cons((node*)NODE_SUPER, c); +} + +/* (:zsuper) */ +static node* +new_zsuper(parser_state *p) +{ + return list1((node*)NODE_ZSUPER); +} + +/* (:yield . c) */ +static node* +new_yield(parser_state *p, node *c) +{ + if (c) { + if (c->cdr) { + yyerror(p, "both block arg and actual block given"); + } + return cons((node*)NODE_YIELD, c->car); + } + return cons((node*)NODE_YIELD, 0); +} + +/* (:return . c) */ +static node* +new_return(parser_state *p, node *c) +{ + return cons((node*)NODE_RETURN, c); +} + +/* (:break . c) */ +static node* +new_break(parser_state *p, node *c) +{ + return cons((node*)NODE_BREAK, c); +} + +/* (:next . c) */ +static node* +new_next(parser_state *p, node *c) +{ + return cons((node*)NODE_NEXT, c); +} + +/* (:redo) */ +static node* +new_redo(parser_state *p) +{ + return list1((node*)NODE_REDO); +} + +/* (:retry) */ +static node* +new_retry(parser_state *p) +{ + return list1((node*)NODE_RETRY); +} + +/* (:dot2 a b) */ +static node* +new_dot2(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_DOT2, cons(a, b)); +} + +/* (:dot3 a b) */ +static node* +new_dot3(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_DOT3, cons(a, b)); +} + +/* (:colon2 b c) */ +static node* +new_colon2(parser_state *p, node *b, mrb_sym c) +{ + return cons((node*)NODE_COLON2, cons(b, nsym(c))); +} + +/* (:colon3 . c) */ +static node* +new_colon3(parser_state *p, mrb_sym c) +{ + return cons((node*)NODE_COLON3, nsym(c)); +} + +/* (:and a b) */ +static node* +new_and(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_AND, cons(a, b)); +} + +/* (:or a b) */ +static node* +new_or(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_OR, cons(a, b)); +} + +/* (:array a...) */ +static node* +new_array(parser_state *p, node *a) +{ + return cons((node*)NODE_ARRAY, a); +} + +/* (:splat . a) */ +static node* +new_splat(parser_state *p, node *a) +{ + return cons((node*)NODE_SPLAT, a); +} + +/* (:hash (k . v) (k . v)...) */ +static node* +new_hash(parser_state *p, node *a) +{ + return cons((node*)NODE_HASH, a); +} + +/* (:sym . a) */ +static node* +new_sym(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_SYM, nsym(sym)); +} + +static mrb_sym +new_strsym(parser_state *p, node* str) +{ + const char *s = (const char*)str->cdr->car; + size_t len = (size_t)str->cdr->cdr; + + return mrb_intern(p->mrb, s, len); +} + +/* (:lvar . a) */ +static node* +new_lvar(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_LVAR, nsym(sym)); +} + +/* (:gvar . a) */ +static node* +new_gvar(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_GVAR, nsym(sym)); +} + +/* (:ivar . a) */ +static node* +new_ivar(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_IVAR, nsym(sym)); +} + +/* (:cvar . a) */ +static node* +new_cvar(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_CVAR, nsym(sym)); +} + +/* (:const . a) */ +static node* +new_const(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_CONST, nsym(sym)); +} + +/* (:undef a...) */ +static node* +new_undef(parser_state *p, mrb_sym sym) +{ + return list2((node*)NODE_UNDEF, nsym(sym)); +} + +/* (:class class super body) */ +static node* +new_class(parser_state *p, node *c, node *s, node *b) +{ + return list4((node*)NODE_CLASS, c, s, cons(p->locals->car, b)); +} + +/* (:sclass obj body) */ +static node* +new_sclass(parser_state *p, node *o, node *b) +{ + return list3((node*)NODE_SCLASS, o, cons(p->locals->car, b)); +} + +/* (:module module body) */ +static node* +new_module(parser_state *p, node *m, node *b) +{ + return list3((node*)NODE_MODULE, m, cons(p->locals->car, b)); +} + +/* (:def m lv (arg . body)) */ +static node* +new_def(parser_state *p, mrb_sym m, node *a, node *b) +{ + return list5((node*)NODE_DEF, nsym(m), p->locals->car, a, b); +} + +/* (:sdef obj m lv (arg . body)) */ +static node* +new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b) +{ + return list6((node*)NODE_SDEF, o, nsym(m), p->locals->car, a, b); +} + +/* (:arg . sym) */ +static node* +new_arg(parser_state *p, mrb_sym sym) +{ + return cons((node*)NODE_ARG, nsym(sym)); +} + +/* (m o r m2 b) */ +/* m: (a b c) */ +/* o: ((a . e1) (b . e2)) */ +/* r: a */ +/* m2: (a b c) */ +/* b: a */ +static node* +new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, mrb_sym blk) +{ + node *n; + + n = cons(m2, nsym(blk)); + n = cons(nsym(rest), n); + n = cons(opt, n); + return cons(m, n); +} + +/* (:block_arg . a) */ +static node* +new_block_arg(parser_state *p, node *a) +{ + return cons((node*)NODE_BLOCK_ARG, a); +} + +/* (:block arg body) */ +static node* +new_block(parser_state *p, node *a, node *b) +{ + return list4((node*)NODE_BLOCK, p->locals->car, a, b); +} + +/* (:lambda arg body) */ +static node* +new_lambda(parser_state *p, node *a, node *b) +{ + return list4((node*)NODE_LAMBDA, p->locals->car, a, b); +} + +/* (:asgn lhs rhs) */ +static node* +new_asgn(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_ASGN, cons(a, b)); +} + +/* (:masgn mlhs=(pre rest post) mrhs) */ +static node* +new_masgn(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_MASGN, cons(a, b)); +} + +/* (:asgn lhs rhs) */ +static node* +new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b) +{ + return list4((node*)NODE_OP_ASGN, a, nsym(op), b); +} + +/* (:int . i) */ +static node* +new_int(parser_state *p, const char *s, int base) +{ + return list3((node*)NODE_INT, (node*)strdup(s), (node*)(intptr_t)base); +} + +/* (:float . i) */ +static node* +new_float(parser_state *p, const char *s) +{ + return cons((node*)NODE_FLOAT, (node*)strdup(s)); +} + +/* (:str . (s . len)) */ +static node* +new_str(parser_state *p, const char *s, int len) +{ + return cons((node*)NODE_STR, cons((node*)strndup(s, len), (node*)(intptr_t)len)); +} + +/* (:dstr . a) */ +static node* +new_dstr(parser_state *p, node *a) +{ + return cons((node*)NODE_DSTR, a); +} + +/* (:str . (s . len)) */ +static node* +new_xstr(parser_state *p, const char *s, int len) +{ + return cons((node*)NODE_XSTR, cons((node*)strndup(s, len), (node*)(intptr_t)len)); +} + +/* (:xstr . a) */ +static node* +new_dxstr(parser_state *p, node *a) +{ + return cons((node*)NODE_DXSTR, a); +} + +/* (:dsym . a) */ +static node* +new_dsym(parser_state *p, node *a) +{ + return cons((node*)NODE_DSYM, new_dstr(p, a)); +} + +/* (:str . (a . a)) */ +static node* +new_regx(parser_state *p, const char *p1, const char* p2) +{ + return cons((node*)NODE_REGX, cons((node*)p1, (node*)p2)); +} + +/* (:dregx . a) */ +static node* +new_dregx(parser_state *p, node *a, node *b) +{ + return cons((node*)NODE_DREGX, cons(a, b)); +} + +/* (:backref . n) */ +static node* +new_back_ref(parser_state *p, int n) +{ + return cons((node*)NODE_BACK_REF, (node*)(intptr_t)n); +} + +/* (:nthref . n) */ +static node* +new_nth_ref(parser_state *p, int n) +{ + return cons((node*)NODE_NTH_REF, (node*)(intptr_t)n); +} + +/* (:heredoc . a) */ +static node* +new_heredoc(parser_state *p) +{ + parser_heredoc_info *inf = (parser_heredoc_info *)parser_palloc(p, sizeof(parser_heredoc_info)); + return cons((node*)NODE_HEREDOC, (node*)inf); +} + +static void +new_bv(parser_state *p, mrb_sym id) +{ +} + +static node* +new_literal_delim(parser_state *p) +{ + return cons((node*)NODE_LITERAL_DELIM, 0); +} + +/* (:words . a) */ +static node* +new_words(parser_state *p, node *a) +{ + return cons((node*)NODE_WORDS, a); +} + +/* (:symbols . a) */ +static node* +new_symbols(parser_state *p, node *a) +{ + return cons((node*)NODE_SYMBOLS, a); +} + +/* xxx ----------------------------- */ + +/* (:call a op) */ +static node* +call_uni_op(parser_state *p, node *recv, const char *m) +{ + return new_call(p, recv, intern_cstr(m), 0); +} + +/* (:call a op b) */ +static node* +call_bin_op(parser_state *p, node *recv, const char *m, node *arg1) +{ + return new_call(p, recv, intern_cstr(m), list1(list1(arg1))); +} + +static void +args_with_block(parser_state *p, node *a, node *b) +{ + if (b) { + if (a->cdr) { + yyerror(p, "both block arg and actual block given"); + } + a->cdr = b; + } +} + +static void +call_with_block(parser_state *p, node *a, node *b) +{ + node *n; + + if (a->car == (node*)NODE_SUPER || + a->car == (node*)NODE_ZSUPER) { + if (!a->cdr) a->cdr = cons(0, b); + else { + args_with_block(p, a->cdr, b); + } + } + else { + n = a->cdr->cdr->cdr; + if (!n->car) n->car = cons(0, b); + else { + args_with_block(p, n->car, b); + } + } +} + +static node* +negate_lit(parser_state *p, node *n) +{ + return cons((node*)NODE_NEGATE, n); +} + +static node* +cond(node *n) +{ + return n; +} + +static node* +ret_args(parser_state *p, node *n) +{ + if (n->cdr) { + yyerror(p, "block argument should not be given"); + return NULL; + } + if (!n->car->cdr) return n->car->car; + return new_array(p, n->car); +} + +static void +assignable(parser_state *p, node *lhs) +{ + if ((int)(intptr_t)lhs->car == NODE_LVAR) { + local_add(p, sym(lhs->cdr)); + } +} + +static node* +var_reference(parser_state *p, node *lhs) +{ + node *n; + + if ((int)(intptr_t)lhs->car == NODE_LVAR) { + if (!local_var_p(p, sym(lhs->cdr))) { + n = new_fcall(p, sym(lhs->cdr), 0); + cons_free(lhs); + return n; + } + } + + return lhs; +} + +typedef enum mrb_string_type string_type; + +static node* +new_strterm(parser_state *p, string_type type, int term, int paren) +{ + return cons((node*)(intptr_t)type, cons((node*)0, cons((node*)(intptr_t)paren, (node*)(intptr_t)term))); +} + +static void +end_strterm(parser_state *p) +{ + cons_free(p->lex_strterm->cdr->cdr); + cons_free(p->lex_strterm->cdr); + cons_free(p->lex_strterm); + p->lex_strterm = NULL; +} + +static parser_heredoc_info * +parsing_heredoc_inf(parser_state *p) +{ + node *nd = p->parsing_heredoc; + if (nd == NULL) + return NULL; + /* mrb_assert(nd->car->car == NODE_HEREDOC); */ + return (parser_heredoc_info*)nd->car->cdr; +} + +static void +heredoc_treat_nextline(parser_state *p) +{ + if (p->heredocs_from_nextline == NULL) + return; + if (p->parsing_heredoc == NULL) { + node *n; + p->parsing_heredoc = p->heredocs_from_nextline; + p->lex_strterm_before_heredoc = p->lex_strterm; + p->lex_strterm = new_strterm(p, parsing_heredoc_inf(p)->type, 0, 0); + n = p->all_heredocs; + if (n) { + while (n->cdr) + n = n->cdr; + n->cdr = p->parsing_heredoc; + } + else { + p->all_heredocs = p->parsing_heredoc; + } + } + else { + node *n, *m; + m = p->heredocs_from_nextline; + while (m->cdr) + m = m->cdr; + n = p->all_heredocs; + mrb_assert(n != NULL); + if (n == p->parsing_heredoc) { + m->cdr = n; + p->all_heredocs = p->heredocs_from_nextline; + p->parsing_heredoc = p->heredocs_from_nextline; + } + else { + while (n->cdr != p->parsing_heredoc) { + n = n->cdr; + mrb_assert(n != NULL); + } + m->cdr = n->cdr; + n->cdr = p->heredocs_from_nextline; + p->parsing_heredoc = p->heredocs_from_nextline; + } + } + p->heredocs_from_nextline = NULL; +} + +static void +heredoc_end(parser_state *p) +{ + p->parsing_heredoc = p->parsing_heredoc->cdr; + if (p->parsing_heredoc == NULL) { + p->lstate = EXPR_BEG; + p->cmd_start = TRUE; + end_strterm(p); + p->lex_strterm = p->lex_strterm_before_heredoc; + p->lex_strterm_before_heredoc = NULL; + p->heredoc_end_now = TRUE; + } + else { + /* next heredoc */ + p->lex_strterm->car = (node*)(intptr_t)parsing_heredoc_inf(p)->type; + } +} +#define is_strterm_type(p,str_func) ((int)(intptr_t)((p)->lex_strterm->car) & (str_func)) + +/* xxx ----------------------------- */ + + + +/* Line 189 of yacc.c */ +#line 1067 "C:/Users/matsuzaki.takuya/work/daily/20150106/mruby-1.1.0/build/ARMCA9/src/y.tab.c" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + keyword_class = 258, + keyword_module = 259, + keyword_def = 260, + keyword_begin = 261, + keyword_if = 262, + keyword_unless = 263, + keyword_while = 264, + keyword_until = 265, + keyword_for = 266, + keyword_undef = 267, + keyword_rescue = 268, + keyword_ensure = 269, + keyword_end = 270, + keyword_then = 271, + keyword_elsif = 272, + keyword_else = 273, + keyword_case = 274, + keyword_when = 275, + keyword_break = 276, + keyword_next = 277, + keyword_redo = 278, + keyword_retry = 279, + keyword_in = 280, + keyword_do = 281, + keyword_do_cond = 282, + keyword_do_block = 283, + keyword_do_LAMBDA = 284, + keyword_return = 285, + keyword_yield = 286, + keyword_super = 287, + keyword_self = 288, + keyword_nil = 289, + keyword_true = 290, + keyword_false = 291, + keyword_and = 292, + keyword_or = 293, + keyword_not = 294, + modifier_if = 295, + modifier_unless = 296, + modifier_while = 297, + modifier_until = 298, + modifier_rescue = 299, + keyword_alias = 300, + keyword_BEGIN = 301, + keyword_END = 302, + keyword__LINE__ = 303, + keyword__FILE__ = 304, + keyword__ENCODING__ = 305, + tIDENTIFIER = 306, + tFID = 307, + tGVAR = 308, + tIVAR = 309, + tCONSTANT = 310, + tCVAR = 311, + tLABEL = 312, + tINTEGER = 313, + tFLOAT = 314, + tCHAR = 315, + tXSTRING = 316, + tREGEXP = 317, + tSTRING = 318, + tSTRING_PART = 319, + tSTRING_MID = 320, + tNTH_REF = 321, + tBACK_REF = 322, + tREGEXP_END = 323, + tUPLUS = 324, + tUMINUS = 325, + tPOW = 326, + tCMP = 327, + tEQ = 328, + tEQQ = 329, + tNEQ = 330, + tGEQ = 331, + tLEQ = 332, + tANDOP = 333, + tOROP = 334, + tMATCH = 335, + tNMATCH = 336, + tDOT2 = 337, + tDOT3 = 338, + tAREF = 339, + tASET = 340, + tLSHFT = 341, + tRSHFT = 342, + tCOLON2 = 343, + tCOLON3 = 344, + tOP_ASGN = 345, + tASSOC = 346, + tLPAREN = 347, + tLPAREN_ARG = 348, + tRPAREN = 349, + tLBRACK = 350, + tLBRACE = 351, + tLBRACE_ARG = 352, + tSTAR = 353, + tAMPER = 354, + tLAMBDA = 355, + tSYMBEG = 356, + tREGEXP_BEG = 357, + tWORDS_BEG = 358, + tSYMBOLS_BEG = 359, + tSTRING_BEG = 360, + tXSTRING_BEG = 361, + tSTRING_DVAR = 362, + tLAMBEG = 363, + tHEREDOC_BEG = 364, + tHEREDOC_END = 365, + tLITERAL_DELIM = 366, + tHD_LITERAL_DELIM = 367, + tHD_STRING_PART = 368, + tHD_STRING_MID = 369, + tLOWEST = 370, + tUMINUS_NUM = 371, + idNULL = 372, + idRespond_to = 373, + idIFUNC = 374, + idCFUNC = 375, + id_core_set_method_alias = 376, + id_core_set_variable_alias = 377, + id_core_undef_method = 378, + id_core_define_method = 379, + id_core_define_singleton_method = 380, + id_core_set_postexe = 381, + tLAST_TOKEN = 382 + }; +#endif + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ + +/* Line 214 of yacc.c */ +#line 1005 "src/parse.y" + + node *nd; + mrb_sym id; + int num; + stack_type stack; + const struct vtable *vars; + + + +/* Line 214 of yacc.c */ +#line 1240 "C:/Users/matsuzaki.takuya/work/daily/20150106/mruby-1.1.0/build/ARMCA9/src/y.tab.c" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + + +/* Copy the second part of user declarations. */ + + +/* Line 264 of yacc.c */ +#line 1252 "C:/Users/matsuzaki.takuya/work/daily/20150106/mruby-1.1.0/build/ARMCA9/src/y.tab.c" + +#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; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int 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 && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# 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 + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# 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 _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# 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 _STDLIB_H \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# 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 (YYID (0)) + +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 3 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 10941 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 154 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 160 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 555 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 970 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 382 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 153, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 130, 2, 2, 2, 128, 123, 2, + 149, 150, 126, 124, 147, 125, 146, 127, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 118, 152, + 120, 116, 119, 117, 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, 145, 2, 151, 122, 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, 143, 121, 144, 131, 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, 129, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 4, 7, 10, 12, 14, 18, 21, + 23, 24, 30, 35, 38, 40, 42, 46, 49, 50, + 55, 58, 62, 66, 70, 74, 78, 83, 85, 89, + 93, 100, 106, 112, 118, 124, 128, 132, 136, 140, + 142, 146, 150, 152, 156, 160, 164, 167, 169, 171, + 173, 175, 177, 182, 183, 189, 192, 196, 201, 207, + 212, 218, 221, 224, 227, 230, 233, 235, 239, 241, + 245, 247, 250, 254, 260, 263, 268, 271, 276, 278, + 282, 284, 288, 291, 295, 297, 300, 302, 307, 311, + 315, 319, 323, 326, 328, 330, 335, 339, 343, 347, + 351, 354, 356, 358, 360, 363, 365, 369, 371, 373, + 375, 377, 379, 381, 383, 385, 386, 391, 393, 395, + 397, 399, 401, 403, 405, 407, 409, 411, 413, 415, + 417, 419, 421, 423, 425, 427, 429, 431, 433, 435, + 437, 439, 441, 443, 445, 447, 449, 451, 453, 455, + 457, 459, 461, 463, 465, 467, 469, 471, 473, 475, + 477, 479, 481, 483, 485, 487, 489, 491, 493, 495, + 497, 499, 501, 503, 505, 507, 509, 511, 513, 515, + 517, 519, 521, 523, 525, 527, 529, 533, 539, 543, + 549, 556, 562, 568, 574, 580, 585, 589, 593, 597, + 601, 605, 609, 613, 617, 621, 626, 631, 634, 637, + 641, 645, 649, 653, 657, 661, 665, 669, 673, 677, + 681, 685, 689, 692, 695, 699, 703, 707, 711, 718, + 720, 722, 724, 727, 732, 735, 739, 741, 743, 745, + 747, 750, 755, 758, 760, 763, 766, 771, 773, 774, + 777, 780, 783, 785, 787, 790, 794, 799, 804, 810, + 814, 819, 822, 824, 826, 828, 830, 832, 834, 836, + 838, 839, 844, 845, 846, 852, 853, 857, 861, 865, + 868, 872, 876, 878, 883, 887, 889, 894, 898, 901, + 903, 906, 907, 912, 919, 926, 927, 928, 936, 937, + 938, 946, 952, 957, 958, 959, 969, 970, 977, 978, + 979, 988, 989, 995, 996, 997, 1005, 1006, 1007, 1017, + 1019, 1021, 1023, 1025, 1027, 1029, 1031, 1034, 1036, 1038, + 1040, 1046, 1048, 1051, 1053, 1055, 1057, 1061, 1063, 1067, + 1069, 1074, 1081, 1085, 1091, 1094, 1099, 1101, 1105, 1112, + 1121, 1126, 1133, 1138, 1141, 1148, 1151, 1156, 1163, 1166, + 1171, 1174, 1179, 1181, 1183, 1185, 1189, 1191, 1196, 1198, + 1203, 1205, 1209, 1211, 1213, 1218, 1220, 1224, 1228, 1229, + 1235, 1238, 1243, 1249, 1255, 1258, 1263, 1268, 1272, 1276, + 1280, 1283, 1285, 1290, 1291, 1297, 1298, 1304, 1310, 1312, + 1314, 1321, 1323, 1325, 1327, 1329, 1332, 1334, 1337, 1339, + 1341, 1343, 1345, 1347, 1349, 1351, 1354, 1358, 1360, 1363, + 1365, 1366, 1371, 1373, 1376, 1379, 1383, 1386, 1390, 1392, + 1393, 1395, 1397, 1400, 1402, 1405, 1407, 1410, 1412, 1413, + 1418, 1421, 1425, 1427, 1432, 1435, 1437, 1439, 1441, 1443, + 1445, 1448, 1451, 1455, 1457, 1459, 1462, 1465, 1467, 1469, + 1471, 1473, 1475, 1477, 1479, 1481, 1483, 1485, 1487, 1489, + 1491, 1493, 1495, 1497, 1498, 1503, 1506, 1510, 1513, 1520, + 1529, 1534, 1541, 1546, 1553, 1556, 1561, 1568, 1571, 1576, + 1579, 1584, 1586, 1587, 1589, 1591, 1593, 1595, 1597, 1599, + 1601, 1605, 1607, 1611, 1614, 1617, 1620, 1622, 1626, 1628, + 1632, 1634, 1636, 1639, 1641, 1643, 1645, 1648, 1651, 1653, + 1655, 1656, 1661, 1663, 1666, 1668, 1672, 1676, 1679, 1681, + 1683, 1685, 1687, 1689, 1691, 1693, 1695, 1697, 1699, 1701, + 1703, 1704, 1706, 1707, 1709, 1712, 1715, 1716, 1718, 1720, + 1722, 1724, 1725, 1729, 1731, 1734 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 155, 0, -1, -1, 156, 157, -1, 158, 304, -1, + 313, -1, 159, -1, 158, 312, 159, -1, 1, 159, + -1, 164, -1, -1, 46, 160, 143, 157, 144, -1, + 162, 249, 227, 252, -1, 163, 304, -1, 313, -1, + 164, -1, 163, 312, 164, -1, 1, 164, -1, -1, + 45, 185, 165, 185, -1, 12, 186, -1, 164, 40, + 168, -1, 164, 41, 168, -1, 164, 42, 168, -1, + 164, 43, 168, -1, 164, 44, 164, -1, 47, 143, + 162, 144, -1, 166, -1, 174, 116, 169, -1, 274, + 90, 169, -1, 223, 145, 195, 307, 90, 169, -1, + 223, 146, 51, 90, 169, -1, 223, 146, 55, 90, + 169, -1, 223, 88, 55, 90, 169, -1, 223, 88, + 51, 90, 169, -1, 276, 90, 169, -1, 181, 116, + 202, -1, 174, 116, 191, -1, 174, 116, 202, -1, + 167, -1, 181, 116, 169, -1, 181, 116, 166, -1, + 169, -1, 167, 37, 167, -1, 167, 38, 167, -1, + 39, 305, 167, -1, 130, 169, -1, 190, -1, 167, + -1, 173, -1, 170, -1, 242, -1, 242, 303, 301, + 197, -1, -1, 97, 172, 233, 162, 144, -1, 300, + 197, -1, 300, 197, 171, -1, 223, 146, 301, 197, + -1, 223, 146, 301, 197, 171, -1, 223, 88, 301, + 197, -1, 223, 88, 301, 197, 171, -1, 32, 197, + -1, 31, 197, -1, 30, 196, -1, 21, 196, -1, + 22, 196, -1, 176, -1, 92, 175, 306, -1, 176, + -1, 92, 175, 306, -1, 178, -1, 178, 177, -1, + 178, 98, 180, -1, 178, 98, 180, 147, 179, -1, + 178, 98, -1, 178, 98, 147, 179, -1, 98, 180, + -1, 98, 180, 147, 179, -1, 98, -1, 98, 147, + 179, -1, 180, -1, 92, 175, 306, -1, 177, 147, + -1, 178, 177, 147, -1, 177, -1, 178, 177, -1, + 273, -1, 223, 145, 195, 307, -1, 223, 146, 51, + -1, 223, 88, 51, -1, 223, 146, 55, -1, 223, + 88, 55, -1, 89, 55, -1, 276, -1, 273, -1, + 223, 145, 195, 307, -1, 223, 146, 51, -1, 223, + 88, 51, -1, 223, 146, 55, -1, 223, 88, 55, + -1, 89, 55, -1, 276, -1, 51, -1, 55, -1, + 89, 182, -1, 182, -1, 223, 88, 182, -1, 51, + -1, 55, -1, 52, -1, 188, -1, 189, -1, 184, + -1, 269, -1, 185, -1, -1, 186, 147, 187, 185, + -1, 121, -1, 122, -1, 123, -1, 72, -1, 73, + -1, 74, -1, 80, -1, 81, -1, 119, -1, 76, + -1, 120, -1, 77, -1, 75, -1, 86, -1, 87, + -1, 124, -1, 125, -1, 126, -1, 98, -1, 127, + -1, 128, -1, 71, -1, 130, -1, 131, -1, 69, + -1, 70, -1, 84, -1, 85, -1, 148, -1, 48, + -1, 49, -1, 50, -1, 46, -1, 47, -1, 45, + -1, 37, -1, 6, -1, 21, -1, 19, -1, 3, + -1, 5, -1, 26, -1, 18, -1, 17, -1, 15, + -1, 14, -1, 36, -1, 11, -1, 25, -1, 4, + -1, 22, -1, 34, -1, 39, -1, 38, -1, 23, + -1, 13, -1, 24, -1, 30, -1, 33, -1, 32, + -1, 16, -1, 35, -1, 12, -1, 20, -1, 31, + -1, 7, -1, 8, -1, 9, -1, 10, -1, 181, + 116, 190, -1, 181, 116, 190, 44, 190, -1, 274, + 90, 190, -1, 274, 90, 190, 44, 190, -1, 223, + 145, 195, 307, 90, 190, -1, 223, 146, 51, 90, + 190, -1, 223, 146, 55, 90, 190, -1, 223, 88, + 51, 90, 190, -1, 223, 88, 55, 90, 190, -1, + 89, 55, 90, 190, -1, 276, 90, 190, -1, 190, + 82, 190, -1, 190, 83, 190, -1, 190, 124, 190, + -1, 190, 125, 190, -1, 190, 126, 190, -1, 190, + 127, 190, -1, 190, 128, 190, -1, 190, 71, 190, + -1, 129, 58, 71, 190, -1, 129, 59, 71, 190, + -1, 69, 190, -1, 70, 190, -1, 190, 121, 190, + -1, 190, 122, 190, -1, 190, 123, 190, -1, 190, + 72, 190, -1, 190, 119, 190, -1, 190, 76, 190, + -1, 190, 120, 190, -1, 190, 77, 190, -1, 190, + 73, 190, -1, 190, 74, 190, -1, 190, 75, 190, + -1, 190, 80, 190, -1, 190, 81, 190, -1, 130, + 190, -1, 131, 190, -1, 190, 86, 190, -1, 190, + 87, 190, -1, 190, 78, 190, -1, 190, 79, 190, + -1, 190, 117, 190, 305, 118, 190, -1, 203, -1, + 190, -1, 313, -1, 201, 308, -1, 201, 147, 298, + 308, -1, 298, 308, -1, 149, 195, 306, -1, 313, + -1, 193, -1, 313, -1, 196, -1, 201, 147, -1, + 201, 147, 298, 147, -1, 298, 147, -1, 173, -1, + 201, 200, -1, 298, 200, -1, 201, 147, 298, 200, + -1, 199, -1, -1, 198, 196, -1, 99, 191, -1, + 147, 199, -1, 313, -1, 191, -1, 98, 191, -1, + 201, 147, 191, -1, 201, 147, 98, 191, -1, 201, + 147, 262, 191, -1, 201, 147, 262, 98, 191, -1, + 201, 147, 191, -1, 201, 147, 98, 191, -1, 98, + 191, -1, 253, -1, 254, -1, 258, -1, 259, -1, + 260, -1, 275, -1, 276, -1, 52, -1, -1, 6, + 204, 161, 15, -1, -1, -1, 93, 205, 167, 206, + 306, -1, -1, 93, 207, 306, -1, 92, 162, 150, + -1, 223, 88, 55, -1, 89, 55, -1, 95, 192, + 151, -1, 96, 297, 144, -1, 30, -1, 31, 149, + 196, 306, -1, 31, 149, 306, -1, 31, -1, 39, + 149, 167, 306, -1, 39, 149, 306, -1, 300, 244, + -1, 243, -1, 243, 244, -1, -1, 100, 208, 238, + 239, -1, 7, 168, 224, 162, 226, 15, -1, 8, + 168, 224, 162, 227, 15, -1, -1, -1, 9, 209, + 168, 225, 210, 162, 15, -1, -1, -1, 10, 211, + 168, 225, 212, 162, 15, -1, 19, 168, 304, 247, + 15, -1, 19, 304, 247, 15, -1, -1, -1, 11, + 228, 25, 213, 168, 225, 214, 162, 15, -1, -1, + 3, 183, 277, 215, 161, 15, -1, -1, -1, 3, + 86, 167, 216, 309, 217, 161, 15, -1, -1, 4, + 183, 218, 161, 15, -1, -1, -1, 5, 184, 219, + 220, 279, 161, 15, -1, -1, -1, 5, 295, 303, + 221, 184, 222, 279, 161, 15, -1, 21, -1, 22, + -1, 23, -1, 24, -1, 203, -1, 309, -1, 16, + -1, 309, 16, -1, 309, -1, 27, -1, 227, -1, + 17, 168, 224, 162, 226, -1, 313, -1, 18, 162, + -1, 181, -1, 174, -1, 282, -1, 92, 231, 306, + -1, 229, -1, 230, 147, 229, -1, 230, -1, 230, + 147, 98, 282, -1, 230, 147, 98, 282, 147, 230, + -1, 230, 147, 98, -1, 230, 147, 98, 147, 230, + -1, 98, 282, -1, 98, 282, 147, 230, -1, 98, + -1, 98, 147, 230, -1, 284, 147, 288, 147, 291, + 294, -1, 284, 147, 288, 147, 291, 147, 284, 294, + -1, 284, 147, 288, 294, -1, 284, 147, 288, 147, + 284, 294, -1, 284, 147, 291, 294, -1, 284, 147, + -1, 284, 147, 291, 147, 284, 294, -1, 284, 294, + -1, 288, 147, 291, 294, -1, 288, 147, 291, 147, + 284, 294, -1, 288, 294, -1, 288, 147, 284, 294, + -1, 291, 294, -1, 291, 147, 284, 294, -1, 293, + -1, 313, -1, 234, -1, 121, 235, 121, -1, 79, + -1, 121, 232, 235, 121, -1, 305, -1, 305, 152, + 236, 305, -1, 237, -1, 236, 147, 237, -1, 51, + -1, 281, -1, 149, 280, 235, 150, -1, 280, -1, + 108, 162, 144, -1, 29, 162, 15, -1, -1, 28, + 241, 233, 162, 15, -1, 173, 240, -1, 242, 303, + 301, 194, -1, 242, 303, 301, 194, 244, -1, 242, + 303, 301, 197, 240, -1, 300, 193, -1, 223, 146, + 301, 194, -1, 223, 88, 301, 193, -1, 223, 88, + 302, -1, 223, 146, 193, -1, 223, 88, 193, -1, + 32, 193, -1, 32, -1, 223, 145, 195, 307, -1, + -1, 143, 245, 233, 162, 144, -1, -1, 26, 246, + 233, 162, 15, -1, 20, 201, 224, 162, 248, -1, + 227, -1, 247, -1, 13, 250, 251, 224, 162, 249, + -1, 313, -1, 191, -1, 202, -1, 313, -1, 91, + 181, -1, 313, -1, 14, 162, -1, 313, -1, 272, + -1, 268, -1, 267, -1, 271, -1, 60, -1, 63, + -1, 105, 63, -1, 105, 255, 63, -1, 256, -1, + 255, 256, -1, 65, -1, -1, 64, 257, 162, 144, + -1, 111, -1, 112, 262, -1, 106, 61, -1, 106, + 255, 61, -1, 102, 62, -1, 102, 255, 62, -1, + 109, -1, -1, 262, -1, 263, -1, 262, 263, -1, + 110, -1, 264, 110, -1, 265, -1, 264, 265, -1, + 114, -1, -1, 113, 266, 162, 144, -1, 103, 63, + -1, 103, 255, 63, -1, 269, -1, 101, 105, 256, + 63, -1, 101, 270, -1, 184, -1, 54, -1, 53, + -1, 56, -1, 63, -1, 105, 63, -1, 104, 63, + -1, 104, 255, 63, -1, 58, -1, 59, -1, 129, + 58, -1, 129, 59, -1, 51, -1, 54, -1, 53, + -1, 56, -1, 55, -1, 273, -1, 273, -1, 34, + -1, 33, -1, 35, -1, 36, -1, 49, -1, 48, + -1, 66, -1, 67, -1, 309, -1, -1, 120, 278, + 168, 309, -1, 1, 309, -1, 149, 280, 306, -1, + 280, 309, -1, 284, 147, 289, 147, 291, 294, -1, + 284, 147, 289, 147, 291, 147, 284, 294, -1, 284, + 147, 289, 294, -1, 284, 147, 289, 147, 284, 294, + -1, 284, 147, 291, 294, -1, 284, 147, 291, 147, + 284, 294, -1, 284, 294, -1, 289, 147, 291, 294, + -1, 289, 147, 291, 147, 284, 294, -1, 289, 294, + -1, 289, 147, 284, 294, -1, 291, 294, -1, 291, + 147, 284, 294, -1, 293, -1, -1, 55, -1, 54, + -1, 53, -1, 56, -1, 281, -1, 51, -1, 282, + -1, 92, 231, 306, -1, 283, -1, 284, 147, 283, + -1, 51, 116, -1, 285, 191, -1, 285, 223, -1, + 287, -1, 288, 147, 287, -1, 286, -1, 289, 147, + 286, -1, 126, -1, 98, -1, 290, 51, -1, 290, + -1, 123, -1, 99, -1, 292, 51, -1, 147, 293, + -1, 313, -1, 275, -1, -1, 149, 296, 167, 306, + -1, 313, -1, 298, 308, -1, 299, -1, 298, 147, + 299, -1, 191, 91, 191, -1, 57, 191, -1, 51, + -1, 55, -1, 52, -1, 51, -1, 55, -1, 52, + -1, 188, -1, 51, -1, 52, -1, 188, -1, 146, + -1, 88, -1, -1, 312, -1, -1, 310, -1, 305, + 150, -1, 305, 151, -1, -1, 310, -1, 147, -1, + 152, -1, 310, -1, -1, 153, 311, 261, -1, 309, + -1, 312, 152, -1, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 1166, 1166, 1166, 1177, 1183, 1187, 1192, 1196, 1202, + 1204, 1203, 1215, 1242, 1248, 1252, 1257, 1261, 1267, 1267, + 1271, 1275, 1279, 1283, 1287, 1291, 1295, 1300, 1301, 1305, + 1309, 1313, 1317, 1321, 1326, 1330, 1335, 1339, 1343, 1347, + 1350, 1354, 1361, 1362, 1366, 1370, 1374, 1378, 1381, 1388, + 1389, 1392, 1393, 1397, 1396, 1409, 1413, 1418, 1422, 1427, + 1431, 1436, 1440, 1444, 1448, 1452, 1458, 1462, 1468, 1469, + 1475, 1479, 1483, 1487, 1491, 1495, 1499, 1503, 1507, 1511, + 1517, 1518, 1524, 1528, 1534, 1538, 1544, 1548, 1552, 1556, + 1560, 1564, 1570, 1576, 1583, 1587, 1591, 1595, 1599, 1603, + 1609, 1615, 1622, 1626, 1629, 1633, 1637, 1643, 1644, 1645, + 1646, 1651, 1658, 1659, 1662, 1666, 1666, 1672, 1673, 1674, + 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, + 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, + 1695, 1696, 1697, 1698, 1699, 1700, 1703, 1703, 1703, 1704, + 1704, 1705, 1705, 1705, 1706, 1706, 1706, 1706, 1707, 1707, + 1707, 1708, 1708, 1708, 1709, 1709, 1709, 1709, 1710, 1710, + 1710, 1710, 1711, 1711, 1711, 1711, 1712, 1712, 1712, 1712, + 1713, 1713, 1713, 1713, 1714, 1714, 1717, 1721, 1725, 1729, + 1733, 1737, 1741, 1745, 1749, 1754, 1759, 1764, 1768, 1772, + 1776, 1780, 1784, 1788, 1792, 1796, 1800, 1804, 1808, 1812, + 1816, 1820, 1824, 1828, 1832, 1836, 1840, 1844, 1848, 1852, + 1856, 1860, 1864, 1868, 1872, 1876, 1880, 1884, 1888, 1892, + 1898, 1905, 1906, 1911, 1915, 1922, 1928, 1929, 1932, 1933, + 1934, 1939, 1944, 1951, 1956, 1961, 1966, 1971, 1978, 1978, + 1989, 1995, 1999, 2005, 2010, 2015, 2019, 2023, 2027, 2033, + 2037, 2041, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, + 2059, 2058, 2070, 2074, 2069, 2079, 2079, 2083, 2087, 2091, + 2095, 2100, 2105, 2109, 2113, 2117, 2121, 2125, 2129, 2133, + 2134, 2140, 2139, 2152, 2160, 2168, 2168, 2168, 2175, 2175, + 2175, 2182, 2188, 2193, 2195, 2192, 2204, 2202, 2218, 2223, + 2216, 2238, 2236, 2251, 2255, 2250, 2270, 2276, 2269, 2291, + 2295, 2299, 2303, 2309, 2316, 2317, 2318, 2321, 2322, 2325, + 2326, 2334, 2335, 2341, 2345, 2348, 2352, 2358, 2362, 2368, + 2372, 2376, 2380, 2384, 2388, 2392, 2396, 2400, 2406, 2410, + 2414, 2418, 2422, 2426, 2430, 2434, 2438, 2442, 2446, 2450, + 2454, 2458, 2462, 2468, 2469, 2476, 2480, 2484, 2491, 2495, + 2501, 2502, 2505, 2510, 2513, 2517, 2523, 2527, 2534, 2533, + 2546, 2556, 2560, 2565, 2572, 2576, 2580, 2584, 2588, 2592, + 2596, 2600, 2604, 2611, 2610, 2623, 2622, 2636, 2644, 2653, + 2656, 2663, 2666, 2670, 2671, 2674, 2678, 2681, 2685, 2688, + 2689, 2690, 2691, 2694, 2695, 2696, 2700, 2706, 2707, 2713, + 2718, 2717, 2728, 2732, 2738, 2742, 2748, 2752, 2758, 2761, + 2762, 2765, 2766, 2769, 2775, 2781, 2782, 2785, 2792, 2791, + 2805, 2809, 2816, 2820, 2827, 2834, 2835, 2836, 2837, 2838, + 2842, 2848, 2852, 2858, 2859, 2860, 2864, 2870, 2874, 2878, + 2882, 2886, 2892, 2898, 2902, 2906, 2910, 2914, 2918, 2925, + 2934, 2935, 2938, 2943, 2942, 2951, 2958, 2964, 2970, 2974, + 2978, 2982, 2986, 2990, 2994, 2998, 3002, 3006, 3010, 3014, + 3018, 3022, 3027, 3033, 3038, 3043, 3048, 3055, 3059, 3066, + 3070, 3076, 3080, 3086, 3093, 3099, 3105, 3109, 3115, 3119, + 3125, 3126, 3129, 3134, 3141, 3142, 3145, 3152, 3156, 3163, + 3168, 3168, 3193, 3194, 3200, 3205, 3211, 3215, 3221, 3222, + 3223, 3226, 3227, 3228, 3229, 3232, 3233, 3234, 3237, 3238, + 3241, 3242, 3245, 3246, 3249, 3252, 3255, 3256, 3257, 3260, + 3261, 3265, 3264, 3271, 3272, 3276 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "keyword_class", "keyword_module", + "keyword_def", "keyword_begin", "keyword_if", "keyword_unless", + "keyword_while", "keyword_until", "keyword_for", "keyword_undef", + "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_then", + "keyword_elsif", "keyword_else", "keyword_case", "keyword_when", + "keyword_break", "keyword_next", "keyword_redo", "keyword_retry", + "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block", + "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super", + "keyword_self", "keyword_nil", "keyword_true", "keyword_false", + "keyword_and", "keyword_or", "keyword_not", "modifier_if", + "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue", + "keyword_alias", "keyword_BEGIN", "keyword_END", "keyword__LINE__", + "keyword__FILE__", "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", + "tIVAR", "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tCHAR", + "tXSTRING", "tREGEXP", "tSTRING", "tSTRING_PART", "tSTRING_MID", + "tNTH_REF", "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", + "tCMP", "tEQ", "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", + "tMATCH", "tNMATCH", "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", + "tRSHFT", "tCOLON2", "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", + "tLPAREN_ARG", "tRPAREN", "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", + "tAMPER", "tLAMBDA", "tSYMBEG", "tREGEXP_BEG", "tWORDS_BEG", + "tSYMBOLS_BEG", "tSTRING_BEG", "tXSTRING_BEG", "tSTRING_DVAR", "tLAMBEG", + "tHEREDOC_BEG", "tHEREDOC_END", "tLITERAL_DELIM", "tHD_LITERAL_DELIM", + "tHD_STRING_PART", "tHD_STRING_MID", "tLOWEST", "'='", "'?'", "':'", + "'>'", "'<'", "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", + "tUMINUS_NUM", "'!'", "'~'", "idNULL", "idRespond_to", "idIFUNC", + "idCFUNC", "id_core_set_method_alias", "id_core_set_variable_alias", + "id_core_undef_method", "id_core_define_method", + "id_core_define_singleton_method", "id_core_set_postexe", "tLAST_TOKEN", + "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'", + "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts", + "top_stmt", "@2", "bodystmt", "compstmt", "stmts", "stmt", "$@3", + "command_asgn", "expr", "expr_value", "command_call", "block_command", + "cmd_brace_block", "$@4", "command", "mlhs", "mlhs_inner", "mlhs_basic", + "mlhs_item", "mlhs_list", "mlhs_post", "mlhs_node", "lhs", "cname", + "cpath", "fname", "fsym", "undef_list", "$@5", "op", "reswords", "arg", + "arg_value", "aref_args", "paren_args", "opt_paren_args", + "opt_call_args", "call_args", "command_args", "@6", "block_arg", + "opt_block_arg", "args", "mrhs", "primary", "@7", "@8", "$@9", "$@10", + "@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "@18", "@19", + "@20", "@21", "@22", "@23", "@24", "@25", "primary_value", "then", "do", + "if_tail", "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs", + "block_param", "opt_block_param", "block_param_def", "opt_bv_decl", + "bv_decls", "bvar", "f_larglist", "lambda_body", "do_block", "$@26", + "block_call", "method_call", "brace_block", "@27", "@28", "case_body", + "cases", "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", + "string", "string_rep", "string_interp", "@29", "xstring", "regexp", + "heredoc", "opt_heredoc_bodies", "heredoc_bodies", "heredoc_body", + "heredoc_string_rep", "heredoc_string_interp", "@30", "words", "symbol", + "basic_symbol", "sym", "symbols", "numeric", "variable", "var_lhs", + "var_ref", "backref", "superclass", "$@31", "f_arglist", "f_args", + "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_opt_asgn", "f_opt", + "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark", + "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg", + "singleton", "$@32", "assoc_list", "assocs", "assoc", "operation", + "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl", + "rparen", "rbracket", "trailer", "term", "nl", "$@33", "terms", "none", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +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, 61, 63, 58, 62, + 60, 124, 94, 38, 43, 45, 42, 47, 37, 371, + 33, 126, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 123, 125, 91, 46, 44, 96, 40, + 41, 93, 59, 10 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint16 yyr1[] = +{ + 0, 154, 156, 155, 157, 158, 158, 158, 158, 159, + 160, 159, 161, 162, 163, 163, 163, 163, 165, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 166, 166, 167, 167, 167, 167, 167, 167, 168, 169, + 169, 170, 170, 172, 171, 173, 173, 173, 173, 173, + 173, 173, 173, 173, 173, 173, 174, 174, 175, 175, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, + 177, 177, 178, 178, 179, 179, 180, 180, 180, 180, + 180, 180, 180, 180, 181, 181, 181, 181, 181, 181, + 181, 181, 182, 182, 183, 183, 183, 184, 184, 184, + 184, 184, 185, 185, 186, 187, 186, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 189, 189, 189, 189, + 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, + 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, + 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, + 189, 189, 189, 189, 189, 189, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 191, 192, 192, 192, 192, 193, 194, 194, 195, 195, + 195, 195, 195, 196, 196, 196, 196, 196, 198, 197, + 199, 200, 200, 201, 201, 201, 201, 201, 201, 202, + 202, 202, 203, 203, 203, 203, 203, 203, 203, 203, + 204, 203, 205, 206, 203, 207, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 208, 203, 203, 203, 209, 210, 203, 211, 212, + 203, 203, 203, 213, 214, 203, 215, 203, 216, 217, + 203, 218, 203, 219, 220, 203, 221, 222, 203, 203, + 203, 203, 203, 223, 224, 224, 224, 225, 225, 226, + 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, + 231, 231, 231, 231, 231, 231, 231, 231, 232, 232, + 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, + 232, 232, 232, 233, 233, 234, 234, 234, 235, 235, + 236, 236, 237, 237, 238, 238, 239, 239, 241, 240, + 242, 242, 242, 242, 243, 243, 243, 243, 243, 243, + 243, 243, 243, 245, 244, 246, 244, 247, 248, 248, + 249, 249, 250, 250, 250, 251, 251, 252, 252, 253, + 253, 253, 253, 254, 254, 254, 254, 255, 255, 256, + 257, 256, 256, 256, 258, 258, 259, 259, 260, 261, + 261, 262, 262, 263, 263, 264, 264, 265, 266, 265, + 267, 267, 268, 268, 269, 270, 270, 270, 270, 270, + 270, 271, 271, 272, 272, 272, 272, 273, 273, 273, + 273, 273, 274, 275, 275, 275, 275, 275, 275, 275, + 276, 276, 277, 278, 277, 277, 279, 279, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 281, 281, 281, 281, 282, 282, 283, + 283, 284, 284, 285, 286, 287, 288, 288, 289, 289, + 290, 290, 291, 291, 292, 292, 293, 294, 294, 295, + 296, 295, 297, 297, 298, 298, 299, 299, 300, 300, + 300, 301, 301, 301, 301, 302, 302, 302, 303, 303, + 304, 304, 305, 305, 306, 307, 308, 308, 308, 309, + 309, 311, 310, 312, 312, 313 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 0, 2, 2, 1, 1, 3, 2, 1, + 0, 5, 4, 2, 1, 1, 3, 2, 0, 4, + 2, 3, 3, 3, 3, 3, 4, 1, 3, 3, + 6, 5, 5, 5, 5, 3, 3, 3, 3, 1, + 3, 3, 1, 3, 3, 3, 2, 1, 1, 1, + 1, 1, 4, 0, 5, 2, 3, 4, 5, 4, + 5, 2, 2, 2, 2, 2, 1, 3, 1, 3, + 1, 2, 3, 5, 2, 4, 2, 4, 1, 3, + 1, 3, 2, 3, 1, 2, 1, 4, 3, 3, + 3, 3, 2, 1, 1, 4, 3, 3, 3, 3, + 2, 1, 1, 1, 2, 1, 3, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 4, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 3, 5, 3, 5, + 6, 5, 5, 5, 5, 4, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 4, 4, 2, 2, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 2, 2, 3, 3, 3, 3, 6, 1, + 1, 1, 2, 4, 2, 3, 1, 1, 1, 1, + 2, 4, 2, 1, 2, 2, 4, 1, 0, 2, + 2, 2, 1, 1, 2, 3, 4, 4, 5, 3, + 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 4, 0, 0, 5, 0, 3, 3, 3, 2, + 3, 3, 1, 4, 3, 1, 4, 3, 2, 1, + 2, 0, 4, 6, 6, 0, 0, 7, 0, 0, + 7, 5, 4, 0, 0, 9, 0, 6, 0, 0, + 8, 0, 5, 0, 0, 7, 0, 0, 9, 1, + 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, + 5, 1, 2, 1, 1, 1, 3, 1, 3, 1, + 4, 6, 3, 5, 2, 4, 1, 3, 6, 8, + 4, 6, 4, 2, 6, 2, 4, 6, 2, 4, + 2, 4, 1, 1, 1, 3, 1, 4, 1, 4, + 1, 3, 1, 1, 4, 1, 3, 3, 0, 5, + 2, 4, 5, 5, 2, 4, 4, 3, 3, 3, + 2, 1, 4, 0, 5, 0, 5, 5, 1, 1, + 6, 1, 1, 1, 1, 2, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 2, 3, 1, 2, 1, + 0, 4, 1, 2, 2, 3, 2, 3, 1, 0, + 1, 1, 2, 1, 2, 1, 2, 1, 0, 4, + 2, 3, 1, 4, 2, 1, 1, 1, 1, 1, + 2, 2, 3, 1, 1, 2, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 4, 2, 3, 2, 6, 8, + 4, 6, 4, 6, 2, 4, 6, 2, 4, 2, + 4, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 3, 1, 3, 2, 2, 2, 1, 3, 1, 3, + 1, 1, 2, 1, 1, 1, 2, 2, 1, 1, + 0, 4, 1, 2, 1, 3, 3, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 1, 0, 1, 2, 2, 0, 1, 1, 1, + 1, 0, 3, 1, 2, 0 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint16 yydefact[] = +{ + 2, 0, 0, 1, 0, 0, 0, 0, 270, 0, + 0, 295, 298, 0, 0, 540, 319, 320, 321, 322, + 282, 248, 248, 465, 464, 466, 467, 542, 0, 10, + 0, 469, 468, 457, 530, 459, 458, 461, 460, 453, + 454, 413, 414, 470, 471, 0, 0, 0, 0, 272, + 555, 555, 78, 291, 0, 0, 0, 0, 0, 0, + 428, 0, 0, 0, 3, 540, 6, 9, 27, 39, + 42, 50, 49, 0, 66, 0, 70, 80, 0, 47, + 229, 0, 51, 289, 262, 263, 264, 265, 266, 411, + 410, 442, 412, 409, 463, 0, 267, 268, 248, 5, + 8, 319, 320, 282, 285, 391, 0, 102, 103, 0, + 0, 0, 0, 105, 0, 323, 0, 463, 268, 0, + 311, 156, 166, 157, 153, 182, 183, 184, 185, 164, + 179, 172, 162, 161, 177, 160, 159, 155, 180, 154, + 167, 171, 173, 165, 158, 174, 181, 176, 175, 168, + 178, 163, 152, 170, 169, 151, 149, 150, 146, 147, + 148, 107, 109, 108, 141, 142, 138, 120, 121, 122, + 129, 126, 128, 123, 124, 143, 144, 130, 131, 135, + 125, 127, 117, 118, 119, 132, 133, 134, 136, 137, + 139, 140, 145, 520, 313, 110, 111, 519, 0, 0, + 0, 48, 0, 0, 0, 463, 0, 268, 0, 0, + 0, 0, 334, 333, 0, 0, 463, 268, 175, 168, + 178, 163, 146, 147, 107, 108, 0, 112, 114, 20, + 113, 549, 551, 540, 0, 553, 550, 541, 0, 0, + 0, 0, 243, 230, 253, 64, 247, 555, 555, 524, + 65, 63, 542, 62, 0, 555, 390, 61, 542, 0, + 543, 18, 0, 0, 207, 0, 208, 279, 0, 0, + 0, 540, 15, 542, 68, 14, 0, 542, 0, 546, + 546, 231, 0, 0, 546, 522, 0, 0, 76, 0, + 86, 93, 492, 447, 446, 448, 449, 0, 445, 444, + 426, 420, 419, 422, 0, 0, 417, 440, 0, 451, + 0, 415, 0, 424, 0, 455, 456, 46, 222, 223, + 4, 541, 0, 0, 0, 0, 0, 0, 0, 378, + 380, 0, 82, 0, 74, 71, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 555, 0, 539, 538, 0, 395, + 393, 290, 0, 0, 384, 55, 288, 308, 102, 103, + 104, 455, 456, 0, 473, 306, 472, 0, 555, 0, + 0, 0, 314, 316, 0, 555, 279, 325, 0, 324, + 0, 0, 555, 0, 0, 0, 0, 0, 0, 279, + 0, 555, 0, 303, 0, 115, 429, 0, 0, 0, + 554, 527, 254, 250, 0, 0, 244, 252, 0, 245, + 542, 0, 284, 249, 542, 239, 555, 555, 238, 542, + 287, 45, 0, 0, 0, 0, 0, 0, 17, 542, + 277, 13, 541, 67, 273, 276, 280, 548, 232, 547, + 548, 234, 281, 523, 92, 84, 0, 79, 0, 0, + 555, 0, 498, 495, 494, 493, 496, 0, 511, 515, + 514, 510, 492, 0, 375, 497, 499, 501, 555, 0, + 508, 555, 513, 555, 0, 491, 450, 0, 0, 433, + 438, 437, 423, 431, 0, 435, 427, 418, 441, 452, + 416, 425, 0, 0, 7, 21, 22, 23, 24, 25, + 43, 44, 555, 0, 28, 37, 0, 38, 542, 0, + 72, 83, 41, 40, 0, 186, 253, 36, 204, 212, + 217, 218, 219, 214, 216, 226, 227, 220, 221, 197, + 198, 224, 225, 542, 213, 215, 209, 210, 211, 199, + 200, 201, 202, 203, 531, 536, 532, 537, 389, 248, + 387, 542, 531, 533, 532, 534, 388, 248, 531, 532, + 248, 555, 555, 29, 188, 35, 196, 53, 56, 0, + 475, 0, 0, 102, 103, 106, 0, 542, 555, 0, + 542, 492, 0, 271, 555, 555, 401, 555, 326, 186, + 535, 532, 542, 531, 532, 555, 328, 296, 327, 299, + 535, 278, 542, 531, 532, 0, 0, 552, 430, 0, + 0, 302, 526, 0, 255, 251, 0, 555, 525, 283, + 544, 235, 240, 242, 286, 19, 0, 26, 195, 69, + 16, 542, 546, 85, 77, 89, 91, 542, 531, 532, + 503, 498, 0, 346, 337, 339, 542, 335, 542, 0, + 0, 292, 0, 484, 518, 504, 0, 487, 512, 0, + 489, 516, 443, 0, 0, 432, 434, 436, 205, 206, + 366, 542, 0, 364, 363, 261, 0, 81, 75, 0, + 0, 0, 0, 0, 0, 386, 59, 0, 392, 0, + 0, 237, 385, 57, 236, 381, 52, 0, 0, 0, + 555, 309, 0, 0, 392, 312, 521, 492, 0, 0, + 317, 402, 403, 555, 404, 0, 555, 331, 0, 0, + 329, 0, 0, 392, 0, 0, 0, 0, 0, 392, + 0, 116, 301, 0, 0, 256, 0, 257, 246, 555, + 11, 274, 233, 87, 542, 0, 344, 0, 500, 0, + 368, 0, 0, 502, 555, 555, 517, 555, 509, 555, + 555, 421, 0, 542, 0, 555, 0, 506, 555, 555, + 362, 0, 0, 259, 73, 187, 0, 34, 193, 33, + 194, 60, 545, 0, 31, 191, 32, 192, 58, 382, + 383, 0, 0, 189, 0, 0, 474, 307, 542, 0, + 477, 492, 0, 0, 406, 332, 0, 12, 408, 0, + 293, 0, 294, 0, 0, 304, 255, 555, 258, 241, + 336, 347, 0, 342, 338, 374, 0, 377, 376, 0, + 480, 0, 482, 0, 488, 0, 485, 490, 439, 0, + 365, 353, 355, 0, 505, 0, 358, 0, 360, 379, + 260, 228, 30, 190, 396, 394, 0, 0, 476, 315, + 0, 0, 405, 0, 94, 101, 0, 407, 0, 297, + 300, 0, 398, 399, 397, 0, 345, 0, 340, 372, + 542, 370, 373, 555, 555, 555, 555, 367, 555, 555, + 279, 0, 555, 507, 555, 555, 54, 310, 0, 100, + 0, 555, 0, 555, 555, 0, 343, 0, 0, 369, + 481, 0, 478, 483, 486, 0, 350, 0, 352, 535, + 278, 359, 0, 356, 361, 318, 535, 99, 542, 531, + 532, 400, 330, 305, 341, 371, 555, 555, 555, 555, + 555, 392, 479, 351, 0, 348, 354, 357, 555, 349 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 1, 2, 64, 65, 66, 262, 394, 395, 271, + 272, 442, 68, 69, 202, 70, 71, 588, 720, 72, + 73, 273, 74, 75, 76, 467, 77, 203, 113, 114, + 227, 228, 229, 626, 195, 196, 79, 244, 278, 568, + 712, 434, 435, 253, 254, 246, 426, 436, 527, 80, + 199, 276, 651, 277, 292, 209, 747, 210, 748, 625, + 891, 592, 589, 815, 390, 392, 601, 602, 821, 265, + 398, 617, 739, 740, 215, 664, 665, 666, 783, 692, + 693, 769, 900, 901, 483, 671, 330, 522, 82, 83, + 376, 582, 581, 419, 894, 605, 733, 823, 827, 84, + 85, 305, 306, 498, 86, 87, 88, 627, 636, 503, + 504, 505, 684, 89, 90, 91, 299, 92, 93, 205, + 206, 96, 207, 385, 591, 728, 729, 485, 486, 487, + 488, 489, 490, 787, 788, 491, 492, 493, 494, 776, + 673, 198, 391, 283, 437, 249, 119, 596, 570, 368, + 234, 431, 432, 708, 458, 399, 260, 416, 237, 275 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -763 +static const yytype_int16 yypact[] = +{ + -763, 120, 2670, -763, 7298, 9106, 9433, 5605, -763, 8767, + 8767, -763, -763, 9215, 6691, 5113, 7976, 7976, -763, -763, + 7976, 3331, 2908, -763, -763, -763, -763, 26, 6691, -763, + 9, -763, -763, 5736, 3049, -763, -763, 5865, -763, -763, + -763, -763, -763, -763, -763, 8880, 8880, 90, 4462, -22, + 8089, 8315, 6967, -763, 6399, 584, 717, 907, 943, 659, + -763, 272, 8993, 8880, -763, 197, -763, 1023, -763, 519, + -763, -763, 119, 45, -763, 11, 9324, -763, 115, 3169, + 173, 228, 28, 81, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, 398, 87, -763, 439, 44, -763, + -763, -763, -763, -763, 21, 85, 100, 350, 394, 8767, + 278, 4597, 540, -763, 58, -763, 271, -763, -763, 44, + -763, -763, -763, -763, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, -763, -763, -763, -763, 38, 49, + 54, 61, -763, -763, -763, -763, -763, -763, 97, 198, + -763, 218, -763, 232, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, -763, -763, -763, -763, 28, 3668, + 99, 519, 74, 138, 320, 24, 203, 40, 74, 8767, + 8767, 262, -763, -763, 331, 317, 52, 68, -763, -763, + -763, -763, -763, -763, -763, -763, 6545, -763, -763, 225, + -763, -763, -763, 197, 325, -763, -763, 229, 8880, 8880, + 8880, 8880, -763, 3169, 292, -763, -763, 243, 250, -763, + -763, -763, 5000, -763, 7976, 7976, -763, -763, 5228, 8767, + -763, -763, 256, 4732, -763, 361, 330, 445, 7524, 4462, + 280, 197, 1023, 268, 326, -763, 8767, 268, 304, 174, + 179, -763, 292, 319, 179, -763, 415, 9542, 334, 363, + 366, 379, 748, -763, -763, -763, -763, 971, -763, -763, + -763, -763, -763, -763, 370, 625, -763, -763, 975, -763, + 982, -763, 1039, -763, 733, 419, 421, -763, -763, -763, + -763, 5341, 8767, 8767, 8767, 8767, 7524, 8767, 8767, -763, + -763, 8428, -763, 4462, 7076, 338, 8428, 8880, 8880, 8880, + 8880, 8880, 8880, 8880, 8880, 8880, 8880, 8880, 8880, 8880, + 8880, 8880, 8880, 8880, 8880, 8880, 8880, 8880, 8880, 8880, + 8880, 8880, 8880, 2210, 7976, 9821, -763, -763, 10793, -763, + -763, -763, 8993, 8993, -763, 400, -763, 519, -763, 387, + -763, -763, -763, 197, -763, -763, -763, 9902, 7976, 9983, + 3668, 8767, -763, -763, 486, 490, 65, -763, 3807, 497, + 8880, 10064, 7976, 10145, 8880, 8880, 4079, 60, 60, 104, + 10226, 7976, 10307, -763, 452, -763, 370, 325, 8541, 503, + -763, -763, -763, -763, 8880, 7185, -763, -763, 8202, -763, + 268, 371, -763, -763, 268, -763, 376, 389, -763, 129, + -763, -763, 6691, 4194, 382, 10064, 10145, 8880, 1023, 268, + -763, -763, 5455, 391, 519, -763, -763, 7411, -763, -763, + 8315, -763, -763, -763, 387, 11, 9542, -763, 9542, 10388, + 7976, 10469, 425, -763, -763, -763, -763, 797, -763, -763, + -763, -763, 757, 80, -763, -763, -763, -763, 397, 8880, + -763, 401, 514, 429, 518, -763, -763, 525, 4732, -763, + -763, -763, 370, -763, 480, -763, -763, -763, -763, -763, + -763, -763, 8880, 8880, -763, -763, -763, -763, -763, -763, + -763, -763, 29, 8880, -763, 434, 448, -763, 268, 9542, + 453, -763, -763, -763, 509, 2107, -763, -763, 330, 1778, + 1778, 1778, 1778, 1278, 1278, 6710, 1338, 1778, 1778, 9758, + 9758, 583, 583, 2455, 1278, 1278, 735, 735, 813, 64, + 64, 330, 330, 330, 3423, 6123, 3515, 6252, -763, 85, + -763, 268, 524, -763, 537, -763, -763, 3190, -763, -763, + 1238, 29, 29, -763, 2887, -763, 3169, -763, -763, 197, + -763, 8767, 3668, 496, 37, -763, 85, 268, 85, 632, + 129, 997, 6837, -763, 8654, 618, -763, 674, -763, 3028, + 5994, 2767, 268, 279, 294, 618, -763, -763, -763, -763, + 140, 147, 268, 132, 151, 8767, 6691, -763, 370, 643, + 67, -763, -763, 8880, 292, -763, 7637, 250, -763, -763, + -763, -763, 7185, 8202, -763, -763, 516, -763, 3169, -6, + 1023, 268, 179, 338, -763, 496, 37, 268, 238, 309, + -763, -763, 797, 556, -763, 517, 268, -763, 268, 4885, + 4732, -763, 757, -763, -763, -763, 757, -763, -763, 877, + -763, -763, -763, 534, 4732, -763, -763, -763, 330, 330, + -763, 837, 4885, -763, -763, 522, 7750, -763, -763, 9542, + 8993, 8880, 562, 8993, 8993, -763, 400, 531, 547, 8993, + 8993, -763, -763, 400, -763, 81, 119, 4885, 4732, 8880, + 29, -763, 197, 673, -763, -763, -763, 757, 3668, 197, + -763, 434, -763, 609, -763, 4347, 688, -763, 8767, 702, + -763, 8880, 8880, 353, 8880, 8880, 704, 4885, 4885, 155, + 60, -763, -763, 7863, 3943, -763, 8880, -763, -763, 574, + -763, -763, -763, 315, 268, 896, 575, 1139, -763, 576, + 573, 712, 586, -763, 585, 592, -763, 593, -763, 595, + 593, -763, 601, 268, 629, 599, 9651, -763, 605, 606, + -763, 739, 8880, 612, -763, 3169, 8880, -763, 3169, -763, + 3169, -763, -763, 8993, -763, 3169, -763, 3169, -763, -763, + -763, 741, 616, 3169, 4732, 3668, -763, -763, 268, 747, + -763, 997, 9760, 74, -763, -763, 4885, -763, -763, 74, + -763, 8880, -763, 749, 751, -763, -763, 93, -763, 8202, + -763, 620, 896, 621, -763, -763, 1073, -763, -763, 757, + -763, 877, -763, 877, -763, 877, -763, -763, -763, 655, + -763, 757, -763, 724, 414, 757, -763, 877, -763, -763, + 637, 3169, -763, 3169, -763, -763, 641, 773, -763, -763, + 3668, 737, -763, 422, 366, 379, 3668, -763, 3807, -763, + -763, 4885, -763, -763, -763, 896, 620, 896, 642, -763, + 213, -763, -763, 593, 653, 593, 593, -763, 658, 662, + -763, 10550, 593, -763, 667, 593, -763, -763, 775, 387, + 10631, 7976, 10712, 490, 674, 800, 620, 896, 1073, -763, + -763, 877, -763, -763, -763, 757, -763, 877, -763, 668, + 670, -763, 877, -763, -763, -763, 128, 37, 268, 84, + 103, -763, -763, -763, 620, -763, 593, 593, 669, 593, + 593, 118, -763, -763, 877, -763, -763, -763, 593, -763 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -763, -763, -763, 380, -763, 42, -763, -363, -19, -763, + 35, -763, -293, 734, 13, -48, -763, -570, -763, -13, + 817, -170, 7, -55, -270, -414, -11, 1771, -59, 828, + -1, -20, -763, -763, -241, -763, 1317, 894, -763, -7, + 257, -338, 55, -3, -763, -395, -243, 101, -291, 5, + -763, -763, -763, -763, -763, -763, -763, -763, -763, -763, + -763, -763, -763, -763, -763, -763, -763, -763, -763, 295, + -199, -370, -86, -553, -763, -699, -689, 177, -763, -480, + -763, -594, -763, -87, -763, -763, 126, -763, -763, -763, + -82, -763, -763, -401, -763, -69, -763, -763, -763, -763, + -763, 656, 903, -763, -763, -763, -763, -763, -198, -364, + -763, 364, -763, -763, -763, 8, -763, -763, -763, 1109, + 1870, 850, 1678, -763, -763, 56, -280, -760, -397, -593, + 305, -644, -616, -762, 48, 193, -763, -587, -763, -279, + 388, -763, -763, -763, 15, -386, 816, -307, -763, 672, + 2, -25, -233, -534, -260, 19, 144, -763, 4, -2 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -556 +static const yytype_int16 yytable[] = +{ + 99, 371, 259, 242, 242, 429, 194, 242, 261, 406, + 115, 115, 484, 495, 317, 256, 629, 466, 115, 257, + 461, 335, 230, 208, 463, 440, 571, 599, 233, 270, + 635, 248, 248, 635, 235, 248, 230, 67, 619, 67, + 453, 288, 638, 532, 455, 537, 100, 786, 281, 285, + 597, 380, 736, 298, 654, 274, 569, 115, 577, 383, + 778, 580, 746, 724, 612, 280, 284, 320, 844, 321, + 369, 245, 250, 622, 638, 251, 841, -94, 743, 773, + 667, 115, 598, 397, 235, 775, 902, 616, 749, 779, + 397, 374, 270, -101, 569, 375, 577, 784, 256, 449, + -96, 717, 718, 913, 789, 598, 502, 369, 690, 669, + -67, 735, 374, 418, -462, 698, 366, 247, 247, -98, + 3, 247, 567, 763, 575, -278, -465, 575, -275, -100, + 405, -275, 657, 386, -95, 337, 801, -464, 685, 598, + -94, -81, -466, 808, -97, 267, 567, 329, 575, -467, + 691, 279, 263, 896, 396, 447, -101, -96, 332, 236, + 567, 331, 575, 528, 598, -97, 327, 328, 902, 567, + 252, 575, -99, 913, 367, 258, -98, 372, 384, 232, + -95, -100, -278, -278, -465, -469, -532, 370, 670, 859, + 360, 361, 362, 255, 429, -464, 844, 639, 466, -86, + -466, 641, 668, 495, 567, 575, 644, -467, 926, 236, + 231, 232, 231, 232, 753, -93, 649, 786, 628, 231, + 232, 786, 407, 408, 370, 298, 231, 232, 567, 723, + 575, 336, 465, 778, 255, 417, -96, -96, 954, 242, + 814, 242, 242, -469, 444, 427, 427, 635, 635, 258, + 270, -92, 235, 438, 400, -98, -98, 638, 236, 466, + 773, -323, 904, -88, 685, 667, 766, 248, 773, 248, + -95, -95, 685, 451, 909, 452, 274, -531, 914, -88, + -97, -97, 232, 524, 892, 794, -468, -89, 533, -531, + 235, 786, 115, 404, -91, 697, -532, 81, -90, 81, + 116, 116, -87, 448, 204, 204, -457, 430, 214, 433, + 204, 204, 204, 732, 270, 204, 363, 409, -323, -323, + -461, 457, 495, 530, 583, 585, 460, 232, 595, 378, + 315, 316, 232, 379, -90, 515, 516, 517, 518, 115, + 274, -392, 413, 81, -468, 418, 236, 289, 958, 231, + 232, 242, 236, 247, -88, 247, 67, 204, 576, 387, + 928, 519, 438, 514, -457, 819, 232, 726, 667, 744, + 667, 289, 415, 364, 365, 242, -528, 236, -461, 607, + 835, 420, 576, 424, 745, -88, 438, 615, -88, 242, + 425, -88, 762, 606, 758, -96, 576, 428, 242, 443, + 438, 337, 590, -392, 204, 576, 81, 532, 401, 438, + -98, 653, 790, 465, 961, 236, 388, 389, 761, 410, + -529, 232, 645, 459, 459, -90, 618, 618, 459, 466, + 450, 754, 526, 768, 427, 427, 893, 526, -457, 576, + 637, 99, -66, 831, 635, 667, 898, 818, 495, 445, + 230, 469, 877, 638, -463, 456, -90, 242, -392, -90, + -392, -392, -90, 462, 576, 402, 403, -268, 438, -95, + 464, 115, 652, 115, 465, -279, 411, 412, 67, 683, + 499, 468, -461, 500, 501, 531, 674, 650, -462, 674, + 512, 674, 513, -528, 81, -457, -457, 587, 667, -528, + 667, 603, 911, 604, 204, 204, 402, 446, 470, 471, + 920, -463, -463, 608, -94, 496, 758, 918, 631, 630, + 694, 640, -535, 642, -268, -268, 647, 236, 702, 373, + 667, 840, -279, -279, 115, 447, 643, -529, -81, -461, + -461, 660, 495, -529, 672, -86, 707, 204, 676, 204, + 204, 236, 236, 204, 204, -101, 327, 328, 81, 388, + 389, -100, 705, 81, 81, 678, 706, 921, 922, 681, + 711, 204, 707, 711, 713, 714, 679, 716, 714, 694, + 694, -253, 289, 948, -535, 878, -93, 707, 682, 705, + 686, 711, -92, 500, 501, 696, 714, 707, 381, 382, + 699, 730, 734, 737, 722, 737, 751, 661, 721, 473, + 474, 475, 476, 737, 709, 598, 81, 204, 204, 204, + 204, 81, 204, 204, 886, 700, 204, 710, 81, 289, + 888, 204, 707, 809, 230, 427, 735, 803, 750, -535, + -96, -535, -535, 770, 465, -531, 300, 725, 301, 302, + 771, 772, 533, -98, 337, 797, 799, 759, 752, 204, + 760, 804, 806, -95, 767, 782, 770, 204, 204, -254, + 567, -88, 661, 791, 473, 474, 475, 476, 781, 567, + 796, 575, 802, 204, -90, 81, 204, 506, 817, 301, + 302, 738, 735, 81, -87, 303, 304, 204, 811, 812, + 822, 81, 826, 765, 115, 526, 204, 358, 359, 360, + 361, 362, 308, 310, 312, 314, 825, 830, 694, 832, + 313, 839, 842, 301, 302, 846, 845, 847, 833, 834, + 848, 824, 849, 236, 828, 837, 303, 304, 81, 851, + 853, 816, 855, 201, 201, 858, 861, 81, 820, 201, + 860, 829, 865, 867, 869, 872, 874, 427, 770, -255, + 875, 289, 879, 289, 889, 204, 890, 895, 897, 618, + 303, 304, 674, 674, 236, 674, 907, 674, 674, 910, + 307, 301, 302, 674, -256, 916, 674, 674, 917, 927, + 945, 115, 919, 81, 511, 876, 459, 301, 302, 472, + 931, 473, 474, 475, 476, 935, 337, 887, 472, 937, + 473, 474, 475, 476, 942, 953, 964, -531, 98, -532, + 98, 350, 351, 646, 289, 98, 98, 115, 303, 304, + 212, 98, 98, 98, 120, 737, 98, 715, 952, 764, + 477, 955, 810, 377, 303, 304, 478, 479, 661, 477, + 473, 474, 475, 476, 951, 478, 479, 197, 357, 358, + 359, 360, 361, 362, 98, 774, 236, 923, 687, 924, + 393, 480, 925, 236, 481, 929, 0, 880, 98, 677, + 480, 680, 0, 481, 337, 0, 204, 81, 472, 662, + 473, 474, 475, 476, 236, 663, 0, 482, 0, 350, + 351, 674, 674, 674, 674, 0, 674, 674, 242, 908, + 674, 0, 674, 674, 0, 576, 0, 0, 0, 438, + 204, 606, 737, 707, 0, 98, 0, 98, 661, 477, + 473, 474, 475, 476, 0, 478, 479, 358, 359, 360, + 361, 362, 0, 201, 201, 282, 0, 661, 0, 473, + 474, 475, 476, 0, 674, 674, 674, 674, 674, 0, + 480, 0, 0, 481, 81, 81, 674, 236, 0, 477, + 309, 301, 302, 236, 0, 0, 479, 0, 0, 81, + 0, 777, 0, 0, 780, 0, 0, 81, 662, 0, + 232, 0, 439, 441, 289, 204, 785, 0, 204, 204, + 480, 0, 0, 0, 204, 204, 311, 301, 302, 0, + 454, 0, 81, 81, 0, 98, 0, 0, 303, 304, + 0, 0, 0, 81, 0, 98, 98, 0, 0, 0, + 81, 0, 0, 204, 496, 301, 302, 0, 508, 301, + 302, 0, 81, 81, 0, 509, 301, 302, 472, 81, + 473, 474, 475, 476, 303, 304, 201, 201, 201, 201, + 0, 520, 521, 322, 323, 324, 325, 326, 98, 0, + 98, 98, 0, 0, 98, 98, 0, 0, 0, 98, + 0, 864, 303, 304, 98, 98, 303, 304, 0, 477, + 0, 0, 98, 303, 304, 478, 479, 0, 204, 0, + 0, 0, 510, 301, 302, 0, 0, 0, 0, 81, + 81, 94, 0, 94, 117, 117, 117, 883, 0, 0, + 480, 81, 216, 481, 899, 600, 473, 474, 475, 476, + 0, 0, 421, 422, 423, 0, 0, 98, 98, 98, + 98, 98, 98, 98, 98, 0, 727, 98, 0, 98, + 303, 304, 98, 0, 903, 0, 905, 94, 0, 0, + 906, 290, 850, 852, 0, 854, 0, 856, 857, 0, + 912, 0, 915, 862, 0, 81, 866, 868, 0, 0, + 98, 81, 0, 81, 0, 290, 81, 0, 98, 98, + 661, 0, 473, 474, 475, 476, 0, 0, 0, 0, + 497, 0, 0, 0, 98, 0, 98, 98, 507, 0, + 0, 507, 0, 507, 98, 507, 204, 507, 98, 0, + 94, 0, 98, 0, 0, 525, 0, 98, 0, 0, + 536, 662, 0, 0, 0, 0, 956, 843, -555, 0, + 957, 0, 959, 0, 0, 0, 0, 960, 0, 0, + 0, -555, -555, -555, -555, -555, -555, 0, -555, 98, + 0, 0, 0, 0, -555, -555, 0, 0, 98, 968, + 0, 0, 0, 0, 0, -555, -555, 0, -555, -555, + -555, -555, -555, 0, 0, 0, 98, 0, 0, 0, + 0, 930, 932, 933, 934, 0, 936, 938, 0, 0, + 941, 0, 943, 944, 0, 0, 0, 0, 94, 0, + 0, 0, 536, 0, 98, 0, 0, 0, 632, 634, + 0, 0, 282, 0, 0, 201, -555, 0, 0, 0, + 0, 0, 0, 243, 243, 0, 0, 243, 0, 0, + 0, 0, 0, 0, 962, 963, 965, 966, 967, 337, + 0, 634, 0, 0, 282, 0, 969, 0, 0, 201, + 0, 0, 264, 266, 350, 351, 0, 243, 243, 0, + 0, 0, 94, 0, 0, 0, 0, 94, 94, 318, + 319, -555, -555, 675, -555, 0, 0, 255, -555, 0, + -555, -555, 0, 0, 0, 0, 290, 0, 0, 355, + 356, 357, 358, 359, 360, 361, 362, 98, 98, 337, + 338, 339, 340, 341, 342, 343, 344, 695, 346, 347, + 0, 0, 0, 0, 350, 351, 0, 0, 0, 0, + 94, 0, 0, 0, 0, 94, 0, 0, 0, 0, + 0, 98, 94, 290, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 0, 0, 0, + 0, 0, 201, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 98, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 731, 94, + 98, 0, 0, 0, 0, 0, 0, 94, 98, 0, + 0, 0, 0, 0, 0, 94, 98, 0, 0, 98, + 98, 0, 0, 0, 0, 98, 98, 755, 0, 0, + 757, 0, 0, 98, 98, 0, 634, 282, 0, 0, + 0, 0, 0, 0, 98, 0, 0, 0, 0, 0, + 0, 98, 94, 0, 98, 243, 243, 243, 318, 0, + 0, 94, 0, 98, 98, 0, 0, 0, 0, 243, + 98, 243, 243, 0, 0, 290, 0, 290, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 793, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 94, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 98, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 98, 98, 0, 0, 0, 0, 0, 0, 290, 0, + 0, 0, 98, 0, 0, 0, 0, 836, 243, 0, + 838, 0, 0, 535, 538, 539, 540, 541, 542, 543, + 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, + 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, + 97, 243, 97, 118, 118, 0, 870, 0, 0, 584, + 586, 217, 0, 0, 0, 0, 98, 0, 0, 0, + 0, 94, 98, 0, 98, 243, 0, 98, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 609, 0, 243, + 0, 584, 586, 0, 0, 0, 97, 0, 243, 0, + 291, 0, 0, 282, 0, 243, 0, 98, 0, 0, + 0, 243, 243, 0, 0, 243, 0, 0, 0, 0, + 0, 0, 0, 0, 291, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 648, 0, 0, 0, 0, 0, + 0, 0, 0, 78, 243, 78, 0, 243, 94, 94, + 0, 0, 0, 0, 213, 0, 0, 243, 0, 97, + 0, 0, 0, 94, 0, 0, 0, 0, 0, 0, + 0, 94, 0, 0, 0, 0, 243, 0, 290, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 78, + 0, 0, 0, 0, 0, 0, 94, 94, 0, 688, + 689, 0, 0, 0, 0, 0, 0, 94, 0, 0, + 243, 0, 0, 0, 94, 0, 0, 0, 0, 337, + -556, -556, -556, -556, 342, 343, 94, 94, -556, -556, + 0, 0, 0, 94, 350, 351, 0, 0, 0, 0, + 0, 0, 95, 0, 95, 0, 0, 97, 0, 0, + 0, 0, 78, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 0, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, + 0, 243, 0, 94, 94, 0, 0, 0, 0, 0, + 0, 884, 0, 0, 0, 94, 0, 0, 0, 0, + 0, 97, 0, 0, 0, 0, 97, 97, 0, 0, + 243, 0, 0, 243, 0, 0, 0, 0, 0, 243, + 243, 0, 0, 0, 0, 291, 0, 0, 0, 0, + 78, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 95, 0, 0, 0, 0, 0, 0, 0, 94, + 0, 0, 0, 0, 0, 94, 0, 94, 0, 97, + 94, 0, 0, 0, 97, 0, 0, 0, 0, 0, + 0, 97, 291, 243, 0, 0, 0, 609, 795, 0, + 798, 800, 0, 0, 0, 0, 805, 807, 0, 0, + 0, 0, 0, 0, 78, 0, 813, 0, 0, 78, + 78, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 798, 800, + 0, 805, 807, 0, 0, 0, 0, 0, 97, 95, + 243, 0, 0, 243, 0, 0, 97, 0, 0, 0, + 0, 0, 0, 0, 97, 0, 0, 0, 0, 0, + 0, 0, 78, 0, 0, 0, 0, 78, 0, 0, + 0, 0, 0, 0, 78, 0, 0, 534, 0, 243, + 0, 0, 0, 871, 0, 0, 0, 0, 0, 0, + 873, 97, 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 95, 0, 0, 0, 0, 95, 95, + 0, 0, 0, 0, 291, 0, 291, 0, 873, 0, + 0, 701, 0, 0, 0, 0, 243, 0, 0, 0, + 0, 78, 0, 0, 0, 0, 0, 0, 0, 78, + 0, 0, 0, 0, 0, 0, 97, 78, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, + 349, 95, 0, 350, 351, 0, 95, 0, 0, 0, + 0, 0, 0, 95, 0, 0, 0, 291, 0, 0, + 0, 0, 0, 0, 78, 0, 0, 0, 0, 0, + 0, 0, 0, 78, 352, 0, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 0, 0, 243, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -230, 0, 0, 0, 0, 0, + 95, 564, 565, 0, 0, 566, 0, 0, 95, 78, + 97, 0, 0, 0, 0, 0, 95, 0, 0, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 0, 0, + 173, 174, 0, 0, 175, 176, 177, 178, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 179, 0, + 0, 0, 0, 95, 0, 0, 0, 0, 0, 0, + 0, 0, 95, 0, 0, 0, 0, 0, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 0, + 190, 191, 0, 0, 0, 0, 0, 97, 97, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 192, 255, + 0, 0, 97, 78, 0, 0, 0, 0, 95, 0, + 97, 0, 0, 0, 0, 0, 0, 291, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 97, 97, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 97, 0, 0, 0, + 0, 0, 0, 97, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 97, 97, 0, 0, 0, + 0, 0, 97, 0, 0, 0, 0, 0, 0, 0, + 78, 78, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 78, 0, 0, 0, 0, + 0, 0, 95, 78, 118, 0, 0, 0, 0, 0, + 0, 534, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 78, 78, + 0, 0, 97, 97, 0, 0, 0, 0, 0, 78, + 885, 0, 0, 0, 97, 0, 78, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 78, 78, + 0, 0, 0, 0, 0, 78, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 95, + 95, 350, 351, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 95, 0, 0, 0, 97, 0, + 0, 0, 95, 0, 97, 0, 97, 0, 0, 97, + 0, 0, 352, 0, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 0, 78, 78, 95, 95, 0, + 0, 0, 0, 882, 0, 0, 0, 78, 95, 0, + 0, 0, 0, 0, 0, 95, 0, 0, 232, 0, + 0, 0, 0, 0, 0, 0, 0, 95, 95, 0, + 0, 0, 0, 0, 95, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 78, 0, 0, 0, 0, 0, 78, 0, 78, + 0, 0, 78, 0, 0, 0, 0, 0, 0, 0, + -555, 4, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 0, 95, 95, 0, 0, 0, 15, + 0, 16, 17, 18, 19, 0, 95, 0, 0, 0, + 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, + 0, 0, 0, 0, 0, 28, 29, 30, 31, 32, + 0, 33, 34, 35, 36, 37, 38, 0, 39, 40, + 41, 0, 0, 42, 0, 0, 43, 44, 0, 45, + 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 95, 0, 0, 0, 0, 0, 95, 0, 95, 47, + 0, 95, 48, 49, 0, 50, 51, -278, 52, 0, + 53, 54, 55, 56, 57, 58, 59, 0, 0, 60, + -278, -278, -278, -278, -278, -278, 0, -278, 0, 0, + 0, 0, 0, 0, -278, -278, -278, 0, 0, 61, + 62, 63, 0, 0, -278, -278, 0, -278, -278, -278, + -278, -278, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -555, -555, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -278, -278, + -278, -278, -278, -278, -278, -278, -278, -278, -278, -278, + -278, 0, 0, -278, -278, -278, 0, 742, -278, 0, + 0, 0, 0, 0, -278, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -278, 0, 0, 0, 0, + 0, 0, 0, -99, -278, -278, -278, -278, -278, -278, + -278, -278, -278, -278, -278, -278, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -391, 0, + 0, -278, -278, -278, -278, 0, 0, -278, -278, -278, + -278, -391, -391, -391, -391, -391, -391, 0, -391, 0, + 0, 719, 0, 0, -391, -391, -391, 0, 0, 0, + 0, 0, 0, 0, 0, -391, -391, 0, -391, -391, + -391, -391, -391, 0, 0, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, + 349, 0, 0, 350, 351, 0, 0, 0, 0, -391, + -391, -391, -391, -391, -391, -391, -391, -391, -391, -391, + -391, -391, 0, 0, -391, -391, -391, 0, 0, -391, + 0, 0, 0, 0, 352, -391, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -391, 0, -391, -391, -391, + -391, -391, -391, -391, -391, -391, -391, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -269, + 0, -391, -391, -391, -391, -391, 0, 255, -391, -391, + -391, -391, -269, -269, -269, -269, -269, -269, 0, -269, + 0, 0, 701, 0, 0, 0, -269, -269, -269, 0, + 0, 0, 0, 0, 0, 0, -269, -269, 0, -269, + -269, -269, -269, -269, 0, 0, 0, 0, 0, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 0, 0, 350, 351, 0, 0, 0, 0, + -269, -269, -269, -269, -269, -269, -269, -269, -269, -269, + -269, -269, -269, 0, 0, -269, -269, -269, 0, 0, + -269, 0, 0, 0, 0, 352, -269, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, -269, 0, 0, + 0, 0, 0, 0, 0, 0, -269, -269, -269, -269, + -269, -269, -269, -269, -269, -269, -269, -269, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -555, 0, 0, -269, -269, -269, -269, 0, 0, -269, + -269, -269, -269, -555, -555, -555, -555, -555, -555, 0, + -555, 0, 0, 0, 0, 0, -555, -555, -555, 0, + 0, 0, 0, 0, 0, 0, 0, -555, -555, 0, + -555, -555, -555, -555, -555, 0, 0, 0, 0, 0, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 0, 0, 350, 351, 0, 0, 0, + 0, -555, -555, -555, -555, -555, -555, -555, -555, -555, + -555, -555, -555, -555, 0, 0, -555, -555, -555, 0, + 0, -555, 0, 0, 0, 0, 352, -555, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -555, 0, -555, + -555, -555, -555, -555, -555, -555, -555, -555, -555, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -285, 0, -555, -555, -555, -555, -555, 0, 255, + -555, -555, -555, -555, -285, -285, -285, -285, -285, -285, + 0, -285, 0, 0, 0, 0, 0, 0, -285, -285, + 0, 0, 0, 0, 0, 0, 0, 0, -285, -285, + 0, -285, -285, -285, -285, -285, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -285, -285, -285, -285, -285, -285, -285, -285, + -285, -285, -285, -285, -285, 0, 0, -285, -285, -285, + 0, 0, -285, -535, 0, 0, 0, 0, -285, 0, + 0, 0, 0, 0, 0, 0, -535, -535, -535, 0, + -535, -535, 0, -535, 0, 0, 0, 0, -285, -535, + -285, -285, -285, -285, -285, -285, -285, -285, -285, -285, + -535, -535, 0, -535, -535, -535, -535, -535, 0, 0, + 0, 0, 0, 0, 0, -285, -285, -285, -285, 0, + 252, -285, -285, -285, -285, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -535, -535, -535, -535, -535, -535, + -535, -535, -535, -535, -535, -535, -535, 0, 0, -535, + -535, -535, 0, 703, 0, -278, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -278, -278, + -278, 0, -278, -278, 0, -278, 0, 0, 0, -97, + -535, 0, -535, -535, -535, -535, -535, -535, -535, -535, + -535, -535, -278, -278, 0, -278, -278, -278, -278, -278, + 0, 0, 0, 0, 0, 0, -535, -535, -535, -535, + -89, 0, 0, -535, 0, -535, -535, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -278, -278, -278, -278, + -278, -278, -278, -278, -278, -278, -278, -278, -278, 0, + 0, -278, -278, -278, 0, 704, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -99, -278, 0, -278, -278, -278, -278, -278, -278, + -278, -278, -278, -278, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -278, + -278, -278, -91, 0, 0, -278, 0, -278, -278, 268, + 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, -555, -555, -555, 0, 0, -555, 15, 0, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, + 0, 0, 0, 28, 0, 30, 31, 32, 0, 33, + 34, 35, 36, 37, 38, 0, 39, 40, 41, 0, + 0, 42, 0, 0, 43, 44, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 47, 0, 0, + 48, 49, 0, 50, 51, 0, 52, 0, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 60, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 61, 62, 63, + 0, 0, 0, 0, 0, 0, 0, 0, 268, 0, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + -555, -555, -555, 0, -555, -555, 15, 0, 16, 17, + 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, + 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, + 0, 0, 28, 0, 30, 31, 32, 0, 33, 34, + 35, 36, 37, 38, 0, 39, 40, 41, 0, 0, + 42, 0, 0, 43, 44, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 47, 0, 0, 48, + 49, 0, 50, 51, 0, 52, 0, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 60, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 61, 62, 63, 0, + 0, 0, 0, 0, 268, 0, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 0, 0, -555, -555, + -555, -555, 15, -555, 16, 17, 18, 19, 0, 0, + 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, + 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, + 30, 31, 32, 0, 33, 34, 35, 36, 37, 38, + 0, 39, 40, 41, 0, 0, 42, 0, 0, 43, + 44, 0, 45, 46, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 47, 0, 0, 48, 49, 0, 50, 51, + 0, 52, 0, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 61, 62, 63, 0, 0, 0, 0, 0, + 268, 0, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 0, 0, -555, -555, -555, -555, 15, 0, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, + 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, + 0, 0, 0, 0, 28, 0, 30, 31, 32, 0, + 33, 34, 35, 36, 37, 38, 0, 39, 40, 41, + 0, 0, 42, 0, 0, 43, 44, 0, 45, 46, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 47, 0, + 0, 48, 49, 0, 50, 51, 0, 52, 0, 53, + 54, 55, 56, 57, 58, 59, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 4, 0, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 0, 61, 62, + 63, 0, 0, 15, 0, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, -555, -555, 27, 0, 0, 0, 0, 0, 28, + 29, 30, 31, 32, 0, 33, 34, 35, 36, 37, + 38, 0, 39, 40, 41, 0, 0, 42, 0, 0, + 43, 44, 0, 45, 46, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 47, 0, 0, 48, 49, 0, 50, + 51, 0, 52, 0, 53, 54, 55, 56, 57, 58, + 59, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 61, 62, 63, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -555, 0, + 0, 0, 0, 0, 0, 0, -555, -555, 268, 0, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 0, -555, -555, 0, 0, 0, 15, 0, 16, 17, + 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, + 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, + 0, 0, 28, 0, 30, 31, 32, 0, 33, 34, + 35, 36, 37, 38, 0, 39, 40, 41, 0, 0, + 42, 0, 0, 43, 44, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 47, 0, 0, 48, + 49, 0, 50, 51, 0, 52, 0, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 60, 0, 0, 0, + 0, 0, 0, 268, 0, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 0, 61, 62, 63, 0, + 0, 15, 0, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, -555, + -555, 27, 0, 0, 0, 0, 0, 28, 0, 30, + 31, 32, 0, 33, 34, 35, 36, 37, 38, 0, + 39, 40, 41, 0, 0, 42, 0, 0, 43, 44, + 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 47, 0, 0, 269, 49, 0, 50, 51, 0, + 52, 0, 53, 54, 55, 56, 57, 58, 59, 0, + 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 61, 62, 63, 0, 0, 0, 0, 268, 0, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 0, 0, -555, 0, -555, -555, 15, 0, 16, 17, + 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, + 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, + 0, 0, 28, 0, 30, 31, 32, 0, 33, 34, + 35, 36, 37, 38, 0, 39, 40, 41, 0, 0, + 42, 0, 0, 43, 44, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 47, 0, 0, 48, + 49, 0, 50, 51, 0, 52, 0, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 60, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 61, 62, 63, 0, + 0, 0, 0, 268, 0, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 0, 0, -555, 0, -555, + -555, 15, 0, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, + 31, 32, 0, 33, 34, 35, 36, 37, 38, 0, + 39, 40, 41, 0, 0, 42, 0, 0, 43, 44, + 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 47, 0, 0, 48, 49, 0, 50, 51, 0, + 52, 0, 53, 54, 55, 56, 57, 58, 59, 0, + 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 61, 62, 63, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -555, 0, 0, 0, + 0, 0, 0, 0, -555, -555, 268, 0, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, + -555, 0, 0, 0, 15, 0, 16, 17, 18, 19, + 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, + 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, + 28, 0, 30, 31, 32, 0, 33, 34, 35, 36, + 37, 38, 0, 39, 40, 41, 0, 0, 42, 0, + 0, 43, 44, 0, 45, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 47, 0, 0, 48, 49, 0, + 50, 51, 0, 52, 0, 53, 54, 55, 56, 57, + 58, 59, 0, 0, 60, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 61, 62, 63, 0, 0, 15, + 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, + 20, 21, 22, 23, 24, 25, 26, -555, -555, 106, + 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, + 0, 33, 34, 35, 36, 37, 38, 238, 39, 40, + 41, 0, 0, 42, 0, 0, 43, 44, 0, 45, + 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, + 0, 0, 111, 49, 0, 50, 51, 0, 239, 240, + 53, 54, 55, 56, 57, 58, 59, 0, 0, 60, + 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 0, 0, 0, 0, 61, + 241, 63, 15, 0, 16, 17, 18, 19, 0, 0, + 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, + 0, 0, 27, 232, 0, 0, 0, 0, 0, 0, + 0, 31, 32, 0, 33, 34, 35, 36, 37, 38, + 0, 39, 40, 41, 0, 0, 42, 0, 0, 43, + 44, 0, 45, 46, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 200, 0, 0, 111, 49, 0, 50, 51, + 0, 0, 0, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 0, 0, 61, 62, 63, 0, 0, 15, 0, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 231, 232, 27, 0, 0, + 0, 0, 0, 0, 0, 0, 31, 32, 0, 33, + 34, 35, 36, 37, 38, 0, 39, 40, 41, 0, + 0, 42, 0, 0, 43, 44, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 200, 0, 0, + 111, 49, 0, 50, 51, 0, 0, 0, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 60, 0, 0, + 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 0, 0, 0, 61, 62, 63, + 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, + 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, + 27, 232, 0, 0, 0, 0, 28, 29, 30, 31, + 32, 0, 33, 34, 35, 36, 37, 38, 0, 39, + 40, 41, 0, 0, 42, 0, 0, 43, 44, 0, + 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 47, 0, 0, 48, 49, 0, 50, 51, 0, 52, + 0, 53, 54, 55, 56, 57, 58, 59, 0, 0, + 60, 0, 0, 0, 0, 0, 0, 0, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, + 61, 62, 63, 0, 15, 0, 16, 17, 18, 19, + 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, + 25, 26, 0, 420, 27, 0, 0, 0, 0, 0, + 28, 0, 30, 31, 32, 0, 33, 34, 35, 36, + 37, 38, 0, 39, 40, 41, 0, 0, 42, 0, + 0, 43, 44, 0, 45, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 47, 0, 0, 48, 49, 0, + 50, 51, 0, 52, 0, 53, 54, 55, 56, 57, + 58, 59, 0, 0, 60, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 61, 62, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 420, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 0, 0, 0, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 0, 0, 0, 0, 0, + 155, 156, 157, 158, 159, 160, 161, 162, 35, 36, + 163, 38, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 0, 173, 174, 0, 0, 175, + 176, 177, 178, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 0, 190, 191, 0, 0, -528, + -528, -528, -528, -528, -528, -528, -528, -528, 0, 0, + 0, 0, 0, 192, 193, -528, 0, -528, -528, -528, + -528, 0, -528, 0, 0, 0, -528, -528, -528, -528, + -528, -528, -528, 0, 0, -528, 0, 0, 0, 0, + 0, 0, 0, 0, -528, -528, 0, -528, -528, -528, + -528, -528, -528, -528, -528, -528, -528, 0, 0, -528, + 0, 0, -528, -528, 0, -528, -528, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -528, 0, 0, -528, -528, + 0, -528, -528, 0, -528, -528, -528, -528, -528, -528, + -528, -528, -528, 0, 0, -528, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -528, -528, -528, -529, -529, + -529, -529, -529, -529, -529, -529, -529, 0, 0, -528, + 0, 0, 0, 0, -529, -528, -529, -529, -529, -529, + 0, -529, 0, 0, 0, -529, -529, -529, -529, -529, + -529, -529, 0, 0, -529, 0, 0, 0, 0, 0, + 0, 0, 0, -529, -529, 0, -529, -529, -529, -529, + -529, -529, -529, -529, -529, -529, 0, 0, -529, 0, + 0, -529, -529, 0, -529, -529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -529, 0, 0, -529, -529, 0, + -529, -529, 0, -529, -529, -529, -529, -529, -529, -529, + -529, -529, 0, 0, -529, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -529, -529, -529, -531, -531, -531, + -531, -531, -531, -531, -531, -531, 0, 0, -529, 0, + 0, 0, 0, -531, -529, -531, -531, -531, -531, 0, + 0, 0, 0, 0, -531, -531, -531, -531, -531, -531, + -531, 0, 0, -531, 0, 0, 0, 0, 0, 0, + 0, 0, -531, -531, 0, -531, -531, -531, -531, -531, + -531, -531, -531, -531, -531, 0, 0, -531, 0, 0, + -531, -531, 0, -531, -531, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -531, 741, 0, -531, -531, 0, -531, + -531, 0, -531, -531, -531, -531, -531, -531, -531, -531, + -531, 0, 0, -531, 0, 0, 0, 0, 0, 0, + -97, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -531, -531, -531, -533, -533, -533, -533, + -533, -533, -533, -533, -533, 0, 0, 0, 0, 0, + 0, 0, -533, -531, -533, -533, -533, -533, 0, 0, + 0, 0, 0, -533, -533, -533, -533, -533, -533, -533, + 0, 0, -533, 0, 0, 0, 0, 0, 0, 0, + 0, -533, -533, 0, -533, -533, -533, -533, -533, -533, + -533, -533, -533, -533, 0, 0, -533, 0, 0, -533, + -533, 0, -533, -533, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -533, 0, 0, -533, -533, 0, -533, -533, + 0, -533, -533, -533, -533, -533, -533, -533, -533, -533, + 0, 0, -533, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -533, -533, -533, -534, -534, -534, -534, -534, + -534, -534, -534, -534, 0, 0, 0, 0, 0, 0, + 0, -534, -533, -534, -534, -534, -534, 0, 0, 0, + 0, 0, -534, -534, -534, -534, -534, -534, -534, 0, + 0, -534, 0, 0, 0, 0, 0, 0, 0, 0, + -534, -534, 0, -534, -534, -534, -534, -534, -534, -534, + -534, -534, -534, 0, 0, -534, 0, 0, -534, -534, + 0, -534, -534, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -534, 0, 0, -534, -534, 0, -534, -534, 0, + -534, -534, -534, -534, -534, -534, -534, -534, -534, 0, + 0, -534, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -534, -534, -534, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -534, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 0, 0, 0, 145, + 146, 147, 218, 219, 220, 221, 152, 153, 154, 0, + 0, 0, 0, 0, 155, 156, 157, 222, 223, 160, + 224, 162, 293, 294, 225, 295, 0, 0, 0, 0, + 0, 0, 296, 0, 0, 0, 0, 0, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 0, 173, + 174, 0, 0, 175, 176, 177, 178, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 179, 0, 0, + 0, 0, 0, 0, 297, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 0, 190, + 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 192, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 0, 0, 0, 145, 146, 147, 218, 219, + 220, 221, 152, 153, 154, 0, 0, 0, 0, 0, + 155, 156, 157, 222, 223, 160, 224, 162, 293, 294, + 225, 295, 0, 0, 0, 0, 0, 0, 296, 0, + 0, 0, 0, 0, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 0, 173, 174, 0, 0, 175, + 176, 177, 178, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, + 414, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 0, 190, 191, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 192, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 0, 0, + 0, 145, 146, 147, 218, 219, 220, 221, 152, 153, + 154, 0, 0, 0, 0, 0, 155, 156, 157, 222, + 223, 160, 224, 162, 0, 0, 225, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 0, 173, 174, 0, 0, 175, 176, 177, 178, 0, + 0, 337, 338, 339, 340, 341, 342, 343, 0, 179, + 346, 347, 226, 0, 0, 0, 350, 351, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 0, 190, 191, 0, 0, 0, 0, 0, 0, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 192, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 0, 0, 0, 145, 146, 147, + 218, 219, 220, 221, 152, 153, 154, 0, 0, 0, + 0, 0, 155, 156, 157, 222, 223, 160, 224, 162, + 0, 0, 225, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 0, 173, 174, 0, + 0, 175, 176, 177, 178, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 179, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 0, 190, 191, 0, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, + 0, 0, 0, 0, 0, 192, 15, 0, 101, 102, + 18, 19, 0, 0, 0, 0, 0, 103, 104, 105, + 23, 24, 25, 26, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 32, 0, 33, 34, + 35, 36, 37, 38, 0, 39, 40, 41, 0, 0, + 42, 0, 0, 43, 44, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 286, 0, 0, 111, + 49, 0, 50, 51, 0, 0, 0, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 60, 0, 0, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, + 0, 0, 0, 0, 0, 15, 112, 101, 102, 18, + 19, 0, 0, 0, 0, 0, 103, 104, 105, 23, + 24, 25, 26, 0, 287, 106, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 32, 0, 33, 34, 35, + 36, 37, 38, 0, 39, 40, 41, 0, 0, 42, + 0, 0, 43, 44, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 286, 0, 0, 111, 49, + 0, 50, 51, 0, 0, 0, 53, 54, 55, 56, + 57, 58, 59, 0, 0, 60, 0, 0, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, + 0, 0, 0, 0, 15, 112, 101, 102, 18, 19, + 0, 0, 0, 0, 0, 103, 104, 105, 23, 24, + 25, 26, 0, 529, 106, 0, 0, 0, 0, 0, + 0, 0, 0, 31, 32, 0, 33, 34, 35, 36, + 37, 38, 238, 39, 40, 41, 0, 0, 42, 0, + 0, 43, 44, 0, 45, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 200, 0, 0, 111, 49, 0, + 50, 51, 0, 633, 240, 53, 54, 55, 56, 57, + 58, 59, 0, 0, 60, 499, 0, 0, 500, 501, + 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 0, 0, 0, 61, 241, 63, 15, 0, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, + 0, 0, 0, 28, 29, 30, 31, 32, 0, 33, + 34, 35, 36, 37, 38, 0, 39, 40, 41, 0, + 0, 42, 0, 0, 43, 44, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 47, 0, 0, + 48, 49, 0, 50, 51, 0, 52, 0, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 60, 0, 0, + 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 0, 0, 0, 0, 61, 62, 63, + 15, 0, 101, 102, 18, 19, 0, 0, 0, 0, + 0, 103, 104, 105, 23, 24, 25, 26, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 32, 0, 33, 34, 35, 36, 37, 38, 238, 39, + 40, 41, 0, 0, 42, 0, 0, 43, 44, 0, + 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 111, 49, 0, 50, 51, 0, 633, + 0, 53, 54, 55, 56, 57, 58, 59, 0, 0, + 60, 499, 0, 0, 500, 501, 0, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 0, 0, 0, + 61, 241, 63, 15, 0, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, + 0, 30, 31, 32, 0, 33, 34, 35, 36, 37, + 38, 0, 39, 40, 41, 0, 0, 42, 0, 0, + 43, 44, 0, 45, 46, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 47, 0, 0, 48, 49, 0, 50, + 51, 0, 52, 0, 53, 54, 55, 56, 57, 58, + 59, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, + 0, 0, 0, 61, 62, 63, 15, 0, 101, 102, + 18, 19, 0, 0, 0, 0, 0, 103, 104, 105, + 23, 24, 25, 26, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 32, 0, 33, 34, + 35, 36, 37, 38, 0, 39, 40, 41, 0, 0, + 42, 0, 0, 43, 44, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 200, 0, 0, 111, + 49, 0, 50, 51, 0, 756, 0, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 60, 499, 0, 0, + 500, 501, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 0, 61, 241, 63, 15, + 0, 101, 102, 18, 19, 0, 0, 0, 0, 0, + 103, 104, 105, 23, 24, 25, 26, 0, 0, 106, + 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, + 0, 33, 34, 35, 36, 37, 38, 0, 39, 40, + 41, 0, 0, 42, 0, 0, 43, 44, 0, 45, + 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, + 0, 0, 111, 49, 0, 50, 51, 0, 792, 0, + 53, 54, 55, 56, 57, 58, 59, 0, 0, 60, + 499, 0, 0, 500, 501, 0, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 0, 0, 0, 0, 61, + 241, 63, 15, 0, 101, 102, 18, 19, 0, 0, + 0, 0, 0, 103, 104, 105, 23, 24, 25, 26, + 0, 0, 106, 0, 0, 0, 0, 0, 0, 0, + 0, 31, 32, 0, 33, 34, 35, 36, 37, 38, + 0, 39, 40, 41, 0, 0, 42, 0, 0, 43, + 44, 0, 45, 46, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 200, 0, 0, 111, 49, 0, 50, 51, + 0, 633, 0, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 60, 499, 0, 0, 500, 501, 0, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, + 0, 0, 61, 241, 63, 15, 0, 16, 17, 18, + 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, + 24, 25, 26, 0, 0, 106, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 32, 0, 33, 34, 35, + 36, 37, 38, 238, 39, 40, 41, 0, 0, 42, + 0, 0, 43, 44, 0, 45, 46, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 200, 0, 0, 111, 49, + 0, 50, 51, 0, 239, 240, 53, 54, 55, 56, + 57, 58, 59, 0, 0, 60, 0, 0, 0, 0, + 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 0, 0, 0, 0, 61, 241, 63, 15, 0, + 101, 102, 18, 19, 0, 0, 0, 0, 0, 103, + 104, 105, 23, 24, 25, 26, 0, 0, 106, 0, + 0, 0, 0, 0, 0, 0, 0, 31, 32, 0, + 33, 34, 35, 36, 37, 38, 238, 39, 40, 41, + 0, 0, 42, 0, 0, 43, 44, 0, 45, 46, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 200, 0, + 0, 111, 49, 0, 50, 51, 0, 239, 0, 53, + 54, 55, 56, 57, 58, 59, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 0, 0, 0, 0, 61, 241, + 63, 15, 0, 101, 102, 18, 19, 0, 0, 0, + 0, 0, 103, 104, 105, 23, 24, 25, 26, 0, + 0, 106, 0, 0, 0, 0, 0, 0, 0, 0, + 31, 32, 0, 33, 34, 35, 36, 37, 38, 238, + 39, 40, 41, 0, 0, 42, 0, 0, 43, 44, + 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 200, 0, 0, 111, 49, 0, 50, 51, 0, + 0, 240, 53, 54, 55, 56, 57, 58, 59, 0, + 0, 60, 0, 0, 0, 0, 0, 0, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, + 0, 61, 241, 63, 15, 0, 101, 102, 18, 19, + 0, 0, 0, 0, 0, 103, 104, 105, 23, 24, + 25, 26, 0, 0, 106, 0, 0, 0, 0, 0, + 0, 0, 0, 31, 32, 0, 33, 34, 35, 36, + 37, 38, 238, 39, 40, 41, 0, 0, 42, 0, + 0, 43, 44, 0, 45, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 200, 0, 0, 111, 49, 0, + 50, 51, 0, 0, 0, 53, 54, 55, 56, 57, + 58, 59, 0, 0, 60, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 0, 0, 0, 0, 61, 241, 63, 15, 0, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 106, 0, 0, + 0, 0, 0, 0, 0, 0, 31, 32, 0, 33, + 34, 35, 36, 37, 38, 0, 39, 40, 41, 0, + 0, 42, 0, 0, 43, 44, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 200, 0, 0, + 111, 49, 0, 50, 51, 0, 523, 0, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 60, 0, 0, + 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 0, 0, 0, 0, 61, 241, 63, + 15, 0, 101, 102, 18, 19, 0, 0, 0, 0, + 0, 103, 104, 105, 23, 24, 25, 26, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 32, 0, 33, 34, 35, 36, 37, 38, 0, 39, + 40, 41, 0, 0, 42, 0, 0, 43, 44, 0, + 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 111, 49, 0, 50, 51, 0, 239, + 0, 53, 54, 55, 56, 57, 58, 59, 0, 0, + 60, 0, 0, 0, 0, 0, 0, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, + 61, 241, 63, 15, 0, 101, 102, 18, 19, 0, + 0, 0, 0, 0, 103, 104, 105, 23, 24, 25, + 26, 0, 0, 106, 0, 0, 0, 0, 0, 0, + 0, 0, 31, 32, 0, 33, 34, 35, 36, 37, + 38, 0, 39, 40, 41, 0, 0, 42, 0, 0, + 43, 44, 0, 45, 46, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 200, 0, 0, 111, 49, 0, 50, + 51, 0, 523, 0, 53, 54, 55, 56, 57, 58, + 59, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, + 0, 0, 0, 61, 241, 63, 15, 0, 16, 17, + 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, + 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 32, 0, 33, 34, + 35, 36, 37, 38, 0, 39, 40, 41, 0, 0, + 42, 0, 0, 43, 44, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 200, 0, 0, 111, + 49, 0, 50, 51, 0, 0, 0, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 60, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 0, 61, 62, 63, 15, + 0, 101, 102, 18, 19, 0, 0, 0, 0, 0, + 103, 104, 105, 23, 24, 25, 26, 0, 0, 106, + 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, + 0, 33, 34, 35, 36, 37, 38, 0, 39, 40, + 41, 0, 0, 42, 0, 0, 43, 44, 0, 45, + 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, + 0, 0, 111, 49, 0, 50, 51, 0, 0, 0, + 53, 54, 55, 56, 57, 58, 59, 0, 0, 60, + 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 0, 0, 0, 0, 61, + 241, 63, 15, 0, 16, 17, 18, 19, 0, 0, + 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, + 0, 0, 106, 0, 0, 0, 0, 0, 0, 0, + 0, 31, 32, 0, 33, 34, 35, 36, 37, 38, + 0, 39, 40, 41, 0, 0, 42, 0, 0, 43, + 44, 0, 45, 46, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 200, 0, 0, 111, 49, 0, 50, 51, + 0, 0, 0, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 60, 0, 0, 0, 0, 0, 0, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, + 0, 0, 61, 241, 63, 15, 0, 101, 102, 18, + 19, 0, 0, 0, 0, 0, 103, 104, 105, 23, + 24, 25, 26, 0, 0, 106, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 32, 0, 107, 34, 35, + 36, 108, 38, 0, 39, 40, 41, 0, 0, 42, + 0, 0, 43, 44, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 109, 0, 0, 110, 0, 0, 111, 49, + 0, 50, 51, 0, 0, 0, 53, 54, 55, 56, + 57, 58, 59, 0, 0, 60, 0, 0, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, + 0, 0, 0, 0, 15, 112, 101, 102, 18, 19, + 0, 0, 0, 0, 0, 103, 104, 105, 23, 24, + 25, 26, 0, 0, 106, 0, 0, 0, 0, 0, + 0, 0, 0, 31, 32, 0, 33, 34, 35, 36, + 37, 38, 0, 39, 40, 41, 0, 0, 42, 0, + 0, 43, 44, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 211, 0, 0, 48, 49, 0, + 50, 51, 0, 52, 0, 53, 54, 55, 56, 57, + 58, 59, 0, 0, 60, 0, 0, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, + 0, 0, 0, 15, 112, 101, 102, 18, 19, 0, + 0, 0, 0, 0, 103, 104, 105, 23, 24, 25, + 26, 0, 0, 106, 0, 0, 0, 0, 0, 0, + 0, 0, 31, 32, 0, 33, 34, 35, 36, 37, + 38, 0, 39, 40, 41, 0, 0, 42, 0, 0, + 43, 44, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 286, 0, 0, 333, 49, 0, 50, + 51, 0, 334, 0, 53, 54, 55, 56, 57, 58, + 59, 0, 0, 60, 0, 0, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, + 0, 0, 15, 112, 101, 102, 18, 19, 0, 0, + 0, 0, 0, 103, 104, 105, 23, 24, 25, 26, + 0, 0, 106, 0, 0, 0, 0, 0, 0, 0, + 0, 31, 32, 0, 107, 34, 35, 36, 108, 38, + 0, 39, 40, 41, 0, 0, 42, 0, 0, 43, + 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 110, 0, 0, 111, 49, 0, 50, 51, + 0, 0, 0, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 60, 0, 0, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, + 0, 15, 112, 101, 102, 18, 19, 0, 0, 0, + 0, 0, 103, 104, 105, 23, 24, 25, 26, 0, + 0, 106, 0, 0, 0, 0, 0, 0, 0, 0, + 31, 32, 0, 33, 34, 35, 36, 37, 38, 0, + 39, 40, 41, 0, 0, 42, 0, 0, 43, 44, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 286, 0, 0, 333, 49, 0, 50, 51, 0, + 0, 0, 53, 54, 55, 56, 57, 58, 59, 0, + 0, 60, 0, 0, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, + 15, 112, 101, 102, 18, 19, 0, 0, 0, 0, + 0, 103, 104, 105, 23, 24, 25, 26, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 32, 0, 33, 34, 35, 36, 37, 38, 0, 39, + 40, 41, 0, 0, 42, 0, 0, 43, 44, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 863, 0, 0, 111, 49, 0, 50, 51, 0, 0, + 0, 53, 54, 55, 56, 57, 58, 59, 0, 0, + 60, 0, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 0, 0, 0, 0, 15, + 112, 101, 102, 18, 19, 0, 0, 0, 0, 0, + 103, 104, 105, 23, 24, 25, 26, 0, 0, 106, + 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, + 0, 33, 34, 35, 36, 37, 38, 0, 39, 40, + 41, 0, 0, 42, 0, 0, 43, 44, 0, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + -556, -556, 0, 0, 350, 351, 0, 0, 0, 881, + 0, 0, 111, 49, 0, 50, 51, 0, 0, 0, + 53, 54, 55, 56, 57, 58, 59, 0, 0, 60, + 0, 0, 572, 573, 0, 0, 574, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 0, 0, 112, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 0, 173, 174, 0, 0, 175, 176, 177, 178, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 0, 190, 191, 593, 565, 0, 0, 594, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, + 255, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 0, 0, 173, 174, 0, 0, 175, 176, 177, 178, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 0, 190, 191, 578, 573, 0, 0, 579, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 192, 255, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 0, 173, 174, 0, 0, 175, 176, 177, + 178, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 179, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 0, 190, 191, 610, 565, 0, 0, 611, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 192, 255, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 0, 173, 174, 0, 0, 175, 176, + 177, 178, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 179, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 0, 190, 191, 613, 573, 0, 0, + 614, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 192, 255, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 0, 173, 174, 0, 0, 175, + 176, 177, 178, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 0, 190, 191, 620, 565, 0, + 0, 621, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 192, 255, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 0, 0, 173, 174, 0, 0, + 175, 176, 177, 178, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 179, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 0, 190, 191, 623, 573, + 0, 0, 624, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 192, 255, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 0, 173, 174, 0, + 0, 175, 176, 177, 178, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 179, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 0, 190, 191, 655, + 565, 0, 0, 656, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 192, 255, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 0, 0, 173, 174, + 0, 0, 175, 176, 177, 178, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 179, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 0, 190, 191, + 658, 573, 0, 0, 659, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 192, 255, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 0, 173, + 174, 0, 0, 175, 176, 177, 178, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 179, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 0, 190, + 191, 939, 565, 0, 0, 940, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 192, 255, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 0, 0, + 173, 174, 0, 0, 175, 176, 177, 178, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 0, + 190, 191, 946, 565, 0, 0, 947, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 192, 255, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 0, 173, 174, 0, 0, 175, 176, 177, 178, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 0, 190, 191, 949, 573, 0, 0, 950, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, + 255, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 0, 0, 173, 174, 0, 0, 175, 176, 177, 178, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 0, 190, 191, 578, 573, 0, 0, 579, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 192, 255, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 0, 173, 174, 0, 0, 175, 176, 177, + 178, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 179, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 0, 190, 191, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 192 +}; + +static const yytype_int16 yycheck[] = +{ + 2, 83, 27, 16, 17, 248, 7, 20, 28, 208, + 5, 6, 292, 292, 62, 22, 417, 287, 13, 22, + 280, 76, 14, 10, 284, 258, 364, 390, 15, 48, + 425, 16, 17, 428, 15, 20, 28, 2, 408, 4, + 273, 52, 428, 336, 277, 336, 4, 691, 50, 51, + 388, 110, 605, 54, 468, 48, 363, 52, 365, 1, + 676, 368, 615, 597, 402, 50, 51, 65, 767, 65, + 26, 16, 17, 411, 460, 20, 765, 25, 612, 672, + 477, 76, 389, 16, 65, 672, 846, 27, 622, 676, + 16, 98, 111, 25, 401, 98, 403, 691, 105, 269, + 16, 581, 582, 865, 691, 412, 304, 26, 79, 29, + 116, 18, 119, 20, 90, 529, 88, 16, 17, 16, + 0, 20, 363, 657, 365, 88, 88, 368, 150, 25, + 90, 153, 470, 114, 16, 71, 706, 88, 502, 446, + 116, 147, 88, 713, 16, 55, 387, 28, 389, 88, + 121, 50, 143, 842, 55, 90, 116, 25, 147, 15, + 401, 116, 403, 333, 471, 25, 37, 38, 928, 410, + 149, 412, 25, 935, 146, 149, 25, 90, 120, 153, + 25, 116, 145, 146, 146, 88, 149, 143, 108, 783, + 126, 127, 128, 149, 437, 146, 895, 430, 468, 147, + 146, 434, 482, 482, 445, 446, 439, 146, 897, 65, + 152, 153, 152, 153, 147, 147, 449, 861, 416, 152, + 153, 865, 209, 210, 143, 226, 152, 153, 469, 592, + 471, 116, 287, 849, 149, 233, 152, 153, 927, 252, + 720, 254, 255, 146, 263, 247, 248, 642, 643, 149, + 269, 147, 233, 255, 116, 152, 153, 643, 114, 529, + 853, 88, 849, 25, 628, 662, 663, 252, 861, 254, + 152, 153, 636, 271, 861, 271, 269, 149, 865, 147, + 152, 153, 153, 331, 837, 699, 88, 147, 336, 149, + 271, 935, 287, 90, 147, 528, 149, 2, 147, 4, + 5, 6, 147, 268, 9, 10, 88, 252, 13, 254, + 15, 16, 17, 604, 333, 20, 88, 55, 145, 146, + 88, 147, 601, 334, 372, 373, 147, 153, 387, 51, + 58, 59, 153, 55, 25, 322, 323, 324, 325, 334, + 333, 26, 25, 48, 146, 20, 202, 52, 935, 152, + 153, 364, 208, 252, 116, 254, 321, 62, 365, 88, + 147, 326, 364, 321, 146, 728, 153, 600, 765, 90, + 767, 76, 147, 145, 146, 388, 26, 233, 146, 398, + 750, 152, 389, 91, 90, 147, 388, 406, 150, 402, + 147, 153, 652, 395, 637, 116, 403, 147, 411, 143, + 402, 71, 383, 88, 109, 412, 111, 700, 88, 411, + 116, 466, 691, 468, 948, 271, 145, 146, 651, 88, + 26, 153, 442, 279, 280, 116, 407, 408, 284, 699, + 150, 630, 331, 666, 436, 437, 837, 336, 88, 446, + 425, 443, 116, 90, 839, 842, 843, 727, 727, 88, + 442, 88, 815, 839, 88, 151, 147, 470, 143, 150, + 145, 146, 153, 144, 471, 145, 146, 88, 470, 116, + 55, 466, 457, 468, 529, 88, 145, 146, 443, 498, + 110, 147, 88, 113, 114, 147, 488, 452, 90, 491, + 71, 493, 71, 143, 199, 145, 146, 97, 895, 149, + 897, 15, 88, 13, 209, 210, 145, 146, 145, 146, + 88, 145, 146, 16, 116, 63, 759, 880, 15, 418, + 522, 150, 26, 147, 145, 146, 144, 383, 553, 90, + 927, 764, 145, 146, 529, 90, 147, 143, 147, 145, + 146, 116, 821, 149, 147, 147, 571, 252, 147, 254, + 255, 407, 408, 258, 259, 116, 37, 38, 263, 145, + 146, 116, 569, 268, 269, 51, 569, 145, 146, 51, + 577, 276, 597, 580, 577, 577, 147, 580, 580, 581, + 582, 147, 287, 921, 88, 818, 147, 612, 63, 596, + 110, 598, 147, 113, 114, 147, 598, 622, 58, 59, + 147, 602, 604, 605, 591, 607, 626, 51, 589, 53, + 54, 55, 56, 615, 90, 922, 321, 322, 323, 324, + 325, 326, 327, 328, 823, 116, 331, 90, 333, 334, + 829, 336, 657, 715, 626, 637, 18, 90, 625, 143, + 116, 145, 146, 668, 699, 149, 62, 15, 64, 65, + 669, 670, 700, 116, 71, 703, 704, 642, 15, 364, + 144, 709, 710, 116, 147, 684, 691, 372, 373, 147, + 911, 147, 51, 692, 53, 54, 55, 56, 144, 920, + 118, 922, 151, 388, 147, 390, 391, 62, 15, 64, + 65, 17, 18, 398, 147, 111, 112, 402, 717, 718, + 91, 406, 14, 147, 699, 604, 411, 124, 125, 126, + 127, 128, 56, 57, 58, 59, 735, 15, 720, 15, + 61, 147, 147, 64, 65, 152, 150, 15, 747, 748, + 144, 733, 147, 589, 736, 754, 111, 112, 443, 147, + 147, 722, 147, 9, 10, 144, 147, 452, 729, 15, + 121, 738, 147, 147, 15, 803, 15, 759, 783, 147, + 144, 466, 15, 468, 15, 470, 15, 147, 147, 750, + 111, 112, 774, 775, 630, 777, 121, 779, 780, 55, + 63, 64, 65, 785, 147, 144, 788, 789, 15, 147, + 15, 786, 55, 498, 61, 814, 652, 64, 65, 51, + 147, 53, 54, 55, 56, 147, 71, 826, 51, 147, + 53, 54, 55, 56, 147, 15, 147, 149, 2, 149, + 4, 86, 87, 443, 529, 9, 10, 822, 111, 112, + 13, 15, 16, 17, 6, 837, 20, 580, 924, 662, + 92, 928, 716, 109, 111, 112, 98, 99, 51, 92, + 53, 54, 55, 56, 923, 98, 99, 7, 123, 124, + 125, 126, 127, 128, 48, 672, 722, 886, 504, 888, + 198, 123, 891, 729, 126, 900, -1, 821, 62, 491, + 123, 493, -1, 126, 71, -1, 591, 592, 51, 92, + 53, 54, 55, 56, 750, 98, -1, 149, -1, 86, + 87, 903, 904, 905, 906, -1, 908, 909, 921, 861, + 912, -1, 914, 915, -1, 922, -1, -1, -1, 921, + 625, 923, 924, 948, -1, 109, -1, 111, 51, 92, + 53, 54, 55, 56, -1, 98, 99, 124, 125, 126, + 127, 128, -1, 209, 210, 51, -1, 51, -1, 53, + 54, 55, 56, -1, 956, 957, 958, 959, 960, -1, + 123, -1, -1, 126, 669, 670, 968, 823, -1, 92, + 63, 64, 65, 829, -1, -1, 99, -1, -1, 684, + -1, 676, -1, -1, 679, -1, -1, 692, 92, -1, + 153, -1, 258, 259, 699, 700, 691, -1, 703, 704, + 123, -1, -1, -1, 709, 710, 63, 64, 65, -1, + 276, -1, 717, 718, -1, 199, -1, -1, 111, 112, + -1, -1, -1, 728, -1, 209, 210, -1, -1, -1, + 735, -1, -1, 738, 63, 64, 65, -1, 63, 64, + 65, -1, 747, 748, -1, 63, 64, 65, 51, 754, + 53, 54, 55, 56, 111, 112, 322, 323, 324, 325, + -1, 327, 328, 40, 41, 42, 43, 44, 252, -1, + 254, 255, -1, -1, 258, 259, -1, -1, -1, 263, + -1, 786, 111, 112, 268, 269, 111, 112, -1, 92, + -1, -1, 276, 111, 112, 98, 99, -1, 803, -1, + -1, -1, 63, 64, 65, -1, -1, -1, -1, 814, + 815, 2, -1, 4, 5, 6, 7, 822, -1, -1, + 123, 826, 13, 126, 51, 391, 53, 54, 55, 56, + -1, -1, 238, 239, 240, -1, -1, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 149, 331, -1, 333, + 111, 112, 336, -1, 849, -1, 851, 48, -1, -1, + 855, 52, 774, 775, -1, 777, -1, 779, 780, -1, + 865, -1, 867, 785, -1, 880, 788, 789, -1, -1, + 364, 886, -1, 888, -1, 76, 891, -1, 372, 373, + 51, -1, 53, 54, 55, 56, -1, -1, -1, -1, + 297, -1, -1, -1, 388, -1, 390, 391, 305, -1, + -1, 308, -1, 310, 398, 312, 921, 314, 402, -1, + 111, -1, 406, -1, -1, 331, -1, 411, -1, -1, + 336, 92, -1, -1, -1, -1, 931, 98, 0, -1, + 935, -1, 937, -1, -1, -1, -1, 942, -1, -1, + -1, 13, 14, 15, 16, 17, 18, -1, 20, 443, + -1, -1, -1, -1, 26, 27, -1, -1, 452, 964, + -1, -1, -1, -1, -1, 37, 38, -1, 40, 41, + 42, 43, 44, -1, -1, -1, 470, -1, -1, -1, + -1, 903, 904, 905, 906, -1, 908, 909, -1, -1, + 912, -1, 914, 915, -1, -1, -1, -1, 199, -1, + -1, -1, 418, -1, 498, -1, -1, -1, 424, 425, + -1, -1, 428, -1, -1, 591, 88, -1, -1, -1, + -1, -1, -1, 16, 17, -1, -1, 20, -1, -1, + -1, -1, -1, -1, 956, 957, 958, 959, 960, 71, + -1, 457, -1, -1, 460, -1, 968, -1, -1, 625, + -1, -1, 45, 46, 86, 87, -1, 50, 51, -1, + -1, -1, 263, -1, -1, -1, -1, 268, 269, 62, + 63, 143, 144, 489, 146, -1, -1, 149, 150, -1, + 152, 153, -1, -1, -1, -1, 287, -1, -1, 121, + 122, 123, 124, 125, 126, 127, 128, 591, 592, 71, + 72, 73, 74, 75, 76, 77, 78, 523, 80, 81, + -1, -1, -1, -1, 86, 87, -1, -1, -1, -1, + 321, -1, -1, -1, -1, 326, -1, -1, -1, -1, + -1, 625, 333, 334, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, -1, -1, -1, + -1, -1, 738, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 669, 670, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 604, 390, + 684, -1, -1, -1, -1, -1, -1, 398, 692, -1, + -1, -1, -1, -1, -1, 406, 700, -1, -1, 703, + 704, -1, -1, -1, -1, 709, 710, 633, -1, -1, + 636, -1, -1, 717, 718, -1, 642, 643, -1, -1, + -1, -1, -1, -1, 728, -1, -1, -1, -1, -1, + -1, 735, 443, -1, 738, 238, 239, 240, 241, -1, + -1, 452, -1, 747, 748, -1, -1, -1, -1, 252, + 754, 254, 255, -1, -1, 466, -1, 468, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 696, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 498, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 803, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 814, 815, -1, -1, -1, -1, -1, -1, 529, -1, + -1, -1, 826, -1, -1, -1, -1, 753, 331, -1, + 756, -1, -1, 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, + 2, 364, 4, 5, 6, -1, 792, -1, -1, 372, + 373, 13, -1, -1, -1, -1, 880, -1, -1, -1, + -1, 592, 886, -1, 888, 388, -1, 891, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 400, -1, 402, + -1, 404, 405, -1, -1, -1, 48, -1, 411, -1, + 52, -1, -1, 839, -1, 418, -1, 921, -1, -1, + -1, 424, 425, -1, -1, 428, -1, -1, -1, -1, + -1, -1, -1, -1, 76, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 447, -1, -1, -1, -1, -1, + -1, -1, -1, 2, 457, 4, -1, 460, 669, 670, + -1, -1, -1, -1, 13, -1, -1, 470, -1, 111, + -1, -1, -1, 684, -1, -1, -1, -1, -1, -1, + -1, 692, -1, -1, -1, -1, 489, -1, 699, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 48, + -1, -1, -1, -1, -1, -1, 717, 718, -1, 512, + 513, -1, -1, -1, -1, -1, -1, 728, -1, -1, + 523, -1, -1, -1, 735, -1, -1, -1, -1, 71, + 72, 73, 74, 75, 76, 77, 747, 748, 80, 81, + -1, -1, -1, 754, 86, 87, -1, -1, -1, -1, + -1, -1, 2, -1, 4, -1, -1, 199, -1, -1, + -1, -1, 111, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 786, -1, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 48, -1, + -1, 604, -1, 814, 815, -1, -1, -1, -1, -1, + -1, 822, -1, -1, -1, 826, -1, -1, -1, -1, + -1, 263, -1, -1, -1, -1, 268, 269, -1, -1, + 633, -1, -1, 636, -1, -1, -1, -1, -1, 642, + 643, -1, -1, -1, -1, 287, -1, -1, -1, -1, + 199, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 111, -1, -1, -1, -1, -1, -1, -1, 880, + -1, -1, -1, -1, -1, 886, -1, 888, -1, 321, + 891, -1, -1, -1, 326, -1, -1, -1, -1, -1, + -1, 333, 334, 696, -1, -1, -1, 700, 701, -1, + 703, 704, -1, -1, -1, -1, 709, 710, -1, -1, + -1, -1, -1, -1, 263, -1, 719, -1, -1, 268, + 269, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 741, 742, + -1, 744, 745, -1, -1, -1, -1, -1, 390, 199, + 753, -1, -1, 756, -1, -1, 398, -1, -1, -1, + -1, -1, -1, -1, 406, -1, -1, -1, -1, -1, + -1, -1, 321, -1, -1, -1, -1, 326, -1, -1, + -1, -1, -1, -1, 333, -1, -1, 336, -1, 792, + -1, -1, -1, 796, -1, -1, -1, -1, -1, -1, + 803, 443, -1, -1, -1, -1, -1, -1, -1, -1, + 452, -1, -1, 263, -1, -1, -1, -1, 268, 269, + -1, -1, -1, -1, 466, -1, 468, -1, 831, -1, + -1, 44, -1, -1, -1, -1, 839, -1, -1, -1, + -1, 390, -1, -1, -1, -1, -1, -1, -1, 398, + -1, -1, -1, -1, -1, -1, 498, 406, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 321, -1, 86, 87, -1, 326, -1, -1, -1, + -1, -1, -1, 333, -1, -1, -1, 529, -1, -1, + -1, -1, -1, -1, 443, -1, -1, -1, -1, -1, + -1, -1, -1, 452, 117, -1, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, -1, 921, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 147, -1, -1, -1, -1, -1, + 390, 51, 52, -1, -1, 55, -1, -1, 398, 498, + 592, -1, -1, -1, -1, -1, 406, -1, -1, 69, + 70, 71, 72, 73, 74, 75, 76, 77, -1, -1, + 80, 81, -1, -1, 84, 85, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 98, -1, + -1, -1, -1, 443, -1, -1, -1, -1, -1, -1, + -1, -1, 452, -1, -1, -1, -1, -1, -1, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, -1, + 130, 131, -1, -1, -1, -1, -1, 669, 670, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 148, 149, + -1, -1, 684, 592, -1, -1, -1, -1, 498, -1, + 692, -1, -1, -1, -1, -1, -1, 699, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 717, 718, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 728, -1, -1, -1, + -1, -1, -1, 735, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 747, 748, -1, -1, -1, + -1, -1, 754, -1, -1, -1, -1, -1, -1, -1, + 669, 670, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 684, -1, -1, -1, -1, + -1, -1, 592, 692, 786, -1, -1, -1, -1, -1, + -1, 700, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 717, 718, + -1, -1, 814, 815, -1, -1, -1, -1, -1, 728, + 822, -1, -1, -1, 826, -1, 735, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 747, 748, + -1, -1, -1, -1, -1, 754, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 669, + 670, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 684, -1, -1, -1, 880, -1, + -1, -1, 692, -1, 886, -1, 888, -1, -1, 891, + -1, -1, 117, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, 814, 815, 717, 718, -1, + -1, -1, -1, 822, -1, -1, -1, 826, 728, -1, + -1, -1, -1, -1, -1, 735, -1, -1, 153, -1, + -1, -1, -1, -1, -1, -1, -1, 747, 748, -1, + -1, -1, -1, -1, 754, -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, 880, -1, -1, -1, -1, -1, 886, -1, 888, + -1, -1, 891, -1, -1, -1, -1, -1, -1, -1, + 0, 1, -1, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, -1, 814, 815, -1, -1, -1, 19, + -1, 21, 22, 23, 24, -1, 826, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, 45, 46, 47, 48, 49, + -1, 51, 52, 53, 54, 55, 56, -1, 58, 59, + 60, -1, -1, 63, -1, -1, 66, 67, -1, 69, + 70, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 880, -1, -1, -1, -1, -1, 886, -1, 888, 89, + -1, 891, 92, 93, -1, 95, 96, 0, 98, -1, + 100, 101, 102, 103, 104, 105, 106, -1, -1, 109, + 13, 14, 15, 16, 17, 18, -1, 20, -1, -1, + -1, -1, -1, -1, 27, 28, 29, -1, -1, 129, + 130, 131, -1, -1, 37, 38, -1, 40, 41, 42, + 43, 44, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 152, 153, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, -1, -1, 86, 87, 88, -1, 90, 91, -1, + -1, -1, -1, -1, 97, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 108, -1, -1, -1, -1, + -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, + -1, 144, 145, 146, 147, -1, -1, 150, 151, 152, + 153, 13, 14, 15, 16, 17, 18, -1, 20, -1, + -1, 44, -1, -1, 26, 27, 28, -1, -1, -1, + -1, -1, -1, -1, -1, 37, 38, -1, 40, 41, + 42, 43, 44, -1, -1, -1, -1, -1, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, -1, -1, 86, 87, -1, -1, -1, -1, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, -1, -1, 86, 87, 88, -1, -1, 91, + -1, -1, -1, -1, 117, 97, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 117, -1, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, + -1, 143, 144, 145, 146, 147, -1, 149, 150, 151, + 152, 153, 13, 14, 15, 16, 17, 18, -1, 20, + -1, -1, 44, -1, -1, -1, 27, 28, 29, -1, + -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, + 41, 42, 43, 44, -1, -1, -1, -1, -1, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, -1, -1, 86, 87, -1, -1, -1, -1, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, -1, -1, 86, 87, 88, -1, -1, + 91, -1, -1, -1, -1, 117, 97, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 108, -1, -1, + -1, -1, -1, -1, -1, -1, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, -1, -1, 144, 145, 146, 147, -1, -1, 150, + 151, 152, 153, 13, 14, 15, 16, 17, 18, -1, + 20, -1, -1, -1, -1, -1, 26, 27, 28, -1, + -1, -1, -1, -1, -1, -1, -1, 37, 38, -1, + 40, 41, 42, 43, 44, -1, -1, -1, -1, -1, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, -1, -1, 86, 87, -1, -1, -1, + -1, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, -1, -1, 86, 87, 88, -1, + -1, 91, -1, -1, -1, -1, 117, 97, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 117, -1, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 0, -1, 143, 144, 145, 146, 147, -1, 149, + 150, 151, 152, 153, 13, 14, 15, 16, 17, 18, + -1, 20, -1, -1, -1, -1, -1, -1, 27, 28, + -1, -1, -1, -1, -1, -1, -1, -1, 37, 38, + -1, 40, 41, 42, 43, 44, -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, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, -1, -1, 86, 87, 88, + -1, -1, 91, 0, -1, -1, -1, -1, 97, -1, + -1, -1, -1, -1, -1, -1, 13, 14, 15, -1, + 17, 18, -1, 20, -1, -1, -1, -1, 117, 26, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 37, 38, -1, 40, 41, 42, 43, 44, -1, -1, + -1, -1, -1, -1, -1, 144, 145, 146, 147, -1, + 149, 150, 151, 152, 153, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, -1, -1, 86, + 87, 88, -1, 90, -1, 0, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 13, 14, + 15, -1, 17, 18, -1, 20, -1, -1, -1, 116, + 117, -1, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 37, 38, -1, 40, 41, 42, 43, 44, + -1, -1, -1, -1, -1, -1, 143, 144, 145, 146, + 147, -1, -1, 150, -1, 152, 153, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, -1, + -1, 86, 87, 88, -1, 90, -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, 116, 117, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 144, + 145, 146, 147, -1, -1, 150, -1, 152, 153, 1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, -1, -1, 18, 19, -1, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, 45, -1, 47, 48, 49, -1, 51, + 52, 53, 54, 55, 56, -1, 58, 59, 60, -1, + -1, 63, -1, -1, 66, 67, -1, 69, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 89, -1, -1, + 92, 93, -1, 95, 96, -1, 98, -1, 100, 101, + 102, 103, 104, 105, 106, -1, -1, 109, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 129, 130, 131, + -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 152, 153, 15, -1, 17, 18, 19, -1, 21, 22, + 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, + -1, -1, 45, -1, 47, 48, 49, -1, 51, 52, + 53, 54, 55, 56, -1, 58, 59, 60, -1, -1, + 63, -1, -1, 66, 67, -1, 69, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89, -1, -1, 92, + 93, -1, 95, 96, -1, 98, -1, 100, 101, 102, + 103, 104, 105, 106, -1, -1, 109, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 129, 130, 131, -1, + -1, -1, -1, -1, 1, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, -1, -1, 15, 152, + 153, 18, 19, 20, 21, 22, 23, 24, -1, -1, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + -1, -1, 39, -1, -1, -1, -1, -1, 45, -1, + 47, 48, 49, -1, 51, 52, 53, 54, 55, 56, + -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, + 67, -1, 69, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, -1, -1, 92, 93, -1, 95, 96, + -1, 98, -1, 100, 101, 102, 103, 104, 105, 106, + -1, -1, 109, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 129, 130, 131, -1, -1, -1, -1, -1, + 1, -1, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, -1, -1, 15, 152, 153, 18, 19, -1, + 21, 22, 23, 24, -1, -1, -1, -1, -1, 30, + 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, + -1, -1, -1, -1, 45, -1, 47, 48, 49, -1, + 51, 52, 53, 54, 55, 56, -1, 58, 59, 60, + -1, -1, 63, -1, -1, 66, 67, -1, 69, 70, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 89, -1, + -1, 92, 93, -1, 95, 96, -1, 98, -1, 100, + 101, 102, 103, 104, 105, 106, -1, -1, 109, -1, + -1, -1, -1, -1, -1, 1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, -1, 129, 130, + 131, -1, -1, 19, -1, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, 152, 153, 39, -1, -1, -1, -1, -1, 45, + 46, 47, 48, 49, -1, 51, 52, 53, 54, 55, + 56, -1, 58, 59, 60, -1, -1, 63, -1, -1, + 66, 67, -1, 69, 70, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, -1, -1, 92, 93, -1, 95, + 96, -1, 98, -1, 100, 101, 102, 103, 104, 105, + 106, -1, -1, 109, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 129, 130, 131, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 144, -1, + -1, -1, -1, -1, -1, -1, 152, 153, 1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + -1, 14, 15, -1, -1, -1, 19, -1, 21, 22, + 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, + -1, -1, 45, -1, 47, 48, 49, -1, 51, 52, + 53, 54, 55, 56, -1, 58, 59, 60, -1, -1, + 63, -1, -1, 66, 67, -1, 69, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89, -1, -1, 92, + 93, -1, 95, 96, -1, 98, -1, 100, 101, 102, + 103, 104, 105, 106, -1, -1, 109, -1, -1, -1, + -1, -1, -1, 1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, -1, 129, 130, 131, -1, + -1, 19, -1, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, 152, + 153, 39, -1, -1, -1, -1, -1, 45, -1, 47, + 48, 49, -1, 51, 52, 53, 54, 55, 56, -1, + 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, + -1, 69, 70, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 89, -1, -1, 92, 93, -1, 95, 96, -1, + 98, -1, 100, 101, 102, 103, 104, 105, 106, -1, + -1, 109, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 129, 130, 131, -1, -1, -1, -1, 1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + -1, -1, 150, -1, 152, 153, 19, -1, 21, 22, + 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, + -1, -1, 45, -1, 47, 48, 49, -1, 51, 52, + 53, 54, 55, 56, -1, 58, 59, 60, -1, -1, + 63, -1, -1, 66, 67, -1, 69, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89, -1, -1, 92, + 93, -1, 95, 96, -1, 98, -1, 100, 101, 102, + 103, 104, 105, 106, -1, -1, 109, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 129, 130, 131, -1, + -1, -1, -1, 1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, -1, -1, 150, -1, 152, + 153, 19, -1, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, 45, -1, 47, + 48, 49, -1, 51, 52, 53, 54, 55, 56, -1, + 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, + -1, 69, 70, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 89, -1, -1, 92, 93, -1, 95, 96, -1, + 98, -1, 100, 101, 102, 103, 104, 105, 106, -1, + -1, 109, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 129, 130, 131, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 144, -1, -1, -1, + -1, -1, -1, -1, 152, 153, 1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, + 15, -1, -1, -1, 19, -1, 21, 22, 23, 24, + -1, -1, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, + 45, -1, 47, 48, 49, -1, 51, 52, 53, 54, + 55, 56, -1, 58, 59, 60, -1, -1, 63, -1, + -1, 66, 67, -1, 69, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, 92, 93, -1, + 95, 96, -1, 98, -1, 100, 101, 102, 103, 104, + 105, 106, -1, -1, 109, -1, -1, -1, -1, -1, + -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, + 10, 11, -1, -1, 129, 130, 131, -1, -1, 19, + -1, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, 152, 153, 39, + -1, -1, -1, -1, -1, -1, -1, -1, 48, 49, + -1, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, -1, -1, 63, -1, -1, 66, 67, -1, 69, + 70, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 89, + -1, -1, 92, 93, -1, 95, 96, -1, 98, 99, + 100, 101, 102, 103, 104, 105, 106, -1, -1, 109, + -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, -1, -1, -1, -1, 129, + 130, 131, 19, -1, 21, 22, 23, 24, -1, -1, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + -1, -1, 39, 153, -1, -1, -1, -1, -1, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, 56, + -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, + 67, -1, 69, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, -1, -1, 92, 93, -1, 95, 96, + -1, -1, -1, 100, 101, 102, 103, 104, 105, 106, + -1, -1, 109, -1, -1, -1, -1, -1, -1, -1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + -1, -1, 129, 130, 131, -1, -1, 19, -1, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, 152, 153, 39, -1, -1, + -1, -1, -1, -1, -1, -1, 48, 49, -1, 51, + 52, 53, 54, 55, 56, -1, 58, 59, 60, -1, + -1, 63, -1, -1, 66, 67, -1, 69, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 89, -1, -1, + 92, 93, -1, 95, 96, -1, -1, -1, 100, 101, + 102, 103, 104, 105, 106, -1, -1, 109, -1, -1, + -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, -1, -1, -1, 129, 130, 131, + 19, -1, 21, 22, 23, 24, -1, -1, -1, -1, + -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, + 39, 153, -1, -1, -1, -1, 45, 46, 47, 48, + 49, -1, 51, 52, 53, 54, 55, 56, -1, 58, + 59, 60, -1, -1, 63, -1, -1, 66, 67, -1, + 69, 70, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 89, -1, -1, 92, 93, -1, 95, 96, -1, 98, + -1, 100, 101, 102, 103, 104, 105, 106, -1, -1, + 109, -1, -1, -1, -1, -1, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, + 129, 130, 131, -1, 19, -1, 21, 22, 23, 24, + -1, -1, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, -1, 152, 39, -1, -1, -1, -1, -1, + 45, -1, 47, 48, 49, -1, 51, 52, 53, 54, + 55, 56, -1, 58, 59, 60, -1, -1, 63, -1, + -1, 66, 67, -1, 69, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, 92, 93, -1, + 95, 96, -1, 98, -1, 100, 101, 102, 103, 104, + 105, 106, -1, -1, 109, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 129, 130, 131, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 152, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, -1, -1, -1, -1, -1, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 69, 70, 71, 72, 73, 74, + 75, 76, 77, -1, -1, 80, 81, -1, -1, 84, + 85, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 98, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, 130, 131, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, + -1, -1, -1, 148, 149, 19, -1, 21, 22, 23, + 24, -1, 26, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, -1, -1, 48, 49, -1, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, -1, -1, 63, + -1, -1, 66, 67, -1, 69, 70, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 89, -1, -1, 92, 93, + -1, 95, 96, -1, 98, 99, 100, 101, 102, 103, + 104, 105, 106, -1, -1, 109, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 129, 130, 131, 3, 4, + 5, 6, 7, 8, 9, 10, 11, -1, -1, 143, + -1, -1, -1, -1, 19, 149, 21, 22, 23, 24, + -1, 26, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, + -1, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, -1, -1, 63, -1, + -1, 66, 67, -1, 69, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, 92, 93, -1, + 95, 96, -1, 98, 99, 100, 101, 102, 103, 104, + 105, 106, -1, -1, 109, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 129, 130, 131, 3, 4, 5, + 6, 7, 8, 9, 10, 11, -1, -1, 143, -1, + -1, -1, -1, 19, 149, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, + -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, -1, -1, 63, -1, -1, + 66, 67, -1, 69, 70, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, 90, -1, 92, 93, -1, 95, + 96, -1, 98, 99, 100, 101, 102, 103, 104, 105, + 106, -1, -1, 109, -1, -1, -1, -1, -1, -1, + 116, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 129, 130, 131, 3, 4, 5, 6, + 7, 8, 9, 10, 11, -1, -1, -1, -1, -1, + -1, -1, 19, 149, 21, 22, 23, 24, -1, -1, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, -1, -1, 63, -1, -1, 66, + 67, -1, 69, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, -1, -1, 92, 93, -1, 95, 96, + -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, + -1, -1, 109, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 129, 130, 131, 3, 4, 5, 6, 7, + 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, + -1, 19, 149, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, + 48, 49, -1, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, + -1, 69, 70, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 89, -1, -1, 92, 93, -1, 95, 96, -1, + 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, + -1, 109, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 129, 130, 131, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 149, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, -1, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, + -1, -1, -1, -1, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, -1, -1, -1, -1, + -1, -1, 63, -1, -1, -1, -1, -1, 69, 70, + 71, 72, 73, 74, 75, 76, 77, -1, -1, 80, + 81, -1, -1, 84, 85, 86, 87, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 98, -1, -1, + -1, -1, -1, -1, 105, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, 130, + 131, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 148, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, -1, -1, -1, -1, -1, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, -1, -1, -1, -1, -1, -1, 63, -1, + -1, -1, -1, -1, 69, 70, 71, 72, 73, 74, + 75, 76, 77, -1, -1, 80, 81, -1, -1, 84, + 85, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 98, -1, -1, -1, -1, -1, -1, + 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, 130, 131, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 148, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, + -1, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, -1, -1, -1, -1, -1, 45, 46, 47, 48, + 49, 50, 51, 52, -1, -1, 55, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 69, 70, 71, 72, 73, 74, 75, 76, 77, -1, + -1, 80, 81, -1, -1, 84, 85, 86, 87, -1, + -1, 71, 72, 73, 74, 75, 76, 77, -1, 98, + 80, 81, 101, -1, -1, -1, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, 130, 131, -1, -1, -1, -1, -1, -1, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 148, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, -1, -1, -1, + -1, -1, 45, 46, 47, 48, 49, 50, 51, 52, + -1, -1, 55, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 69, 70, 71, 72, + 73, 74, 75, 76, 77, -1, -1, 80, 81, -1, + -1, 84, 85, 86, 87, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 98, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, 130, 131, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, + -1, -1, -1, -1, -1, 148, 19, -1, 21, 22, + 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, + -1, -1, -1, -1, -1, 48, 49, -1, 51, 52, + 53, 54, 55, 56, -1, 58, 59, 60, -1, -1, + 63, -1, -1, 66, 67, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89, -1, -1, 92, + 93, -1, 95, 96, -1, -1, -1, 100, 101, 102, + 103, 104, 105, 106, -1, -1, 109, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, + -1, -1, -1, -1, -1, 19, 129, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, 147, 39, -1, -1, -1, -1, + -1, -1, -1, -1, 48, 49, -1, 51, 52, 53, + 54, 55, 56, -1, 58, 59, 60, -1, -1, 63, + -1, -1, 66, 67, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 89, -1, -1, 92, 93, + -1, 95, 96, -1, -1, -1, 100, 101, 102, 103, + 104, 105, 106, -1, -1, 109, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, + -1, -1, -1, -1, 19, 129, 21, 22, 23, 24, + -1, -1, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, -1, 147, 39, -1, -1, -1, -1, -1, + -1, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, -1, -1, 63, -1, + -1, 66, 67, -1, 69, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, 92, 93, -1, + 95, 96, -1, 98, 99, 100, 101, 102, 103, 104, + 105, 106, -1, -1, 109, 110, -1, -1, 113, 114, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, -1, -1, -1, 129, 130, 131, 19, -1, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, 45, 46, 47, 48, 49, -1, 51, + 52, 53, 54, 55, 56, -1, 58, 59, 60, -1, + -1, 63, -1, -1, 66, 67, -1, 69, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 89, -1, -1, + 92, 93, -1, 95, 96, -1, 98, -1, 100, 101, + 102, 103, 104, 105, 106, -1, -1, 109, -1, -1, + -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, -1, -1, -1, -1, 129, 130, 131, + 19, -1, 21, 22, 23, 24, -1, -1, -1, -1, + -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, + 39, -1, -1, -1, -1, -1, -1, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, -1, -1, 63, -1, -1, 66, 67, -1, + 69, 70, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 89, -1, -1, 92, 93, -1, 95, 96, -1, 98, + -1, 100, 101, 102, 103, 104, 105, 106, -1, -1, + 109, 110, -1, -1, 113, 114, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, + 129, 130, 131, 19, -1, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, + -1, 47, 48, 49, -1, 51, 52, 53, 54, 55, + 56, -1, 58, 59, 60, -1, -1, 63, -1, -1, + 66, 67, -1, 69, 70, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, -1, -1, 92, 93, -1, 95, + 96, -1, 98, -1, 100, 101, 102, 103, 104, 105, + 106, -1, -1, 109, -1, -1, -1, -1, -1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, + -1, -1, -1, 129, 130, 131, 19, -1, 21, 22, + 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, + -1, -1, -1, -1, -1, 48, 49, -1, 51, 52, + 53, 54, 55, 56, -1, 58, 59, 60, -1, -1, + 63, -1, -1, 66, 67, -1, 69, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89, -1, -1, 92, + 93, -1, 95, 96, -1, 98, -1, 100, 101, 102, + 103, 104, 105, 106, -1, -1, 109, 110, -1, -1, + 113, 114, -1, 3, 4, 5, 6, 7, 8, 9, + 10, 11, -1, -1, -1, -1, 129, 130, 131, 19, + -1, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, -1, -1, 48, 49, + -1, 51, 52, 53, 54, 55, 56, -1, 58, 59, + 60, -1, -1, 63, -1, -1, 66, 67, -1, 69, + 70, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 89, + -1, -1, 92, 93, -1, 95, 96, -1, 98, -1, + 100, 101, 102, 103, 104, 105, 106, -1, -1, 109, + 110, -1, -1, 113, 114, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, -1, -1, -1, -1, 129, + 130, 131, 19, -1, 21, 22, 23, 24, -1, -1, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, 56, + -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, + 67, -1, 69, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, -1, -1, 92, 93, -1, 95, 96, + -1, 98, -1, 100, 101, 102, 103, 104, 105, 106, + -1, -1, 109, 110, -1, -1, 113, 114, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, + -1, -1, 129, 130, 131, 19, -1, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, -1, -1, 48, 49, -1, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, -1, -1, 63, + -1, -1, 66, 67, -1, 69, 70, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 89, -1, -1, 92, 93, + -1, 95, 96, -1, 98, 99, 100, 101, 102, 103, + 104, 105, 106, -1, -1, 109, -1, -1, -1, -1, + -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, + 11, -1, -1, -1, -1, 129, 130, 131, 19, -1, + 21, 22, 23, 24, -1, -1, -1, -1, -1, 30, + 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, + -1, -1, -1, -1, -1, -1, -1, 48, 49, -1, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + -1, -1, 63, -1, -1, 66, 67, -1, 69, 70, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 89, -1, + -1, 92, 93, -1, 95, 96, -1, 98, -1, 100, + 101, 102, 103, 104, 105, 106, -1, -1, 109, -1, + -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, -1, -1, -1, -1, 129, 130, + 131, 19, -1, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, + 48, 49, -1, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, + -1, 69, 70, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 89, -1, -1, 92, 93, -1, 95, 96, -1, + -1, 99, 100, 101, 102, 103, 104, 105, 106, -1, + -1, 109, -1, -1, -1, -1, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, + -1, 129, 130, 131, 19, -1, 21, 22, 23, 24, + -1, -1, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, + -1, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, -1, -1, 63, -1, + -1, 66, 67, -1, 69, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, 92, 93, -1, + 95, 96, -1, -1, -1, 100, 101, 102, 103, 104, + 105, 106, -1, -1, 109, -1, -1, -1, -1, -1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + -1, -1, -1, -1, 129, 130, 131, 19, -1, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, -1, -1, 48, 49, -1, 51, + 52, 53, 54, 55, 56, -1, 58, 59, 60, -1, + -1, 63, -1, -1, 66, 67, -1, 69, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 89, -1, -1, + 92, 93, -1, 95, 96, -1, 98, -1, 100, 101, + 102, 103, 104, 105, 106, -1, -1, 109, -1, -1, + -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, -1, -1, -1, -1, 129, 130, 131, + 19, -1, 21, 22, 23, 24, -1, -1, -1, -1, + -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, + 39, -1, -1, -1, -1, -1, -1, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, 56, -1, 58, + 59, 60, -1, -1, 63, -1, -1, 66, 67, -1, + 69, 70, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 89, -1, -1, 92, 93, -1, 95, 96, -1, 98, + -1, 100, 101, 102, 103, 104, 105, 106, -1, -1, + 109, -1, -1, -1, -1, -1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, + 129, 130, 131, 19, -1, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, + -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, + 56, -1, 58, 59, 60, -1, -1, 63, -1, -1, + 66, 67, -1, 69, 70, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, -1, -1, 92, 93, -1, 95, + 96, -1, 98, -1, 100, 101, 102, 103, 104, 105, + 106, -1, -1, 109, -1, -1, -1, -1, -1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, + -1, -1, -1, 129, 130, 131, 19, -1, 21, 22, + 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, + -1, -1, -1, -1, -1, 48, 49, -1, 51, 52, + 53, 54, 55, 56, -1, 58, 59, 60, -1, -1, + 63, -1, -1, 66, 67, -1, 69, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89, -1, -1, 92, + 93, -1, 95, 96, -1, -1, -1, 100, 101, 102, + 103, 104, 105, 106, -1, -1, 109, -1, -1, -1, + -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, + 10, 11, -1, -1, -1, -1, 129, 130, 131, 19, + -1, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, -1, -1, 48, 49, + -1, 51, 52, 53, 54, 55, 56, -1, 58, 59, + 60, -1, -1, 63, -1, -1, 66, 67, -1, 69, + 70, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 89, + -1, -1, 92, 93, -1, 95, 96, -1, -1, -1, + 100, 101, 102, 103, 104, 105, 106, -1, -1, 109, + -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, -1, -1, -1, -1, 129, + 130, 131, 19, -1, 21, 22, 23, 24, -1, -1, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, 56, + -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, + 67, -1, 69, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, -1, -1, 92, 93, -1, 95, 96, + -1, -1, -1, 100, 101, 102, 103, 104, 105, 106, + -1, -1, 109, -1, -1, -1, -1, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, + -1, -1, 129, 130, 131, 19, -1, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, -1, -1, 48, 49, -1, 51, 52, 53, + 54, 55, 56, -1, 58, 59, 60, -1, -1, 63, + -1, -1, 66, 67, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 86, -1, -1, 89, -1, -1, 92, 93, + -1, 95, 96, -1, -1, -1, 100, 101, 102, 103, + 104, 105, 106, -1, -1, 109, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, + -1, -1, -1, -1, 19, 129, 21, 22, 23, 24, + -1, -1, -1, -1, -1, 30, 31, 32, 33, 34, + 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, + -1, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, 56, -1, 58, 59, 60, -1, -1, 63, -1, + -1, 66, 67, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, 92, 93, -1, + 95, 96, -1, 98, -1, 100, 101, 102, 103, 104, + 105, 106, -1, -1, 109, -1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, + -1, -1, -1, 19, 129, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, + -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, + 56, -1, 58, 59, 60, -1, -1, 63, -1, -1, + 66, 67, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, -1, -1, 92, 93, -1, 95, + 96, -1, 98, -1, 100, 101, 102, 103, 104, 105, + 106, -1, -1, 109, -1, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, -1, -1, -1, -1, -1, + -1, -1, 19, 129, 21, 22, 23, 24, -1, -1, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, 56, + -1, 58, 59, 60, -1, -1, 63, -1, -1, 66, + 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, -1, -1, 92, 93, -1, 95, 96, + -1, -1, -1, 100, 101, 102, 103, 104, 105, 106, + -1, -1, 109, -1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, + -1, 19, 129, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, + 48, 49, -1, 51, 52, 53, 54, 55, 56, -1, + 58, 59, 60, -1, -1, 63, -1, -1, 66, 67, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 89, -1, -1, 92, 93, -1, 95, 96, -1, + -1, -1, 100, 101, 102, 103, 104, 105, 106, -1, + -1, 109, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, -1, -1, -1, -1, -1, -1, -1, + 19, 129, 21, 22, 23, 24, -1, -1, -1, -1, + -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, + 39, -1, -1, -1, -1, -1, -1, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, 56, -1, 58, + 59, 60, -1, -1, 63, -1, -1, 66, 67, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 89, -1, -1, 92, 93, -1, 95, 96, -1, -1, + -1, 100, 101, 102, 103, 104, 105, 106, -1, -1, + 109, -1, -1, 3, 4, 5, 6, 7, 8, 9, + 10, 11, -1, -1, -1, -1, -1, -1, -1, 19, + 129, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, -1, -1, 48, 49, + -1, 51, 52, 53, 54, 55, 56, -1, 58, 59, + 60, -1, -1, 63, -1, -1, 66, 67, -1, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, -1, -1, 86, 87, -1, -1, -1, 89, + -1, -1, 92, 93, -1, 95, 96, -1, -1, -1, + 100, 101, 102, 103, 104, 105, 106, -1, -1, 109, + -1, -1, 51, 52, -1, -1, 55, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, -1, -1, 129, + 69, 70, 71, 72, 73, 74, 75, 76, 77, -1, + -1, 80, 81, -1, -1, 84, 85, 86, 87, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 98, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, 130, 131, 51, 52, -1, -1, 55, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 148, + 149, 69, 70, 71, 72, 73, 74, 75, 76, 77, + -1, -1, 80, 81, -1, -1, 84, 85, 86, 87, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 51, 52, -1, -1, 55, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 148, 149, 69, 70, 71, 72, 73, 74, 75, 76, + 77, -1, -1, 80, 81, -1, -1, 84, 85, 86, + 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 98, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, 130, 131, 51, 52, -1, -1, 55, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 148, 149, 69, 70, 71, 72, 73, 74, 75, + 76, 77, -1, -1, 80, 81, -1, -1, 84, 85, + 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 98, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, -1, 130, 131, 51, 52, -1, -1, + 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 148, 149, 69, 70, 71, 72, 73, 74, + 75, 76, 77, -1, -1, 80, 81, -1, -1, 84, + 85, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 98, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, 130, 131, 51, 52, -1, + -1, 55, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 148, 149, 69, 70, 71, 72, 73, + 74, 75, 76, 77, -1, -1, 80, 81, -1, -1, + 84, 85, 86, 87, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 98, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, -1, 130, 131, 51, 52, + -1, -1, 55, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 148, 149, 69, 70, 71, 72, + 73, 74, 75, 76, 77, -1, -1, 80, 81, -1, + -1, 84, 85, 86, 87, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 98, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, 130, 131, 51, + 52, -1, -1, 55, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 148, 149, 69, 70, 71, + 72, 73, 74, 75, 76, 77, -1, -1, 80, 81, + -1, -1, 84, 85, 86, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 98, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, -1, 130, 131, + 51, 52, -1, -1, 55, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 148, 149, 69, 70, + 71, 72, 73, 74, 75, 76, 77, -1, -1, 80, + 81, -1, -1, 84, 85, 86, 87, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 98, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, 130, + 131, 51, 52, -1, -1, 55, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 148, 149, 69, + 70, 71, 72, 73, 74, 75, 76, 77, -1, -1, + 80, 81, -1, -1, 84, 85, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 98, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, -1, + 130, 131, 51, 52, -1, -1, 55, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 148, 149, + 69, 70, 71, 72, 73, 74, 75, 76, 77, -1, + -1, 80, 81, -1, -1, 84, 85, 86, 87, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 98, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, 130, 131, 51, 52, -1, -1, 55, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 148, + 149, 69, 70, 71, 72, 73, 74, 75, 76, 77, + -1, -1, 80, 81, -1, -1, 84, 85, 86, 87, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 51, 52, -1, -1, 55, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 148, 149, 69, 70, 71, 72, 73, 74, 75, 76, + 77, -1, -1, 80, 81, -1, -1, 84, 85, 86, + 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 98, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, 130, 131, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 148 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint16 yystos[] = +{ + 0, 155, 156, 0, 1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 19, 21, 22, 23, 24, + 30, 31, 32, 33, 34, 35, 36, 39, 45, 46, + 47, 48, 49, 51, 52, 53, 54, 55, 56, 58, + 59, 60, 63, 66, 67, 69, 70, 89, 92, 93, + 95, 96, 98, 100, 101, 102, 103, 104, 105, 106, + 109, 129, 130, 131, 157, 158, 159, 164, 166, 167, + 169, 170, 173, 174, 176, 177, 178, 180, 181, 190, + 203, 223, 242, 243, 253, 254, 258, 259, 260, 267, + 268, 269, 271, 272, 273, 274, 275, 276, 300, 313, + 159, 21, 22, 30, 31, 32, 39, 51, 55, 86, + 89, 92, 129, 182, 183, 203, 223, 273, 276, 300, + 183, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 45, 46, 47, 48, 49, + 50, 51, 52, 55, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 80, 81, 84, 85, 86, 87, 98, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 130, 131, 148, 149, 184, 188, 189, 275, 295, 204, + 89, 167, 168, 181, 223, 273, 274, 276, 168, 209, + 211, 89, 174, 181, 223, 228, 273, 276, 33, 34, + 35, 36, 48, 49, 51, 55, 101, 184, 185, 186, + 269, 152, 153, 168, 304, 309, 310, 312, 57, 98, + 99, 130, 173, 190, 191, 196, 199, 201, 298, 299, + 196, 196, 149, 197, 198, 149, 193, 197, 149, 305, + 310, 185, 160, 143, 190, 223, 190, 55, 1, 92, + 162, 163, 164, 175, 176, 313, 205, 207, 192, 201, + 298, 313, 191, 297, 298, 313, 89, 147, 180, 223, + 273, 276, 208, 53, 54, 56, 63, 105, 184, 270, + 62, 64, 65, 111, 112, 255, 256, 63, 255, 63, + 255, 63, 255, 61, 255, 58, 59, 169, 190, 190, + 304, 312, 40, 41, 42, 43, 44, 37, 38, 28, + 240, 116, 147, 92, 98, 177, 116, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 86, 87, 117, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 88, 145, 146, 88, 146, 303, 26, + 143, 244, 90, 90, 193, 197, 244, 167, 51, 55, + 182, 58, 59, 1, 120, 277, 309, 88, 145, 146, + 218, 296, 219, 303, 161, 162, 55, 16, 224, 309, + 116, 88, 145, 146, 90, 90, 224, 168, 168, 55, + 88, 145, 146, 25, 105, 147, 311, 304, 20, 247, + 152, 191, 191, 191, 91, 147, 200, 313, 147, 200, + 196, 305, 306, 196, 195, 196, 201, 298, 313, 167, + 306, 167, 165, 143, 162, 88, 146, 90, 164, 175, + 150, 304, 312, 306, 167, 306, 151, 147, 308, 310, + 147, 308, 144, 308, 55, 177, 178, 179, 147, 88, + 145, 146, 51, 53, 54, 55, 56, 92, 98, 99, + 123, 126, 149, 238, 280, 281, 282, 283, 284, 285, + 286, 289, 290, 291, 292, 293, 63, 256, 257, 110, + 113, 114, 262, 263, 264, 265, 62, 256, 63, 63, + 63, 61, 71, 71, 159, 168, 168, 168, 168, 164, + 167, 167, 241, 98, 169, 191, 201, 202, 175, 147, + 180, 147, 166, 169, 181, 190, 191, 202, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 51, 52, 55, 188, 193, 301, + 302, 195, 51, 52, 55, 188, 193, 301, 51, 55, + 301, 246, 245, 169, 190, 169, 190, 97, 171, 216, + 309, 278, 215, 51, 55, 182, 301, 195, 301, 161, + 167, 220, 221, 15, 13, 249, 313, 162, 16, 190, + 51, 55, 195, 51, 55, 162, 27, 225, 309, 225, + 51, 55, 195, 51, 55, 213, 187, 261, 262, 247, + 201, 15, 191, 98, 191, 199, 262, 298, 299, 306, + 150, 306, 147, 147, 306, 185, 157, 144, 190, 306, + 164, 206, 298, 177, 179, 51, 55, 195, 51, 55, + 116, 51, 92, 98, 229, 230, 231, 282, 280, 29, + 108, 239, 147, 294, 313, 191, 147, 294, 51, 147, + 294, 51, 63, 162, 266, 263, 110, 265, 190, 190, + 79, 121, 233, 234, 313, 191, 147, 306, 179, 147, + 116, 44, 305, 90, 90, 193, 197, 305, 307, 90, + 90, 193, 194, 197, 313, 194, 197, 233, 233, 44, + 172, 309, 168, 161, 307, 15, 306, 149, 279, 280, + 184, 191, 202, 250, 313, 18, 227, 313, 17, 226, + 227, 90, 90, 307, 90, 90, 227, 210, 212, 307, + 168, 185, 15, 147, 224, 191, 98, 191, 200, 298, + 144, 306, 308, 307, 231, 147, 282, 147, 306, 235, + 305, 162, 162, 283, 289, 291, 293, 284, 286, 291, + 284, 144, 162, 232, 235, 284, 285, 287, 288, 291, + 293, 162, 98, 191, 179, 190, 118, 169, 190, 169, + 190, 171, 151, 90, 169, 190, 169, 190, 171, 244, + 240, 162, 162, 190, 233, 217, 309, 15, 280, 161, + 309, 222, 91, 251, 313, 162, 14, 252, 313, 168, + 15, 90, 15, 162, 162, 225, 191, 162, 191, 147, + 306, 230, 147, 98, 229, 150, 152, 15, 144, 147, + 294, 147, 294, 147, 294, 147, 294, 294, 144, 235, + 121, 147, 294, 89, 223, 147, 294, 147, 294, 15, + 191, 190, 169, 190, 15, 144, 162, 161, 306, 15, + 279, 89, 181, 223, 273, 276, 224, 162, 224, 15, + 15, 214, 227, 247, 248, 147, 230, 147, 282, 51, + 236, 237, 281, 284, 291, 284, 284, 121, 288, 291, + 55, 88, 284, 287, 291, 284, 144, 15, 161, 55, + 88, 145, 146, 162, 162, 162, 230, 147, 147, 305, + 294, 147, 294, 294, 294, 147, 294, 147, 294, 51, + 55, 294, 147, 294, 294, 15, 51, 55, 195, 51, + 55, 249, 226, 15, 230, 237, 284, 284, 291, 284, + 284, 307, 294, 294, 147, 294, 294, 294, 284, 294 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (p, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval, p) +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value, p); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_state *p) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep, p) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + parser_state *p; +#endif +{ + if (!yyvaluep) + return; + YYUSE (p); +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_state *p) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep, p) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + parser_state *p; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep, p); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule, parser_state *p) +#else +static void +yy_reduce_print (yyvsp, yyrule, p) + YYSTYPE *yyvsp; + int yyrule; + parser_state *p; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + , p); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule, p); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error (char *yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + + if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else + { + int yytype = YYTRANSLATE (yychar); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +# if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +# endif + char *yyfmt; + char const *yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const *yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy (yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy (yyfmt, yyprefix); + yyprefix = yyor; + } + + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen (yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + + if (yysize_overflow) + return YYSIZE_MAXIMUM; + + if (yyresult) + { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char *yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') + { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyf += 2; + } + else + { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_state *p) +#else +static void +yydestruct (yymsg, yytype, yyvaluep, p) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; + parser_state *p; +#endif +{ + YYUSE (yyvaluep); + YYUSE (p); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + +/* Prevent warnings from -Wmissing-prototypes. */ +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (parser_state *p); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + + + +/*-------------------------. +| yyparse or yypush_parse. | +`-------------------------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (parser_state *p) +#else +int +yyparse (p) + parser_state *p; +#endif +#endif +{ +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + + /* Number of syntax errors so far. */ + int yynerrs; + + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: + +/* Line 1464 of yacc.c */ +#line 1166 "src/parse.y" + { + p->lstate = EXPR_BEG; + if (!p->locals) p->locals = cons(0,0); + ;} + break; + + case 3: + +/* Line 1464 of yacc.c */ +#line 1171 "src/parse.y" + { + p->tree = new_scope(p, (yyvsp[(2) - (2)].nd)); + NODE_LINENO(p->tree, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 4: + +/* Line 1464 of yacc.c */ +#line 1178 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (2)].nd); + ;} + break; + + case 5: + +/* Line 1464 of yacc.c */ +#line 1184 "src/parse.y" + { + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 6: + +/* Line 1464 of yacc.c */ +#line 1188 "src/parse.y" + { + (yyval.nd) = new_begin(p, (yyvsp[(1) - (1)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 7: + +/* Line 1464 of yacc.c */ +#line 1193 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), newline_node((yyvsp[(3) - (3)].nd))); + ;} + break; + + case 8: + +/* Line 1464 of yacc.c */ +#line 1197 "src/parse.y" + { + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 10: + +/* Line 1464 of yacc.c */ +#line 1204 "src/parse.y" + { + (yyval.nd) = local_switch(p); + ;} + break; + + case 11: + +/* Line 1464 of yacc.c */ +#line 1208 "src/parse.y" + { + yyerror(p, "BEGIN not supported"); + local_resume(p, (yyvsp[(2) - (5)].nd)); + (yyval.nd) = 0; + ;} + break; + + case 12: + +/* Line 1464 of yacc.c */ +#line 1219 "src/parse.y" + { + if ((yyvsp[(2) - (4)].nd)) { + (yyval.nd) = new_rescue(p, (yyvsp[(1) - (4)].nd), (yyvsp[(2) - (4)].nd), (yyvsp[(3) - (4)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (4)].nd)); + } + else if ((yyvsp[(3) - (4)].nd)) { + yywarn(p, "else without rescue is useless"); + (yyval.nd) = push((yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].nd)); + } + else { + (yyval.nd) = (yyvsp[(1) - (4)].nd); + } + if ((yyvsp[(4) - (4)].nd)) { + if ((yyval.nd)) { + (yyval.nd) = new_ensure(p, (yyval.nd), (yyvsp[(4) - (4)].nd)); + } + else { + (yyval.nd) = push((yyvsp[(4) - (4)].nd), new_nil(p)); + } + } + ;} + break; + + case 13: + +/* Line 1464 of yacc.c */ +#line 1243 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (2)].nd); + ;} + break; + + case 14: + +/* Line 1464 of yacc.c */ +#line 1249 "src/parse.y" + { + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 15: + +/* Line 1464 of yacc.c */ +#line 1253 "src/parse.y" + { + (yyval.nd) = new_begin(p, (yyvsp[(1) - (1)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 16: + +/* Line 1464 of yacc.c */ +#line 1258 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), newline_node((yyvsp[(3) - (3)].nd))); + ;} + break; + + case 17: + +/* Line 1464 of yacc.c */ +#line 1262 "src/parse.y" + { + (yyval.nd) = new_begin(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 18: + +/* Line 1464 of yacc.c */ +#line 1267 "src/parse.y" + {p->lstate = EXPR_FNAME;;} + break; + + case 19: + +/* Line 1464 of yacc.c */ +#line 1268 "src/parse.y" + { + (yyval.nd) = new_alias(p, (yyvsp[(2) - (4)].id), (yyvsp[(4) - (4)].id)); + ;} + break; + + case 20: + +/* Line 1464 of yacc.c */ +#line 1272 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 21: + +/* Line 1464 of yacc.c */ +#line 1276 "src/parse.y" + { + (yyval.nd) = new_if(p, cond((yyvsp[(3) - (3)].nd)), (yyvsp[(1) - (3)].nd), 0); + ;} + break; + + case 22: + +/* Line 1464 of yacc.c */ +#line 1280 "src/parse.y" + { + (yyval.nd) = new_unless(p, cond((yyvsp[(3) - (3)].nd)), (yyvsp[(1) - (3)].nd), 0); + ;} + break; + + case 23: + +/* Line 1464 of yacc.c */ +#line 1284 "src/parse.y" + { + (yyval.nd) = new_while(p, cond((yyvsp[(3) - (3)].nd)), (yyvsp[(1) - (3)].nd)); + ;} + break; + + case 24: + +/* Line 1464 of yacc.c */ +#line 1288 "src/parse.y" + { + (yyval.nd) = new_until(p, cond((yyvsp[(3) - (3)].nd)), (yyvsp[(1) - (3)].nd)); + ;} + break; + + case 25: + +/* Line 1464 of yacc.c */ +#line 1292 "src/parse.y" + { + (yyval.nd) = new_rescue(p, (yyvsp[(1) - (3)].nd), list1(list3(0, 0, (yyvsp[(3) - (3)].nd))), 0); + ;} + break; + + case 26: + +/* Line 1464 of yacc.c */ +#line 1296 "src/parse.y" + { + yyerror(p, "END not suported"); + (yyval.nd) = new_postexe(p, (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 28: + +/* Line 1464 of yacc.c */ +#line 1302 "src/parse.y" + { + (yyval.nd) = new_masgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 29: + +/* Line 1464 of yacc.c */ +#line 1306 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 30: + +/* Line 1464 of yacc.c */ +#line 1310 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (6)].nd), intern("[]",2), (yyvsp[(3) - (6)].nd)), (yyvsp[(5) - (6)].id), (yyvsp[(6) - (6)].nd)); + ;} + break; + + case 31: + +/* Line 1464 of yacc.c */ +#line 1314 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), 0), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 32: + +/* Line 1464 of yacc.c */ +#line 1318 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), 0), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 33: + +/* Line 1464 of yacc.c */ +#line 1322 "src/parse.y" + { + yyerror(p, "constant re-assignment"); + (yyval.nd) = 0; + ;} + break; + + case 34: + +/* Line 1464 of yacc.c */ +#line 1327 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), 0), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 35: + +/* Line 1464 of yacc.c */ +#line 1331 "src/parse.y" + { + backref_error(p, (yyvsp[(1) - (3)].nd)); + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 36: + +/* Line 1464 of yacc.c */ +#line 1336 "src/parse.y" + { + (yyval.nd) = new_asgn(p, (yyvsp[(1) - (3)].nd), new_array(p, (yyvsp[(3) - (3)].nd))); + ;} + break; + + case 37: + +/* Line 1464 of yacc.c */ +#line 1340 "src/parse.y" + { + (yyval.nd) = new_masgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 38: + +/* Line 1464 of yacc.c */ +#line 1344 "src/parse.y" + { + (yyval.nd) = new_masgn(p, (yyvsp[(1) - (3)].nd), new_array(p, (yyvsp[(3) - (3)].nd))); + ;} + break; + + case 40: + +/* Line 1464 of yacc.c */ +#line 1351 "src/parse.y" + { + (yyval.nd) = new_asgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 41: + +/* Line 1464 of yacc.c */ +#line 1355 "src/parse.y" + { + (yyval.nd) = new_asgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 43: + +/* Line 1464 of yacc.c */ +#line 1363 "src/parse.y" + { + (yyval.nd) = new_and(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 44: + +/* Line 1464 of yacc.c */ +#line 1367 "src/parse.y" + { + (yyval.nd) = new_or(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 45: + +/* Line 1464 of yacc.c */ +#line 1371 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, cond((yyvsp[(3) - (3)].nd)), "!"); + ;} + break; + + case 46: + +/* Line 1464 of yacc.c */ +#line 1375 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, cond((yyvsp[(2) - (2)].nd)), "!"); + ;} + break; + + case 48: + +/* Line 1464 of yacc.c */ +#line 1382 "src/parse.y" + { + if (!(yyvsp[(1) - (1)].nd)) (yyval.nd) = new_nil(p); + else (yyval.nd) = (yyvsp[(1) - (1)].nd); + ;} + break; + + case 53: + +/* Line 1464 of yacc.c */ +#line 1397 "src/parse.y" + { + local_nest(p); + ;} + break; + + case 54: + +/* Line 1464 of yacc.c */ +#line 1403 "src/parse.y" + { + (yyval.nd) = new_block(p, (yyvsp[(3) - (5)].nd), (yyvsp[(4) - (5)].nd)); + local_unnest(p); + ;} + break; + + case 55: + +/* Line 1464 of yacc.c */ +#line 1410 "src/parse.y" + { + (yyval.nd) = new_fcall(p, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 56: + +/* Line 1464 of yacc.c */ +#line 1414 "src/parse.y" + { + args_with_block(p, (yyvsp[(2) - (3)].nd), (yyvsp[(3) - (3)].nd)); + (yyval.nd) = new_fcall(p, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].nd)); + ;} + break; + + case 57: + +/* Line 1464 of yacc.c */ +#line 1419 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 58: + +/* Line 1464 of yacc.c */ +#line 1423 "src/parse.y" + { + args_with_block(p, (yyvsp[(4) - (5)].nd), (yyvsp[(5) - (5)].nd)); + (yyval.nd) = new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].nd)); + ;} + break; + + case 59: + +/* Line 1464 of yacc.c */ +#line 1428 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 60: + +/* Line 1464 of yacc.c */ +#line 1432 "src/parse.y" + { + args_with_block(p, (yyvsp[(4) - (5)].nd), (yyvsp[(5) - (5)].nd)); + (yyval.nd) = new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].nd)); + ;} + break; + + case 61: + +/* Line 1464 of yacc.c */ +#line 1437 "src/parse.y" + { + (yyval.nd) = new_super(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 62: + +/* Line 1464 of yacc.c */ +#line 1441 "src/parse.y" + { + (yyval.nd) = new_yield(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 63: + +/* Line 1464 of yacc.c */ +#line 1445 "src/parse.y" + { + (yyval.nd) = new_return(p, ret_args(p, (yyvsp[(2) - (2)].nd))); + ;} + break; + + case 64: + +/* Line 1464 of yacc.c */ +#line 1449 "src/parse.y" + { + (yyval.nd) = new_break(p, ret_args(p, (yyvsp[(2) - (2)].nd))); + ;} + break; + + case 65: + +/* Line 1464 of yacc.c */ +#line 1453 "src/parse.y" + { + (yyval.nd) = new_next(p, ret_args(p, (yyvsp[(2) - (2)].nd))); + ;} + break; + + case 66: + +/* Line 1464 of yacc.c */ +#line 1459 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (1)].nd); + ;} + break; + + case 67: + +/* Line 1464 of yacc.c */ +#line 1463 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + ;} + break; + + case 69: + +/* Line 1464 of yacc.c */ +#line 1470 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(2) - (3)].nd)); + ;} + break; + + case 70: + +/* Line 1464 of yacc.c */ +#line 1476 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 71: + +/* Line 1464 of yacc.c */ +#line 1480 "src/parse.y" + { + (yyval.nd) = list1(push((yyvsp[(1) - (2)].nd),(yyvsp[(2) - (2)].nd))); + ;} + break; + + case 72: + +/* Line 1464 of yacc.c */ +#line 1484 "src/parse.y" + { + (yyval.nd) = list2((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 73: + +/* Line 1464 of yacc.c */ +#line 1488 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].nd), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 74: + +/* Line 1464 of yacc.c */ +#line 1492 "src/parse.y" + { + (yyval.nd) = list2((yyvsp[(1) - (2)].nd), new_nil(p)); + ;} + break; + + case 75: + +/* Line 1464 of yacc.c */ +#line 1496 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (4)].nd), new_nil(p), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 76: + +/* Line 1464 of yacc.c */ +#line 1500 "src/parse.y" + { + (yyval.nd) = list2(0, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 77: + +/* Line 1464 of yacc.c */ +#line 1504 "src/parse.y" + { + (yyval.nd) = list3(0, (yyvsp[(2) - (4)].nd), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 78: + +/* Line 1464 of yacc.c */ +#line 1508 "src/parse.y" + { + (yyval.nd) = list2(0, new_nil(p)); + ;} + break; + + case 79: + +/* Line 1464 of yacc.c */ +#line 1512 "src/parse.y" + { + (yyval.nd) = list3(0, new_nil(p), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 81: + +/* Line 1464 of yacc.c */ +#line 1519 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + ;} + break; + + case 82: + +/* Line 1464 of yacc.c */ +#line 1525 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (2)].nd)); + ;} + break; + + case 83: + +/* Line 1464 of yacc.c */ +#line 1529 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(2) - (3)].nd)); + ;} + break; + + case 84: + +/* Line 1464 of yacc.c */ +#line 1535 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 85: + +/* Line 1464 of yacc.c */ +#line 1539 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (2)].nd), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 86: + +/* Line 1464 of yacc.c */ +#line 1545 "src/parse.y" + { + assignable(p, (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 87: + +/* Line 1464 of yacc.c */ +#line 1549 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), intern("[]",2), (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 88: + +/* Line 1464 of yacc.c */ +#line 1553 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 89: + +/* Line 1464 of yacc.c */ +#line 1557 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 90: + +/* Line 1464 of yacc.c */ +#line 1561 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 91: + +/* Line 1464 of yacc.c */ +#line 1565 "src/parse.y" + { + if (p->in_def || p->in_single) + yyerror(p, "dynamic constant assignment"); + (yyval.nd) = new_colon2(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id)); + ;} + break; + + case 92: + +/* Line 1464 of yacc.c */ +#line 1571 "src/parse.y" + { + if (p->in_def || p->in_single) + yyerror(p, "dynamic constant assignment"); + (yyval.nd) = new_colon3(p, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 93: + +/* Line 1464 of yacc.c */ +#line 1577 "src/parse.y" + { + backref_error(p, (yyvsp[(1) - (1)].nd)); + (yyval.nd) = 0; + ;} + break; + + case 94: + +/* Line 1464 of yacc.c */ +#line 1584 "src/parse.y" + { + assignable(p, (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 95: + +/* Line 1464 of yacc.c */ +#line 1588 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), intern("[]",2), (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 96: + +/* Line 1464 of yacc.c */ +#line 1592 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 97: + +/* Line 1464 of yacc.c */ +#line 1596 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 98: + +/* Line 1464 of yacc.c */ +#line 1600 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 99: + +/* Line 1464 of yacc.c */ +#line 1604 "src/parse.y" + { + if (p->in_def || p->in_single) + yyerror(p, "dynamic constant assignment"); + (yyval.nd) = new_colon2(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id)); + ;} + break; + + case 100: + +/* Line 1464 of yacc.c */ +#line 1610 "src/parse.y" + { + if (p->in_def || p->in_single) + yyerror(p, "dynamic constant assignment"); + (yyval.nd) = new_colon3(p, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 101: + +/* Line 1464 of yacc.c */ +#line 1616 "src/parse.y" + { + backref_error(p, (yyvsp[(1) - (1)].nd)); + (yyval.nd) = 0; + ;} + break; + + case 102: + +/* Line 1464 of yacc.c */ +#line 1623 "src/parse.y" + { + yyerror(p, "class/module name must be CONSTANT"); + ;} + break; + + case 104: + +/* Line 1464 of yacc.c */ +#line 1630 "src/parse.y" + { + (yyval.nd) = cons((node*)1, nsym((yyvsp[(2) - (2)].id))); + ;} + break; + + case 105: + +/* Line 1464 of yacc.c */ +#line 1634 "src/parse.y" + { + (yyval.nd) = cons((node*)0, nsym((yyvsp[(1) - (1)].id))); + ;} + break; + + case 106: + +/* Line 1464 of yacc.c */ +#line 1638 "src/parse.y" + { + (yyval.nd) = cons((yyvsp[(1) - (3)].nd), nsym((yyvsp[(3) - (3)].id))); + ;} + break; + + case 110: + +/* Line 1464 of yacc.c */ +#line 1647 "src/parse.y" + { + p->lstate = EXPR_ENDFN; + (yyval.id) = (yyvsp[(1) - (1)].id); + ;} + break; + + case 111: + +/* Line 1464 of yacc.c */ +#line 1652 "src/parse.y" + { + p->lstate = EXPR_ENDFN; + (yyval.id) = (yyvsp[(1) - (1)].id); + ;} + break; + + case 114: + +/* Line 1464 of yacc.c */ +#line 1663 "src/parse.y" + { + (yyval.nd) = new_undef(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 115: + +/* Line 1464 of yacc.c */ +#line 1666 "src/parse.y" + {p->lstate = EXPR_FNAME;;} + break; + + case 116: + +/* Line 1464 of yacc.c */ +#line 1667 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (4)].nd), nsym((yyvsp[(4) - (4)].id))); + ;} + break; + + case 117: + +/* Line 1464 of yacc.c */ +#line 1672 "src/parse.y" + { (yyval.id) = intern_c('|'); ;} + break; + + case 118: + +/* Line 1464 of yacc.c */ +#line 1673 "src/parse.y" + { (yyval.id) = intern_c('^'); ;} + break; + + case 119: + +/* Line 1464 of yacc.c */ +#line 1674 "src/parse.y" + { (yyval.id) = intern_c('&'); ;} + break; + + case 120: + +/* Line 1464 of yacc.c */ +#line 1675 "src/parse.y" + { (yyval.id) = intern("<=>",3); ;} + break; + + case 121: + +/* Line 1464 of yacc.c */ +#line 1676 "src/parse.y" + { (yyval.id) = intern("==",2); ;} + break; + + case 122: + +/* Line 1464 of yacc.c */ +#line 1677 "src/parse.y" + { (yyval.id) = intern("===",3); ;} + break; + + case 123: + +/* Line 1464 of yacc.c */ +#line 1678 "src/parse.y" + { (yyval.id) = intern("=~",2); ;} + break; + + case 124: + +/* Line 1464 of yacc.c */ +#line 1679 "src/parse.y" + { (yyval.id) = intern("!~",2); ;} + break; + + case 125: + +/* Line 1464 of yacc.c */ +#line 1680 "src/parse.y" + { (yyval.id) = intern_c('>'); ;} + break; + + case 126: + +/* Line 1464 of yacc.c */ +#line 1681 "src/parse.y" + { (yyval.id) = intern(">=",2); ;} + break; + + case 127: + +/* Line 1464 of yacc.c */ +#line 1682 "src/parse.y" + { (yyval.id) = intern_c('<'); ;} + break; + + case 128: + +/* Line 1464 of yacc.c */ +#line 1683 "src/parse.y" + { (yyval.id) = intern("<=",2); ;} + break; + + case 129: + +/* Line 1464 of yacc.c */ +#line 1684 "src/parse.y" + { (yyval.id) = intern("!=",2); ;} + break; + + case 130: + +/* Line 1464 of yacc.c */ +#line 1685 "src/parse.y" + { (yyval.id) = intern("<<",2); ;} + break; + + case 131: + +/* Line 1464 of yacc.c */ +#line 1686 "src/parse.y" + { (yyval.id) = intern(">>",2); ;} + break; + + case 132: + +/* Line 1464 of yacc.c */ +#line 1687 "src/parse.y" + { (yyval.id) = intern_c('+'); ;} + break; + + case 133: + +/* Line 1464 of yacc.c */ +#line 1688 "src/parse.y" + { (yyval.id) = intern_c('-'); ;} + break; + + case 134: + +/* Line 1464 of yacc.c */ +#line 1689 "src/parse.y" + { (yyval.id) = intern_c('*'); ;} + break; + + case 135: + +/* Line 1464 of yacc.c */ +#line 1690 "src/parse.y" + { (yyval.id) = intern_c('*'); ;} + break; + + case 136: + +/* Line 1464 of yacc.c */ +#line 1691 "src/parse.y" + { (yyval.id) = intern_c('/'); ;} + break; + + case 137: + +/* Line 1464 of yacc.c */ +#line 1692 "src/parse.y" + { (yyval.id) = intern_c('%'); ;} + break; + + case 138: + +/* Line 1464 of yacc.c */ +#line 1693 "src/parse.y" + { (yyval.id) = intern("**",2); ;} + break; + + case 139: + +/* Line 1464 of yacc.c */ +#line 1694 "src/parse.y" + { (yyval.id) = intern_c('!'); ;} + break; + + case 140: + +/* Line 1464 of yacc.c */ +#line 1695 "src/parse.y" + { (yyval.id) = intern_c('~'); ;} + break; + + case 141: + +/* Line 1464 of yacc.c */ +#line 1696 "src/parse.y" + { (yyval.id) = intern("+@",2); ;} + break; + + case 142: + +/* Line 1464 of yacc.c */ +#line 1697 "src/parse.y" + { (yyval.id) = intern("-@",2); ;} + break; + + case 143: + +/* Line 1464 of yacc.c */ +#line 1698 "src/parse.y" + { (yyval.id) = intern("[]",2); ;} + break; + + case 144: + +/* Line 1464 of yacc.c */ +#line 1699 "src/parse.y" + { (yyval.id) = intern("[]=",3); ;} + break; + + case 145: + +/* Line 1464 of yacc.c */ +#line 1700 "src/parse.y" + { (yyval.id) = intern_c('`'); ;} + break; + + case 186: + +/* Line 1464 of yacc.c */ +#line 1718 "src/parse.y" + { + (yyval.nd) = new_asgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 187: + +/* Line 1464 of yacc.c */ +#line 1722 "src/parse.y" + { + (yyval.nd) = new_asgn(p, (yyvsp[(1) - (5)].nd), new_rescue(p, (yyvsp[(3) - (5)].nd), list1(list3(0, 0, (yyvsp[(5) - (5)].nd))), 0)); + ;} + break; + + case 188: + +/* Line 1464 of yacc.c */ +#line 1726 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, (yyvsp[(1) - (3)].nd), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 189: + +/* Line 1464 of yacc.c */ +#line 1730 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, (yyvsp[(1) - (5)].nd), (yyvsp[(2) - (5)].id), new_rescue(p, (yyvsp[(3) - (5)].nd), list1(list3(0, 0, (yyvsp[(5) - (5)].nd))), 0)); + ;} + break; + + case 190: + +/* Line 1464 of yacc.c */ +#line 1734 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (6)].nd), intern("[]",2), (yyvsp[(3) - (6)].nd)), (yyvsp[(5) - (6)].id), (yyvsp[(6) - (6)].nd)); + ;} + break; + + case 191: + +/* Line 1464 of yacc.c */ +#line 1738 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), 0), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 192: + +/* Line 1464 of yacc.c */ +#line 1742 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), 0), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 193: + +/* Line 1464 of yacc.c */ +#line 1746 "src/parse.y" + { + (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), 0), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 194: + +/* Line 1464 of yacc.c */ +#line 1750 "src/parse.y" + { + yyerror(p, "constant re-assignment"); + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 195: + +/* Line 1464 of yacc.c */ +#line 1755 "src/parse.y" + { + yyerror(p, "constant re-assignment"); + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 196: + +/* Line 1464 of yacc.c */ +#line 1760 "src/parse.y" + { + backref_error(p, (yyvsp[(1) - (3)].nd)); + (yyval.nd) = new_begin(p, 0); + ;} + break; + + case 197: + +/* Line 1464 of yacc.c */ +#line 1765 "src/parse.y" + { + (yyval.nd) = new_dot2(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 198: + +/* Line 1464 of yacc.c */ +#line 1769 "src/parse.y" + { + (yyval.nd) = new_dot3(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 199: + +/* Line 1464 of yacc.c */ +#line 1773 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "+", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 200: + +/* Line 1464 of yacc.c */ +#line 1777 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "-", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 201: + +/* Line 1464 of yacc.c */ +#line 1781 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "*", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 202: + +/* Line 1464 of yacc.c */ +#line 1785 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "/", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 203: + +/* Line 1464 of yacc.c */ +#line 1789 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "%", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 204: + +/* Line 1464 of yacc.c */ +#line 1793 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "**", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 205: + +/* Line 1464 of yacc.c */ +#line 1797 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[(2) - (4)].nd), "**", (yyvsp[(4) - (4)].nd)), "-@"); + ;} + break; + + case 206: + +/* Line 1464 of yacc.c */ +#line 1801 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[(2) - (4)].nd), "**", (yyvsp[(4) - (4)].nd)), "-@"); + ;} + break; + + case 207: + +/* Line 1464 of yacc.c */ +#line 1805 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, (yyvsp[(2) - (2)].nd), "+@"); + ;} + break; + + case 208: + +/* Line 1464 of yacc.c */ +#line 1809 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, (yyvsp[(2) - (2)].nd), "-@"); + ;} + break; + + case 209: + +/* Line 1464 of yacc.c */ +#line 1813 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "|", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 210: + +/* Line 1464 of yacc.c */ +#line 1817 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "^", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 211: + +/* Line 1464 of yacc.c */ +#line 1821 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "&", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 212: + +/* Line 1464 of yacc.c */ +#line 1825 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "<=>", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 213: + +/* Line 1464 of yacc.c */ +#line 1829 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), ">", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 214: + +/* Line 1464 of yacc.c */ +#line 1833 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), ">=", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 215: + +/* Line 1464 of yacc.c */ +#line 1837 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "<", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 216: + +/* Line 1464 of yacc.c */ +#line 1841 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "<=", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 217: + +/* Line 1464 of yacc.c */ +#line 1845 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "==", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 218: + +/* Line 1464 of yacc.c */ +#line 1849 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "===", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 219: + +/* Line 1464 of yacc.c */ +#line 1853 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "!=", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 220: + +/* Line 1464 of yacc.c */ +#line 1857 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "=~", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 221: + +/* Line 1464 of yacc.c */ +#line 1861 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "!~", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 222: + +/* Line 1464 of yacc.c */ +#line 1865 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, cond((yyvsp[(2) - (2)].nd)), "!"); + ;} + break; + + case 223: + +/* Line 1464 of yacc.c */ +#line 1869 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, cond((yyvsp[(2) - (2)].nd)), "~"); + ;} + break; + + case 224: + +/* Line 1464 of yacc.c */ +#line 1873 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), "<<", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 225: + +/* Line 1464 of yacc.c */ +#line 1877 "src/parse.y" + { + (yyval.nd) = call_bin_op(p, (yyvsp[(1) - (3)].nd), ">>", (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 226: + +/* Line 1464 of yacc.c */ +#line 1881 "src/parse.y" + { + (yyval.nd) = new_and(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 227: + +/* Line 1464 of yacc.c */ +#line 1885 "src/parse.y" + { + (yyval.nd) = new_or(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 228: + +/* Line 1464 of yacc.c */ +#line 1889 "src/parse.y" + { + (yyval.nd) = new_if(p, cond((yyvsp[(1) - (6)].nd)), (yyvsp[(3) - (6)].nd), (yyvsp[(6) - (6)].nd)); + ;} + break; + + case 229: + +/* Line 1464 of yacc.c */ +#line 1893 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (1)].nd); + ;} + break; + + case 230: + +/* Line 1464 of yacc.c */ +#line 1899 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (1)].nd); + if (!(yyval.nd)) (yyval.nd) = new_nil(p); + ;} + break; + + case 232: + +/* Line 1464 of yacc.c */ +#line 1907 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (2)].nd); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (2)].nd)); + ;} + break; + + case 233: + +/* Line 1464 of yacc.c */ +#line 1912 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (4)].nd), new_hash(p, (yyvsp[(3) - (4)].nd))); + ;} + break; + + case 234: + +/* Line 1464 of yacc.c */ +#line 1916 "src/parse.y" + { + (yyval.nd) = cons(new_hash(p, (yyvsp[(1) - (2)].nd)), 0); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (2)].nd)); + ;} + break; + + case 235: + +/* Line 1464 of yacc.c */ +#line 1923 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + ;} + break; + + case 240: + +/* Line 1464 of yacc.c */ +#line 1935 "src/parse.y" + { + (yyval.nd) = cons((yyvsp[(1) - (2)].nd),0); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (2)].nd)); + ;} + break; + + case 241: + +/* Line 1464 of yacc.c */ +#line 1940 "src/parse.y" + { + (yyval.nd) = cons(push((yyvsp[(1) - (4)].nd), new_hash(p, (yyvsp[(3) - (4)].nd))), 0); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (4)].nd)); + ;} + break; + + case 242: + +/* Line 1464 of yacc.c */ +#line 1945 "src/parse.y" + { + (yyval.nd) = cons(list1(new_hash(p, (yyvsp[(1) - (2)].nd))), 0); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (2)].nd)); + ;} + break; + + case 243: + +/* Line 1464 of yacc.c */ +#line 1952 "src/parse.y" + { + (yyval.nd) = cons(list1((yyvsp[(1) - (1)].nd)), 0); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 244: + +/* Line 1464 of yacc.c */ +#line 1957 "src/parse.y" + { + (yyval.nd) = cons((yyvsp[(1) - (2)].nd), (yyvsp[(2) - (2)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (2)].nd)); + ;} + break; + + case 245: + +/* Line 1464 of yacc.c */ +#line 1962 "src/parse.y" + { + (yyval.nd) = cons(list1(new_hash(p, (yyvsp[(1) - (2)].nd))), (yyvsp[(2) - (2)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (2)].nd)); + ;} + break; + + case 246: + +/* Line 1464 of yacc.c */ +#line 1967 "src/parse.y" + { + (yyval.nd) = cons(push((yyvsp[(1) - (4)].nd), new_hash(p, (yyvsp[(3) - (4)].nd))), (yyvsp[(4) - (4)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (4)].nd)); + ;} + break; + + case 247: + +/* Line 1464 of yacc.c */ +#line 1972 "src/parse.y" + { + (yyval.nd) = cons(0, (yyvsp[(1) - (1)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 248: + +/* Line 1464 of yacc.c */ +#line 1978 "src/parse.y" + { + (yyval.stack) = p->cmdarg_stack; + CMDARG_PUSH(1); + ;} + break; + + case 249: + +/* Line 1464 of yacc.c */ +#line 1983 "src/parse.y" + { + p->cmdarg_stack = (yyvsp[(1) - (2)].stack); + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 250: + +/* Line 1464 of yacc.c */ +#line 1990 "src/parse.y" + { + (yyval.nd) = new_block_arg(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 251: + +/* Line 1464 of yacc.c */ +#line 1996 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 252: + +/* Line 1464 of yacc.c */ +#line 2000 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 253: + +/* Line 1464 of yacc.c */ +#line 2006 "src/parse.y" + { + (yyval.nd) = cons((yyvsp[(1) - (1)].nd), 0); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 254: + +/* Line 1464 of yacc.c */ +#line 2011 "src/parse.y" + { + (yyval.nd) = cons(new_splat(p, (yyvsp[(2) - (2)].nd)), 0); + NODE_LINENO((yyval.nd), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 255: + +/* Line 1464 of yacc.c */ +#line 2016 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 256: + +/* Line 1464 of yacc.c */ +#line 2020 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (4)].nd), new_splat(p, (yyvsp[(4) - (4)].nd))); + ;} + break; + + case 257: + +/* Line 1464 of yacc.c */ +#line 2024 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (4)].nd), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 258: + +/* Line 1464 of yacc.c */ +#line 2028 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (5)].nd), new_splat(p, (yyvsp[(5) - (5)].nd))); + ;} + break; + + case 259: + +/* Line 1464 of yacc.c */ +#line 2034 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 260: + +/* Line 1464 of yacc.c */ +#line 2038 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (4)].nd), new_splat(p, (yyvsp[(4) - (4)].nd))); + ;} + break; + + case 261: + +/* Line 1464 of yacc.c */ +#line 2042 "src/parse.y" + { + (yyval.nd) = list1(new_splat(p, (yyvsp[(2) - (2)].nd))); + ;} + break; + + case 269: + +/* Line 1464 of yacc.c */ +#line 2055 "src/parse.y" + { + (yyval.nd) = new_fcall(p, (yyvsp[(1) - (1)].id), 0); + ;} + break; + + case 270: + +/* Line 1464 of yacc.c */ +#line 2059 "src/parse.y" + { + (yyval.stack) = p->cmdarg_stack; + p->cmdarg_stack = 0; + ;} + break; + + case 271: + +/* Line 1464 of yacc.c */ +#line 2065 "src/parse.y" + { + p->cmdarg_stack = (yyvsp[(2) - (4)].stack); + (yyval.nd) = (yyvsp[(3) - (4)].nd); + ;} + break; + + case 272: + +/* Line 1464 of yacc.c */ +#line 2070 "src/parse.y" + { + (yyval.stack) = p->cmdarg_stack; + p->cmdarg_stack = 0; + ;} + break; + + case 273: + +/* Line 1464 of yacc.c */ +#line 2074 "src/parse.y" + {p->lstate = EXPR_ENDARG;;} + break; + + case 274: + +/* Line 1464 of yacc.c */ +#line 2075 "src/parse.y" + { + p->cmdarg_stack = (yyvsp[(2) - (5)].stack); + (yyval.nd) = (yyvsp[(3) - (5)].nd); + ;} + break; + + case 275: + +/* Line 1464 of yacc.c */ +#line 2079 "src/parse.y" + {p->lstate = EXPR_ENDARG;;} + break; + + case 276: + +/* Line 1464 of yacc.c */ +#line 2080 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 277: + +/* Line 1464 of yacc.c */ +#line 2084 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + ;} + break; + + case 278: + +/* Line 1464 of yacc.c */ +#line 2088 "src/parse.y" + { + (yyval.nd) = new_colon2(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id)); + ;} + break; + + case 279: + +/* Line 1464 of yacc.c */ +#line 2092 "src/parse.y" + { + (yyval.nd) = new_colon3(p, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 280: + +/* Line 1464 of yacc.c */ +#line 2096 "src/parse.y" + { + (yyval.nd) = new_array(p, (yyvsp[(2) - (3)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(2) - (3)].nd)); + ;} + break; + + case 281: + +/* Line 1464 of yacc.c */ +#line 2101 "src/parse.y" + { + (yyval.nd) = new_hash(p, (yyvsp[(2) - (3)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(2) - (3)].nd)); + ;} + break; + + case 282: + +/* Line 1464 of yacc.c */ +#line 2106 "src/parse.y" + { + (yyval.nd) = new_return(p, 0); + ;} + break; + + case 283: + +/* Line 1464 of yacc.c */ +#line 2110 "src/parse.y" + { + (yyval.nd) = new_yield(p, (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 284: + +/* Line 1464 of yacc.c */ +#line 2114 "src/parse.y" + { + (yyval.nd) = new_yield(p, 0); + ;} + break; + + case 285: + +/* Line 1464 of yacc.c */ +#line 2118 "src/parse.y" + { + (yyval.nd) = new_yield(p, 0); + ;} + break; + + case 286: + +/* Line 1464 of yacc.c */ +#line 2122 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, cond((yyvsp[(3) - (4)].nd)), "!"); + ;} + break; + + case 287: + +/* Line 1464 of yacc.c */ +#line 2126 "src/parse.y" + { + (yyval.nd) = call_uni_op(p, new_nil(p), "!"); + ;} + break; + + case 288: + +/* Line 1464 of yacc.c */ +#line 2130 "src/parse.y" + { + (yyval.nd) = new_fcall(p, (yyvsp[(1) - (2)].id), cons(0, (yyvsp[(2) - (2)].nd))); + ;} + break; + + case 290: + +/* Line 1464 of yacc.c */ +#line 2135 "src/parse.y" + { + call_with_block(p, (yyvsp[(1) - (2)].nd), (yyvsp[(2) - (2)].nd)); + (yyval.nd) = (yyvsp[(1) - (2)].nd); + ;} + break; + + case 291: + +/* Line 1464 of yacc.c */ +#line 2140 "src/parse.y" + { + local_nest(p); + (yyval.num) = p->lpar_beg; + p->lpar_beg = ++p->paren_nest; + ;} + break; + + case 292: + +/* Line 1464 of yacc.c */ +#line 2147 "src/parse.y" + { + p->lpar_beg = (yyvsp[(2) - (4)].num); + (yyval.nd) = new_lambda(p, (yyvsp[(3) - (4)].nd), (yyvsp[(4) - (4)].nd)); + local_unnest(p); + ;} + break; + + case 293: + +/* Line 1464 of yacc.c */ +#line 2156 "src/parse.y" + { + (yyval.nd) = new_if(p, cond((yyvsp[(2) - (6)].nd)), (yyvsp[(4) - (6)].nd), (yyvsp[(5) - (6)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (6)].num)); + ;} + break; + + case 294: + +/* Line 1464 of yacc.c */ +#line 2164 "src/parse.y" + { + (yyval.nd) = new_unless(p, cond((yyvsp[(2) - (6)].nd)), (yyvsp[(4) - (6)].nd), (yyvsp[(5) - (6)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (6)].num)); + ;} + break; + + case 295: + +/* Line 1464 of yacc.c */ +#line 2168 "src/parse.y" + {COND_PUSH(1);;} + break; + + case 296: + +/* Line 1464 of yacc.c */ +#line 2168 "src/parse.y" + {COND_POP();;} + break; + + case 297: + +/* Line 1464 of yacc.c */ +#line 2171 "src/parse.y" + { + (yyval.nd) = new_while(p, cond((yyvsp[(3) - (7)].nd)), (yyvsp[(6) - (7)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (7)].num)); + ;} + break; + + case 298: + +/* Line 1464 of yacc.c */ +#line 2175 "src/parse.y" + {COND_PUSH(1);;} + break; + + case 299: + +/* Line 1464 of yacc.c */ +#line 2175 "src/parse.y" + {COND_POP();;} + break; + + case 300: + +/* Line 1464 of yacc.c */ +#line 2178 "src/parse.y" + { + (yyval.nd) = new_until(p, cond((yyvsp[(3) - (7)].nd)), (yyvsp[(6) - (7)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (7)].num)); + ;} + break; + + case 301: + +/* Line 1464 of yacc.c */ +#line 2185 "src/parse.y" + { + (yyval.nd) = new_case(p, (yyvsp[(2) - (5)].nd), (yyvsp[(4) - (5)].nd)); + ;} + break; + + case 302: + +/* Line 1464 of yacc.c */ +#line 2189 "src/parse.y" + { + (yyval.nd) = new_case(p, 0, (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 303: + +/* Line 1464 of yacc.c */ +#line 2193 "src/parse.y" + {COND_PUSH(1);;} + break; + + case 304: + +/* Line 1464 of yacc.c */ +#line 2195 "src/parse.y" + {COND_POP();;} + break; + + case 305: + +/* Line 1464 of yacc.c */ +#line 2198 "src/parse.y" + { + (yyval.nd) = new_for(p, (yyvsp[(2) - (9)].nd), (yyvsp[(5) - (9)].nd), (yyvsp[(8) - (9)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (9)].num)); + ;} + break; + + case 306: + +/* Line 1464 of yacc.c */ +#line 2204 "src/parse.y" + { + if (p->in_def || p->in_single) + yyerror(p, "class definition in method body"); + (yyval.nd) = local_switch(p); + ;} + break; + + case 307: + +/* Line 1464 of yacc.c */ +#line 2211 "src/parse.y" + { + (yyval.nd) = new_class(p, (yyvsp[(2) - (6)].nd), (yyvsp[(3) - (6)].nd), (yyvsp[(5) - (6)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (6)].num)); + local_resume(p, (yyvsp[(4) - (6)].nd)); + ;} + break; + + case 308: + +/* Line 1464 of yacc.c */ +#line 2218 "src/parse.y" + { + (yyval.num) = p->in_def; + p->in_def = 0; + ;} + break; + + case 309: + +/* Line 1464 of yacc.c */ +#line 2223 "src/parse.y" + { + (yyval.nd) = cons(local_switch(p), (node*)(intptr_t)p->in_single); + p->in_single = 0; + ;} + break; + + case 310: + +/* Line 1464 of yacc.c */ +#line 2229 "src/parse.y" + { + (yyval.nd) = new_sclass(p, (yyvsp[(3) - (8)].nd), (yyvsp[(7) - (8)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (8)].num)); + local_resume(p, (yyvsp[(6) - (8)].nd)->car); + p->in_def = (yyvsp[(4) - (8)].num); + p->in_single = (int)(intptr_t)(yyvsp[(6) - (8)].nd)->cdr; + ;} + break; + + case 311: + +/* Line 1464 of yacc.c */ +#line 2238 "src/parse.y" + { + if (p->in_def || p->in_single) + yyerror(p, "module definition in method body"); + (yyval.nd) = local_switch(p); + ;} + break; + + case 312: + +/* Line 1464 of yacc.c */ +#line 2245 "src/parse.y" + { + (yyval.nd) = new_module(p, (yyvsp[(2) - (5)].nd), (yyvsp[(4) - (5)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (5)].num)); + local_resume(p, (yyvsp[(3) - (5)].nd)); + ;} + break; + + case 313: + +/* Line 1464 of yacc.c */ +#line 2251 "src/parse.y" + { + (yyval.stack) = p->cmdarg_stack; + p->cmdarg_stack = 0; + ;} + break; + + case 314: + +/* Line 1464 of yacc.c */ +#line 2255 "src/parse.y" + { + p->in_def++; + (yyval.nd) = local_switch(p); + ;} + break; + + case 315: + +/* Line 1464 of yacc.c */ +#line 2262 "src/parse.y" + { + (yyval.nd) = new_def(p, (yyvsp[(2) - (7)].id), (yyvsp[(5) - (7)].nd), (yyvsp[(6) - (7)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (7)].num)); + local_resume(p, (yyvsp[(4) - (7)].nd)); + p->in_def--; + p->cmdarg_stack = (yyvsp[(3) - (7)].stack); + ;} + break; + + case 316: + +/* Line 1464 of yacc.c */ +#line 2270 "src/parse.y" + { + p->lstate = EXPR_FNAME; + (yyval.stack) = p->cmdarg_stack; + p->cmdarg_stack = 0; + ;} + break; + + case 317: + +/* Line 1464 of yacc.c */ +#line 2276 "src/parse.y" + { + p->in_single++; + p->lstate = EXPR_ENDFN; /* force for args */ + (yyval.nd) = local_switch(p); + ;} + break; + + case 318: + +/* Line 1464 of yacc.c */ +#line 2284 "src/parse.y" + { + (yyval.nd) = new_sdef(p, (yyvsp[(2) - (9)].nd), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].nd), (yyvsp[(8) - (9)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(1) - (9)].num)); + local_resume(p, (yyvsp[(6) - (9)].nd)); + p->in_single--; + p->cmdarg_stack = (yyvsp[(4) - (9)].stack); + ;} + break; + + case 319: + +/* Line 1464 of yacc.c */ +#line 2292 "src/parse.y" + { + (yyval.nd) = new_break(p, 0); + ;} + break; + + case 320: + +/* Line 1464 of yacc.c */ +#line 2296 "src/parse.y" + { + (yyval.nd) = new_next(p, 0); + ;} + break; + + case 321: + +/* Line 1464 of yacc.c */ +#line 2300 "src/parse.y" + { + (yyval.nd) = new_redo(p); + ;} + break; + + case 322: + +/* Line 1464 of yacc.c */ +#line 2304 "src/parse.y" + { + (yyval.nd) = new_retry(p); + ;} + break; + + case 323: + +/* Line 1464 of yacc.c */ +#line 2310 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (1)].nd); + if (!(yyval.nd)) (yyval.nd) = new_nil(p); + ;} + break; + + case 330: + +/* Line 1464 of yacc.c */ +#line 2329 "src/parse.y" + { + (yyval.nd) = new_if(p, cond((yyvsp[(2) - (5)].nd)), (yyvsp[(4) - (5)].nd), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 332: + +/* Line 1464 of yacc.c */ +#line 2336 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 333: + +/* Line 1464 of yacc.c */ +#line 2342 "src/parse.y" + { + (yyval.nd) = list1(list1((yyvsp[(1) - (1)].nd))); + ;} + break; + + case 335: + +/* Line 1464 of yacc.c */ +#line 2349 "src/parse.y" + { + (yyval.nd) = new_arg(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 336: + +/* Line 1464 of yacc.c */ +#line 2353 "src/parse.y" + { + (yyval.nd) = new_masgn(p, (yyvsp[(2) - (3)].nd), 0); + ;} + break; + + case 337: + +/* Line 1464 of yacc.c */ +#line 2359 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 338: + +/* Line 1464 of yacc.c */ +#line 2363 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 339: + +/* Line 1464 of yacc.c */ +#line 2369 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (1)].nd),0,0); + ;} + break; + + case 340: + +/* Line 1464 of yacc.c */ +#line 2373 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (4)].nd), new_arg(p, (yyvsp[(4) - (4)].id)), 0); + ;} + break; + + case 341: + +/* Line 1464 of yacc.c */ +#line 2377 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (6)].nd), new_arg(p, (yyvsp[(4) - (6)].id)), (yyvsp[(6) - (6)].nd)); + ;} + break; + + case 342: + +/* Line 1464 of yacc.c */ +#line 2381 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (3)].nd), (node*)-1, 0); + ;} + break; + + case 343: + +/* Line 1464 of yacc.c */ +#line 2385 "src/parse.y" + { + (yyval.nd) = list3((yyvsp[(1) - (5)].nd), (node*)-1, (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 344: + +/* Line 1464 of yacc.c */ +#line 2389 "src/parse.y" + { + (yyval.nd) = list3(0, new_arg(p, (yyvsp[(2) - (2)].id)), 0); + ;} + break; + + case 345: + +/* Line 1464 of yacc.c */ +#line 2393 "src/parse.y" + { + (yyval.nd) = list3(0, new_arg(p, (yyvsp[(2) - (4)].id)), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 346: + +/* Line 1464 of yacc.c */ +#line 2397 "src/parse.y" + { + (yyval.nd) = list3(0, (node*)-1, 0); + ;} + break; + + case 347: + +/* Line 1464 of yacc.c */ +#line 2401 "src/parse.y" + { + (yyval.nd) = list3(0, (node*)-1, (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 348: + +/* Line 1464 of yacc.c */ +#line 2407 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (6)].nd), (yyvsp[(3) - (6)].nd), (yyvsp[(5) - (6)].id), 0, (yyvsp[(6) - (6)].id)); + ;} + break; + + case 349: + +/* Line 1464 of yacc.c */ +#line 2411 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (8)].nd), (yyvsp[(3) - (8)].nd), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].nd), (yyvsp[(8) - (8)].id)); + ;} + break; + + case 350: + +/* Line 1464 of yacc.c */ +#line 2415 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].nd), 0, 0, (yyvsp[(4) - (4)].id)); + ;} + break; + + case 351: + +/* Line 1464 of yacc.c */ +#line 2419 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (6)].nd), (yyvsp[(3) - (6)].nd), 0, (yyvsp[(5) - (6)].nd), (yyvsp[(6) - (6)].id)); + ;} + break; + + case 352: + +/* Line 1464 of yacc.c */ +#line 2423 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (4)].nd), 0, (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id)); + ;} + break; + + case 353: + +/* Line 1464 of yacc.c */ +#line 2427 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (2)].nd), 0, 1, 0, 0); + ;} + break; + + case 354: + +/* Line 1464 of yacc.c */ +#line 2431 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (6)].nd), 0, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].nd), (yyvsp[(6) - (6)].id)); + ;} + break; + + case 355: + +/* Line 1464 of yacc.c */ +#line 2435 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (2)].nd), 0, 0, 0, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 356: + +/* Line 1464 of yacc.c */ +#line 2439 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id)); + ;} + break; + + case 357: + +/* Line 1464 of yacc.c */ +#line 2443 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (6)].nd), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].nd), (yyvsp[(6) - (6)].id)); + ;} + break; + + case 358: + +/* Line 1464 of yacc.c */ +#line 2447 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (2)].nd), 0, 0, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 359: + +/* Line 1464 of yacc.c */ +#line 2451 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (4)].nd), 0, (yyvsp[(3) - (4)].nd), (yyvsp[(4) - (4)].id)); + ;} + break; + + case 360: + +/* Line 1464 of yacc.c */ +#line 2455 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, (yyvsp[(1) - (2)].id), 0, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 361: + +/* Line 1464 of yacc.c */ +#line 2459 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].nd), (yyvsp[(4) - (4)].id)); + ;} + break; + + case 362: + +/* Line 1464 of yacc.c */ +#line 2463 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 364: + +/* Line 1464 of yacc.c */ +#line 2470 "src/parse.y" + { + p->cmd_start = TRUE; + (yyval.nd) = (yyvsp[(1) - (1)].nd); + ;} + break; + + case 365: + +/* Line 1464 of yacc.c */ +#line 2477 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 366: + +/* Line 1464 of yacc.c */ +#line 2481 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 367: + +/* Line 1464 of yacc.c */ +#line 2485 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (4)].nd); + ;} + break; + + case 368: + +/* Line 1464 of yacc.c */ +#line 2492 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 369: + +/* Line 1464 of yacc.c */ +#line 2496 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 372: + +/* Line 1464 of yacc.c */ +#line 2506 "src/parse.y" + { + local_add_f(p, (yyvsp[(1) - (1)].id)); + new_bv(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 374: + +/* Line 1464 of yacc.c */ +#line 2514 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (4)].nd); + ;} + break; + + case 375: + +/* Line 1464 of yacc.c */ +#line 2518 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (1)].nd); + ;} + break; + + case 376: + +/* Line 1464 of yacc.c */ +#line 2524 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + ;} + break; + + case 377: + +/* Line 1464 of yacc.c */ +#line 2528 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + ;} + break; + + case 378: + +/* Line 1464 of yacc.c */ +#line 2534 "src/parse.y" + { + local_nest(p); + ;} + break; + + case 379: + +/* Line 1464 of yacc.c */ +#line 2540 "src/parse.y" + { + (yyval.nd) = new_block(p,(yyvsp[(3) - (5)].nd),(yyvsp[(4) - (5)].nd)); + local_unnest(p); + ;} + break; + + case 380: + +/* Line 1464 of yacc.c */ +#line 2547 "src/parse.y" + { + if ((yyvsp[(1) - (2)].nd)->car == (node*)NODE_YIELD) { + yyerror(p, "block given to yield"); + } + else { + call_with_block(p, (yyvsp[(1) - (2)].nd), (yyvsp[(2) - (2)].nd)); + } + (yyval.nd) = (yyvsp[(1) - (2)].nd); + ;} + break; + + case 381: + +/* Line 1464 of yacc.c */ +#line 2557 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 382: + +/* Line 1464 of yacc.c */ +#line 2561 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].nd)); + call_with_block(p, (yyval.nd), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 383: + +/* Line 1464 of yacc.c */ +#line 2566 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (5)].nd), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].nd)); + call_with_block(p, (yyval.nd), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 384: + +/* Line 1464 of yacc.c */ +#line 2573 "src/parse.y" + { + (yyval.nd) = new_fcall(p, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 385: + +/* Line 1464 of yacc.c */ +#line 2577 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 386: + +/* Line 1464 of yacc.c */ +#line 2581 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].nd)); + ;} + break; + + case 387: + +/* Line 1464 of yacc.c */ +#line 2585 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].id), 0); + ;} + break; + + case 388: + +/* Line 1464 of yacc.c */ +#line 2589 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), intern("call",4), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 389: + +/* Line 1464 of yacc.c */ +#line 2593 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (3)].nd), intern("call",4), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 390: + +/* Line 1464 of yacc.c */ +#line 2597 "src/parse.y" + { + (yyval.nd) = new_super(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 391: + +/* Line 1464 of yacc.c */ +#line 2601 "src/parse.y" + { + (yyval.nd) = new_zsuper(p); + ;} + break; + + case 392: + +/* Line 1464 of yacc.c */ +#line 2605 "src/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[(1) - (4)].nd), intern("[]",2), (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 393: + +/* Line 1464 of yacc.c */ +#line 2611 "src/parse.y" + { + local_nest(p); + (yyval.num) = p->lineno; + ;} + break; + + case 394: + +/* Line 1464 of yacc.c */ +#line 2617 "src/parse.y" + { + (yyval.nd) = new_block(p,(yyvsp[(3) - (5)].nd),(yyvsp[(4) - (5)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(2) - (5)].num)); + local_unnest(p); + ;} + break; + + case 395: + +/* Line 1464 of yacc.c */ +#line 2623 "src/parse.y" + { + local_nest(p); + (yyval.num) = p->lineno; + ;} + break; + + case 396: + +/* Line 1464 of yacc.c */ +#line 2629 "src/parse.y" + { + (yyval.nd) = new_block(p,(yyvsp[(3) - (5)].nd),(yyvsp[(4) - (5)].nd)); + SET_LINENO((yyval.nd), (yyvsp[(2) - (5)].num)); + local_unnest(p); + ;} + break; + + case 397: + +/* Line 1464 of yacc.c */ +#line 2639 "src/parse.y" + { + (yyval.nd) = cons(cons((yyvsp[(2) - (5)].nd), (yyvsp[(4) - (5)].nd)), (yyvsp[(5) - (5)].nd)); + ;} + break; + + case 398: + +/* Line 1464 of yacc.c */ +#line 2645 "src/parse.y" + { + if ((yyvsp[(1) - (1)].nd)) { + (yyval.nd) = cons(cons(0, (yyvsp[(1) - (1)].nd)), 0); + } + else { + (yyval.nd) = 0; + } + ;} + break; + + case 400: + +/* Line 1464 of yacc.c */ +#line 2659 "src/parse.y" + { + (yyval.nd) = list1(list3((yyvsp[(2) - (6)].nd), (yyvsp[(3) - (6)].nd), (yyvsp[(5) - (6)].nd))); + if ((yyvsp[(6) - (6)].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[(6) - (6)].nd)); + ;} + break; + + case 402: + +/* Line 1464 of yacc.c */ +#line 2667 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 405: + +/* Line 1464 of yacc.c */ +#line 2675 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 407: + +/* Line 1464 of yacc.c */ +#line 2682 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 415: + +/* Line 1464 of yacc.c */ +#line 2697 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 416: + +/* Line 1464 of yacc.c */ +#line 2701 "src/parse.y" + { + (yyval.nd) = new_dstr(p, push((yyvsp[(2) - (3)].nd), (yyvsp[(3) - (3)].nd))); + ;} + break; + + case 418: + +/* Line 1464 of yacc.c */ +#line 2708 "src/parse.y" + { + (yyval.nd) = append((yyvsp[(1) - (2)].nd), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 419: + +/* Line 1464 of yacc.c */ +#line 2714 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 420: + +/* Line 1464 of yacc.c */ +#line 2718 "src/parse.y" + { + (yyval.nd) = p->lex_strterm; + p->lex_strterm = NULL; + ;} + break; + + case 421: + +/* Line 1464 of yacc.c */ +#line 2724 "src/parse.y" + { + p->lex_strterm = (yyvsp[(2) - (4)].nd); + (yyval.nd) = list2((yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 422: + +/* Line 1464 of yacc.c */ +#line 2729 "src/parse.y" + { + (yyval.nd) = list1(new_literal_delim(p)); + ;} + break; + + case 423: + +/* Line 1464 of yacc.c */ +#line 2733 "src/parse.y" + { + (yyval.nd) = list1(new_literal_delim(p)); + ;} + break; + + case 424: + +/* Line 1464 of yacc.c */ +#line 2739 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 425: + +/* Line 1464 of yacc.c */ +#line 2743 "src/parse.y" + { + (yyval.nd) = new_dxstr(p, push((yyvsp[(2) - (3)].nd), (yyvsp[(3) - (3)].nd))); + ;} + break; + + case 426: + +/* Line 1464 of yacc.c */ +#line 2749 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (2)].nd); + ;} + break; + + case 427: + +/* Line 1464 of yacc.c */ +#line 2753 "src/parse.y" + { + (yyval.nd) = new_dregx(p, (yyvsp[(2) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 433: + +/* Line 1464 of yacc.c */ +#line 2770 "src/parse.y" + { + parser_heredoc_info * inf = parsing_heredoc_inf(p); + inf->doc = push(inf->doc, new_str(p, "", 0)); + heredoc_end(p); + ;} + break; + + case 434: + +/* Line 1464 of yacc.c */ +#line 2776 "src/parse.y" + { + heredoc_end(p); + ;} + break; + + case 437: + +/* Line 1464 of yacc.c */ +#line 2786 "src/parse.y" + { + parser_heredoc_info * inf = parsing_heredoc_inf(p); + inf->doc = push(inf->doc, (yyvsp[(1) - (1)].nd)); + heredoc_treat_nextline(p); + ;} + break; + + case 438: + +/* Line 1464 of yacc.c */ +#line 2792 "src/parse.y" + { + (yyval.nd) = p->lex_strterm; + p->lex_strterm = NULL; + ;} + break; + + case 439: + +/* Line 1464 of yacc.c */ +#line 2798 "src/parse.y" + { + parser_heredoc_info * inf = parsing_heredoc_inf(p); + p->lex_strterm = (yyvsp[(2) - (4)].nd); + inf->doc = push(push(inf->doc, (yyvsp[(1) - (4)].nd)), (yyvsp[(3) - (4)].nd)); + ;} + break; + + case 440: + +/* Line 1464 of yacc.c */ +#line 2806 "src/parse.y" + { + (yyval.nd) = new_words(p, list1((yyvsp[(2) - (2)].nd))); + ;} + break; + + case 441: + +/* Line 1464 of yacc.c */ +#line 2810 "src/parse.y" + { + (yyval.nd) = new_words(p, push((yyvsp[(2) - (3)].nd), (yyvsp[(3) - (3)].nd))); + ;} + break; + + case 442: + +/* Line 1464 of yacc.c */ +#line 2817 "src/parse.y" + { + (yyval.nd) = new_sym(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 443: + +/* Line 1464 of yacc.c */ +#line 2821 "src/parse.y" + { + p->lstate = EXPR_END; + (yyval.nd) = new_dsym(p, push((yyvsp[(3) - (4)].nd), (yyvsp[(4) - (4)].nd))); + ;} + break; + + case 444: + +/* Line 1464 of yacc.c */ +#line 2828 "src/parse.y" + { + p->lstate = EXPR_END; + (yyval.id) = (yyvsp[(2) - (2)].id); + ;} + break; + + case 449: + +/* Line 1464 of yacc.c */ +#line 2839 "src/parse.y" + { + (yyval.id) = new_strsym(p, (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 450: + +/* Line 1464 of yacc.c */ +#line 2843 "src/parse.y" + { + (yyval.id) = new_strsym(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 451: + +/* Line 1464 of yacc.c */ +#line 2849 "src/parse.y" + { + (yyval.nd) = new_symbols(p, list1((yyvsp[(2) - (2)].nd))); + ;} + break; + + case 452: + +/* Line 1464 of yacc.c */ +#line 2853 "src/parse.y" + { + (yyval.nd) = new_symbols(p, push((yyvsp[(2) - (3)].nd), (yyvsp[(3) - (3)].nd))); + ;} + break; + + case 455: + +/* Line 1464 of yacc.c */ +#line 2861 "src/parse.y" + { + (yyval.nd) = negate_lit(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 456: + +/* Line 1464 of yacc.c */ +#line 2865 "src/parse.y" + { + (yyval.nd) = negate_lit(p, (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 457: + +/* Line 1464 of yacc.c */ +#line 2871 "src/parse.y" + { + (yyval.nd) = new_lvar(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 458: + +/* Line 1464 of yacc.c */ +#line 2875 "src/parse.y" + { + (yyval.nd) = new_ivar(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 459: + +/* Line 1464 of yacc.c */ +#line 2879 "src/parse.y" + { + (yyval.nd) = new_gvar(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 460: + +/* Line 1464 of yacc.c */ +#line 2883 "src/parse.y" + { + (yyval.nd) = new_cvar(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 461: + +/* Line 1464 of yacc.c */ +#line 2887 "src/parse.y" + { + (yyval.nd) = new_const(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 462: + +/* Line 1464 of yacc.c */ +#line 2893 "src/parse.y" + { + assignable(p, (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 463: + +/* Line 1464 of yacc.c */ +#line 2899 "src/parse.y" + { + (yyval.nd) = var_reference(p, (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 464: + +/* Line 1464 of yacc.c */ +#line 2903 "src/parse.y" + { + (yyval.nd) = new_nil(p); + ;} + break; + + case 465: + +/* Line 1464 of yacc.c */ +#line 2907 "src/parse.y" + { + (yyval.nd) = new_self(p); + ;} + break; + + case 466: + +/* Line 1464 of yacc.c */ +#line 2911 "src/parse.y" + { + (yyval.nd) = new_true(p); + ;} + break; + + case 467: + +/* Line 1464 of yacc.c */ +#line 2915 "src/parse.y" + { + (yyval.nd) = new_false(p); + ;} + break; + + case 468: + +/* Line 1464 of yacc.c */ +#line 2919 "src/parse.y" + { + if (!p->filename) { + p->filename = "(null)"; + } + (yyval.nd) = new_str(p, p->filename, strlen(p->filename)); + ;} + break; + + case 469: + +/* Line 1464 of yacc.c */ +#line 2926 "src/parse.y" + { + char buf[16]; + + snprintf(buf, sizeof(buf), "%d", p->lineno); + (yyval.nd) = new_int(p, buf, 10); + ;} + break; + + case 472: + +/* Line 1464 of yacc.c */ +#line 2939 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + case 473: + +/* Line 1464 of yacc.c */ +#line 2943 "src/parse.y" + { + p->lstate = EXPR_BEG; + p->cmd_start = TRUE; + ;} + break; + + case 474: + +/* Line 1464 of yacc.c */ +#line 2948 "src/parse.y" + { + (yyval.nd) = (yyvsp[(3) - (4)].nd); + ;} + break; + + case 475: + +/* Line 1464 of yacc.c */ +#line 2952 "src/parse.y" + { + yyerrok; + (yyval.nd) = 0; + ;} + break; + + case 476: + +/* Line 1464 of yacc.c */ +#line 2959 "src/parse.y" + { + (yyval.nd) = (yyvsp[(2) - (3)].nd); + p->lstate = EXPR_BEG; + p->cmd_start = TRUE; + ;} + break; + + case 477: + +/* Line 1464 of yacc.c */ +#line 2965 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (2)].nd); + ;} + break; + + case 478: + +/* Line 1464 of yacc.c */ +#line 2971 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (6)].nd), (yyvsp[(3) - (6)].nd), (yyvsp[(5) - (6)].id), 0, (yyvsp[(6) - (6)].id)); + ;} + break; + + case 479: + +/* Line 1464 of yacc.c */ +#line 2975 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (8)].nd), (yyvsp[(3) - (8)].nd), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].nd), (yyvsp[(8) - (8)].id)); + ;} + break; + + case 480: + +/* Line 1464 of yacc.c */ +#line 2979 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].nd), 0, 0, (yyvsp[(4) - (4)].id)); + ;} + break; + + case 481: + +/* Line 1464 of yacc.c */ +#line 2983 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (6)].nd), (yyvsp[(3) - (6)].nd), 0, (yyvsp[(5) - (6)].nd), (yyvsp[(6) - (6)].id)); + ;} + break; + + case 482: + +/* Line 1464 of yacc.c */ +#line 2987 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (4)].nd), 0, (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id)); + ;} + break; + + case 483: + +/* Line 1464 of yacc.c */ +#line 2991 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (6)].nd), 0, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].nd), (yyvsp[(6) - (6)].id)); + ;} + break; + + case 484: + +/* Line 1464 of yacc.c */ +#line 2995 "src/parse.y" + { + (yyval.nd) = new_args(p, (yyvsp[(1) - (2)].nd), 0, 0, 0, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 485: + +/* Line 1464 of yacc.c */ +#line 2999 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (4)].nd), (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id)); + ;} + break; + + case 486: + +/* Line 1464 of yacc.c */ +#line 3003 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (6)].nd), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].nd), (yyvsp[(6) - (6)].id)); + ;} + break; + + case 487: + +/* Line 1464 of yacc.c */ +#line 3007 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (2)].nd), 0, 0, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 488: + +/* Line 1464 of yacc.c */ +#line 3011 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, (yyvsp[(1) - (4)].nd), 0, (yyvsp[(3) - (4)].nd), (yyvsp[(4) - (4)].id)); + ;} + break; + + case 489: + +/* Line 1464 of yacc.c */ +#line 3015 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, (yyvsp[(1) - (2)].id), 0, (yyvsp[(2) - (2)].id)); + ;} + break; + + case 490: + +/* Line 1464 of yacc.c */ +#line 3019 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].nd), (yyvsp[(4) - (4)].id)); + ;} + break; + + case 491: + +/* Line 1464 of yacc.c */ +#line 3023 "src/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 492: + +/* Line 1464 of yacc.c */ +#line 3027 "src/parse.y" + { + local_add_f(p, 0); + (yyval.nd) = new_args(p, 0, 0, 0, 0, 0); + ;} + break; + + case 493: + +/* Line 1464 of yacc.c */ +#line 3034 "src/parse.y" + { + yyerror(p, "formal argument cannot be a constant"); + (yyval.nd) = 0; + ;} + break; + + case 494: + +/* Line 1464 of yacc.c */ +#line 3039 "src/parse.y" + { + yyerror(p, "formal argument cannot be an instance variable"); + (yyval.nd) = 0; + ;} + break; + + case 495: + +/* Line 1464 of yacc.c */ +#line 3044 "src/parse.y" + { + yyerror(p, "formal argument cannot be a global variable"); + (yyval.nd) = 0; + ;} + break; + + case 496: + +/* Line 1464 of yacc.c */ +#line 3049 "src/parse.y" + { + yyerror(p, "formal argument cannot be a class variable"); + (yyval.nd) = 0; + ;} + break; + + case 497: + +/* Line 1464 of yacc.c */ +#line 3056 "src/parse.y" + { + (yyval.id) = 0; + ;} + break; + + case 498: + +/* Line 1464 of yacc.c */ +#line 3060 "src/parse.y" + { + local_add_f(p, (yyvsp[(1) - (1)].id)); + (yyval.id) = (yyvsp[(1) - (1)].id); + ;} + break; + + case 499: + +/* Line 1464 of yacc.c */ +#line 3067 "src/parse.y" + { + (yyval.nd) = new_arg(p, (yyvsp[(1) - (1)].id)); + ;} + break; + + case 500: + +/* Line 1464 of yacc.c */ +#line 3071 "src/parse.y" + { + (yyval.nd) = new_masgn(p, (yyvsp[(2) - (3)].nd), 0); + ;} + break; + + case 501: + +/* Line 1464 of yacc.c */ +#line 3077 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 502: + +/* Line 1464 of yacc.c */ +#line 3081 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 503: + +/* Line 1464 of yacc.c */ +#line 3087 "src/parse.y" + { + local_add_f(p, (yyvsp[(1) - (2)].id)); + (yyval.id) = (yyvsp[(1) - (2)].id); + ;} + break; + + case 504: + +/* Line 1464 of yacc.c */ +#line 3094 "src/parse.y" + { + (yyval.nd) = cons(nsym((yyvsp[(1) - (2)].id)), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 505: + +/* Line 1464 of yacc.c */ +#line 3100 "src/parse.y" + { + (yyval.nd) = cons(nsym((yyvsp[(1) - (2)].id)), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 506: + +/* Line 1464 of yacc.c */ +#line 3106 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 507: + +/* Line 1464 of yacc.c */ +#line 3110 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 508: + +/* Line 1464 of yacc.c */ +#line 3116 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + ;} + break; + + case 509: + +/* Line 1464 of yacc.c */ +#line 3120 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 512: + +/* Line 1464 of yacc.c */ +#line 3130 "src/parse.y" + { + local_add_f(p, (yyvsp[(2) - (2)].id)); + (yyval.id) = (yyvsp[(2) - (2)].id); + ;} + break; + + case 513: + +/* Line 1464 of yacc.c */ +#line 3135 "src/parse.y" + { + local_add_f(p, 0); + (yyval.id) = -1; + ;} + break; + + case 516: + +/* Line 1464 of yacc.c */ +#line 3146 "src/parse.y" + { + local_add_f(p, (yyvsp[(2) - (2)].id)); + (yyval.id) = (yyvsp[(2) - (2)].id); + ;} + break; + + case 517: + +/* Line 1464 of yacc.c */ +#line 3153 "src/parse.y" + { + (yyval.id) = (yyvsp[(2) - (2)].id); + ;} + break; + + case 518: + +/* Line 1464 of yacc.c */ +#line 3157 "src/parse.y" + { + local_add_f(p, 0); + (yyval.id) = 0; + ;} + break; + + case 519: + +/* Line 1464 of yacc.c */ +#line 3164 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (1)].nd); + if (!(yyval.nd)) (yyval.nd) = new_nil(p); + ;} + break; + + case 520: + +/* Line 1464 of yacc.c */ +#line 3168 "src/parse.y" + {p->lstate = EXPR_BEG;;} + break; + + case 521: + +/* Line 1464 of yacc.c */ +#line 3169 "src/parse.y" + { + if ((yyvsp[(3) - (4)].nd) == 0) { + yyerror(p, "can't define singleton method for ()."); + } + else { + switch ((enum node_type)(int)(intptr_t)(yyvsp[(3) - (4)].nd)->car) { + case NODE_STR: + case NODE_DSTR: + case NODE_XSTR: + case NODE_DXSTR: + case NODE_DREGX: + case NODE_MATCH: + case NODE_FLOAT: + case NODE_ARRAY: + case NODE_HEREDOC: + yyerror(p, "can't define singleton method for literals"); + default: + break; + } + } + (yyval.nd) = (yyvsp[(3) - (4)].nd); + ;} + break; + + case 523: + +/* Line 1464 of yacc.c */ +#line 3195 "src/parse.y" + { + (yyval.nd) = (yyvsp[(1) - (2)].nd); + ;} + break; + + case 524: + +/* Line 1464 of yacc.c */ +#line 3201 "src/parse.y" + { + (yyval.nd) = list1((yyvsp[(1) - (1)].nd)); + NODE_LINENO((yyval.nd), (yyvsp[(1) - (1)].nd)); + ;} + break; + + case 525: + +/* Line 1464 of yacc.c */ +#line 3206 "src/parse.y" + { + (yyval.nd) = push((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 526: + +/* Line 1464 of yacc.c */ +#line 3212 "src/parse.y" + { + (yyval.nd) = cons((yyvsp[(1) - (3)].nd), (yyvsp[(3) - (3)].nd)); + ;} + break; + + case 527: + +/* Line 1464 of yacc.c */ +#line 3216 "src/parse.y" + { + (yyval.nd) = cons(new_sym(p, (yyvsp[(1) - (2)].id)), (yyvsp[(2) - (2)].nd)); + ;} + break; + + case 549: + +/* Line 1464 of yacc.c */ +#line 3260 "src/parse.y" + {yyerrok;;} + break; + + case 551: + +/* Line 1464 of yacc.c */ +#line 3265 "src/parse.y" + { + p->lineno++; + p->column = 0; + ;} + break; + + case 554: + +/* Line 1464 of yacc.c */ +#line 3272 "src/parse.y" + {yyerrok;;} + break; + + case 555: + +/* Line 1464 of yacc.c */ +#line 3276 "src/parse.y" + { + (yyval.nd) = 0; + ;} + break; + + + +/* Line 1464 of yacc.c */ +#line 9260 "C:/Users/matsuzaki.takuya/work/daily/20150106/mruby-1.1.0/build/ARMCA9/src/y.tab.c" + default: break; + } + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (p, YY_("syntax error")); +#else + { + YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) + { + YYSIZE_T yyalloc = 2 * yysize; + if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) + { + (void) yysyntax_error (yymsg, yystate, yychar); + yyerror (p, yymsg); + } + else + { + yyerror (p, YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval, p); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp, p); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined(yyoverflow) || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (p, YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval, p); + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp, p); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + + +/* Line 1684 of yacc.c */ +#line 3280 "src/parse.y" + +#define yylval (*((YYSTYPE*)(p->ylval))) + +static void +yyerror(parser_state *p, const char *s) +{ + char* c; + int n; + + if (! p->capture_errors) { +#ifdef ENABLE_STDIO + if (p->filename) { + fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s); + } + else { + fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s); + } +#endif + } + else if (p->nerr < sizeof(p->error_buffer) / sizeof(p->error_buffer[0])) { + n = strlen(s); + c = (char *)parser_palloc(p, n + 1); + memcpy(c, s, n + 1); + p->error_buffer[p->nerr].message = c; + p->error_buffer[p->nerr].lineno = p->lineno; + p->error_buffer[p->nerr].column = p->column; + } + p->nerr++; +} + +static void +yyerror_i(parser_state *p, const char *fmt, int i) +{ + char buf[256]; + + snprintf(buf, sizeof(buf), fmt, i); + yyerror(p, buf); +} + +static void +yywarn(parser_state *p, const char *s) +{ + char* c; + int n; + + if (! p->capture_errors) { +#ifdef ENABLE_STDIO + if (p->filename) { + fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s); + } + else { + fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s); + } +#endif + } + else if (p->nwarn < sizeof(p->warn_buffer) / sizeof(p->warn_buffer[0])) { + n = strlen(s); + c = (char *)parser_palloc(p, n + 1); + memcpy(c, s, n + 1); + p->warn_buffer[p->nwarn].message = c; + p->warn_buffer[p->nwarn].lineno = p->lineno; + p->warn_buffer[p->nwarn].column = p->column; + } + p->nwarn++; +} + +static void +yywarning(parser_state *p, const char *s) +{ + yywarn(p, s); +} + +static void +yywarning_s(parser_state *p, const char *fmt, const char *s) +{ + char buf[256]; + + snprintf(buf, sizeof(buf), fmt, s); + yywarning(p, buf); +} + +static void +backref_error(parser_state *p, node *n) +{ + int c; + + c = (int)(intptr_t)n->car; + + if (c == NODE_NTH_REF) { + yyerror_i(p, "can't set variable $%d", (int)(intptr_t)n->cdr); + } + else if (c == NODE_BACK_REF) { + yyerror_i(p, "can't set variable $%c", (int)(intptr_t)n->cdr); + } + else { + mrb_bug(p->mrb, "Internal error in backref_error() : n=>car == %S", mrb_fixnum_value(c)); + } +} + +static void pushback(parser_state *p, int c); +static mrb_bool peeks(parser_state *p, const char *s); +static mrb_bool skips(parser_state *p, const char *s); + +static inline int +nextc(parser_state *p) +{ + int c; + + if (p->pb) { + node *tmp; + + c = (int)(intptr_t)p->pb->car; + tmp = p->pb; + p->pb = p->pb->cdr; + cons_free(tmp); + } + else { +#ifdef ENABLE_STDIO + if (p->f) { + if (feof(p->f)) goto eof; + c = fgetc(p->f); + if (c == EOF) goto eof; + } + else +#endif + if (!p->s || p->s >= p->send) { + goto eof; + } + else { + c = (unsigned char)*p->s++; + } + } + if (c >= 0) { + p->column++; + } + if (c == '\r') { + c = nextc(p); + if (c != '\n') { + pushback(p, c); + return '\r'; + } + return c; + } + return c; + + eof: + if (!p->cxt) return -1; + else { + if (p->cxt->partial_hook(p) < 0) + return -1; /* end of program(s) */ + return -2; /* end of a file in the program files */ + } +} + +static void +pushback(parser_state *p, int c) +{ + if (c >= 0) { + p->column--; + } + p->pb = cons((node*)(intptr_t)c, p->pb); +} + +static void +skip(parser_state *p, char term) +{ + int c; + + for (;;) { + c = nextc(p); + if (c < 0) break; + if (c == term) break; + } +} + +static int +peekc_n(parser_state *p, int n) +{ + node *list = 0; + int c0; + + do { + c0 = nextc(p); + if (c0 == -1) return c0; /* do not skip partial EOF */ + list = push(list, (node*)(intptr_t)c0); + } while(n--); + if (p->pb) { + p->pb = append((node*)list, p->pb); + } + else { + p->pb = list; + } + return c0; +} + +static mrb_bool +peek_n(parser_state *p, int c, int n) +{ + return peekc_n(p, n) == c && c >= 0; +} +#define peek(p,c) peek_n((p), (c), 0) + +static mrb_bool +peeks(parser_state *p, const char *s) +{ + int len = strlen(s); + +#ifdef ENABLE_STDIO + if (p->f) { + int n = 0; + while (*s) { + if (!peek_n(p, *s++, n++)) return FALSE; + } + return TRUE; + } + else +#endif + if (p->s && p->s + len <= p->send) { + if (memcmp(p->s, s, len) == 0) return TRUE; + } + return FALSE; +} + +static mrb_bool +skips(parser_state *p, const char *s) +{ + int c; + + for (;;) { + /* skip until first char */ + for (;;) { + c = nextc(p); + if (c < 0) return c; + if (c == '\n') { + p->lineno++; + p->column = 0; + } + if (c == *s) break; + } + s++; + if (peeks(p, s)) { + int len = strlen(s); + + while (len--) { + if (nextc(p) == '\n') { + p->lineno++; + p->column = 0; + } + } + return TRUE; + } + else{ + s--; + } + } + return FALSE; +} + + +static int +newtok(parser_state *p) +{ + p->bidx = 0; + return p->column - 1; +} + +static void +tokadd(parser_state *p, int32_t c) +{ + char utf8[4]; + unsigned len; + + /* mrb_assert(-0x10FFFF <= c && c <= 0xFF); */ + if (c >= 0) { + /* Single byte from source or non-Unicode escape */ + utf8[0] = (char)c; + len = 1; + } + else { + /* Unicode character */ + c = -c; + if (c < 0x80) { + utf8[0] = (char)c; + len = 1; + } + else if (c < 0x800) { + utf8[0] = (char)(0xC0 | (c >> 6)); + utf8[1] = (char)(0x80 | (c & 0x3F)); + len = 2; + } + else if (c < 0x10000) { + utf8[0] = (char)(0xE0 | (c >> 12) ); + utf8[1] = (char)(0x80 | ((c >> 6) & 0x3F)); + utf8[2] = (char)(0x80 | ( c & 0x3F)); + len = 3; + } + else { + utf8[0] = (char)(0xF0 | (c >> 18) ); + utf8[1] = (char)(0x80 | ((c >> 12) & 0x3F)); + utf8[2] = (char)(0x80 | ((c >> 6) & 0x3F)); + utf8[3] = (char)(0x80 | ( c & 0x3F)); + len = 4; + } + } + if (p->bidx+len <= MRB_PARSER_BUF_SIZE) { + unsigned i; + for (i = 0; i < len; i++) { + p->buf[p->bidx++] = utf8[i]; + } + } +} + +static int +toklast(parser_state *p) +{ + return p->buf[p->bidx-1]; +} + +static void +tokfix(parser_state *p) +{ + if (p->bidx >= MRB_PARSER_BUF_SIZE) { + yyerror(p, "string too long (truncated)"); + } + p->buf[p->bidx] = '\0'; +} + +static const char* +tok(parser_state *p) +{ + return p->buf; +} + +static int +toklen(parser_state *p) +{ + return p->bidx; +} + +#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG) +#define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN) +#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS) +#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c)) +#define IS_LABEL_POSSIBLE() ((p->lstate == EXPR_BEG && !cmd_state) || IS_ARG()) +#define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1)) + +static int +scan_oct(const int *start, int len, int *retlen) +{ + const int *s = start; + int retval = 0; + + /* mrb_assert(len <= 3) */ + while (len-- && *s >= '0' && *s <= '7') { + retval <<= 3; + retval |= *s++ - '0'; + } + *retlen = s - start; + + return retval; +} + +static int32_t +scan_hex(const int *start, int len, int *retlen) +{ + static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF"; + const int *s = start; + int32_t retval = 0; + char *tmp; + + /* mrb_assert(len <= 8) */ + while (len-- && *s && (tmp = (char*)strchr(hexdigit, *s))) { + retval <<= 4; + retval |= (tmp - hexdigit) & 15; + s++; + } + *retlen = s - start; + + return retval; +} + +/* Return negative to indicate Unicode code point */ +static int32_t +read_escape(parser_state *p) +{ + int32_t c; + + switch (c = nextc(p)) { + case '\\':/* Backslash */ + return c; + + case 'n':/* newline */ + return '\n'; + + case 't':/* horizontal tab */ + return '\t'; + + case 'r':/* carriage-return */ + return '\r'; + + case 'f':/* form-feed */ + return '\f'; + + case 'v':/* vertical tab */ + return '\13'; + + case 'a':/* alarm(bell) */ + return '\007'; + + case 'e':/* escape */ + return 033; + + case '0': case '1': case '2': case '3': /* octal constant */ + case '4': case '5': case '6': case '7': + { + int buf[3]; + int i; + + buf[0] = c; + for (i=1; i<3; i++) { + buf[i] = nextc(p); + if (buf[i] < 0) goto eof; + if (buf[i] < '0' || '7' < buf[i]) { + pushback(p, buf[i]); + break; + } + } + c = scan_oct(buf, i, &i); + } + return c; + + case 'x': /* hex constant */ + { + int buf[2]; + int i; + + for (i=0; i<2; i++) { + buf[i] = nextc(p); + if (buf[i] < 0) goto eof; + if (!ISXDIGIT(buf[i])) { + pushback(p, buf[i]); + break; + } + } + c = scan_hex(buf, i, &i); + if (i == 0) { + yyerror(p, "Invalid escape character syntax"); + return 0; + } + } + return c; + + case 'u': /* Unicode */ + { + int buf[9]; + int i; + + /* Look for opening brace */ + i = 0; + buf[0] = nextc(p); + if (buf[0] < 0) goto eof; + if (buf[0] == '{') { + /* \u{xxxxxxxx} form */ + for (i=0; i<9; i++) { + buf[i] = nextc(p); + if (buf[i] < 0) goto eof; + if (buf[i] == '}') { + break; + } + else if (!ISXDIGIT(buf[i])) { + yyerror(p, "Invalid escape character syntax"); + pushback(p, buf[i]); + return 0; + } + } + } + else if (ISXDIGIT(buf[0])) { + /* \uxxxx form */ + for (i=1; i<4; i++) { + buf[i] = nextc(p); + if (buf[i] < 0) goto eof; + if (!ISXDIGIT(buf[i])) { + pushback(p, buf[i]); + break; + } + } + } + else { + pushback(p, buf[0]); + } + c = scan_hex(buf, i, &i); + if (i == 0) { + yyerror(p, "Invalid escape character syntax"); + return 0; + } + if (c < 0 || c > 0x10FFFF || (c & 0xFFFFF800) == 0xD800) { + yyerror(p, "Invalid Unicode code point"); + return 0; + } + } + return -c; + + case 'b':/* backspace */ + return '\010'; + + case 's':/* space */ + return ' '; + + case 'M': + if ((c = nextc(p)) != '-') { + yyerror(p, "Invalid escape character syntax"); + pushback(p, c); + return '\0'; + } + if ((c = nextc(p)) == '\\') { + return read_escape(p) | 0x80; + } + else if (c < 0) goto eof; + else { + return ((c & 0xff) | 0x80); + } + + case 'C': + if ((c = nextc(p)) != '-') { + yyerror(p, "Invalid escape character syntax"); + pushback(p, c); + return '\0'; + } + case 'c': + if ((c = nextc(p))== '\\') { + c = read_escape(p); + } + else if (c == '?') + return 0177; + else if (c < 0) goto eof; + return c & 0x9f; + + eof: + case -1: + case -2: /* end of a file */ + yyerror(p, "Invalid escape character syntax"); + return '\0'; + + default: + return c; + } +} + +static int +parse_string(parser_state *p) +{ + int c; + string_type type = (string_type)(intptr_t)p->lex_strterm->car; + int nest_level = (intptr_t)p->lex_strterm->cdr->car; + int beg = (intptr_t)p->lex_strterm->cdr->cdr->car; + int end = (intptr_t)p->lex_strterm->cdr->cdr->cdr; + parser_heredoc_info *hinf = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_inf(p) : NULL; + + newtok(p); + while ((c = nextc(p)) != end || nest_level != 0) { + if (hinf && (c == '\n' || c < 0)) { + mrb_bool line_head; + tokadd(p, '\n'); + tokfix(p); + p->lineno++; + p->column = 0; + line_head = hinf->line_head; + hinf->line_head = TRUE; + if (line_head) { + /* check whether end of heredoc */ + const char *s = tok(p); + int len = toklen(p); + if (hinf->allow_indent) { + while (ISSPACE(*s) && len > 0) { + ++s; + --len; + } + } + if ((len-1 == hinf->term_len) && (strncmp(s, hinf->term, len-1) == 0)) { + return tHEREDOC_END; + } + } + if (c < 0) { + char buf[256]; + snprintf(buf, sizeof(buf), "can't find heredoc delimiter \"%s\" anywhere before EOF", hinf->term); + yyerror(p, buf); + return 0; + } + yylval.nd = new_str(p, tok(p), toklen(p)); + return tHD_STRING_MID; + } + if (c < 0) { + yyerror(p, "unterminated string meets end of file"); + return 0; + } + else if (c == beg) { + nest_level++; + p->lex_strterm->cdr->car = (node*)(intptr_t)nest_level; + } + else if (c == end) { + nest_level--; + p->lex_strterm->cdr->car = (node*)(intptr_t)nest_level; + } + else if (c == '\\') { + c = nextc(p); + if (type & STR_FUNC_EXPAND) { + if (c == end || c == beg) { + tokadd(p, c); + } + else if (c == '\n') { + p->lineno++; + p->column = 0; + if (type & STR_FUNC_ARRAY) { + tokadd(p, '\n'); + } + } + else if (type & STR_FUNC_REGEXP) { + tokadd(p, '\\'); + tokadd(p, c); + } + else { + pushback(p, c); + tokadd(p, read_escape(p)); + if (hinf) + hinf->line_head = FALSE; + } + } + else { + if (c != beg && c != end) { + if (c == '\n') { + p->lineno++; + p->column = 0; + } + if (!(c == '\\' || ((type & STR_FUNC_ARRAY) && ISSPACE(c)))) { + tokadd(p, '\\'); + } + } + tokadd(p, c); + } + continue; + } + else if ((c == '#') && (type & STR_FUNC_EXPAND)) { + c = nextc(p); + if (c == '{') { + tokfix(p); + p->lstate = EXPR_BEG; + p->cmd_start = TRUE; + yylval.nd = new_str(p, tok(p), toklen(p)); + if (hinf) { + hinf->line_head = FALSE; + return tHD_STRING_PART; + } + return tSTRING_PART; + } + tokadd(p, '#'); + pushback(p, c); + continue; + } + if ((type & STR_FUNC_ARRAY) && ISSPACE(c)) { + if (toklen(p) == 0) { + do { + if (c == '\n') { + p->lineno++; + p->column = 0; + heredoc_treat_nextline(p); + if (p->parsing_heredoc != NULL) { + return tHD_LITERAL_DELIM; + } + } + c = nextc(p); + } while (ISSPACE(c)); + pushback(p, c); + return tLITERAL_DELIM; + } + else { + pushback(p, c); + tokfix(p); + yylval.nd = new_str(p, tok(p), toklen(p)); + return tSTRING_MID; + } + } + tokadd(p, c); + } + + tokfix(p); + p->lstate = EXPR_END; + end_strterm(p); + + if (type & STR_FUNC_XQUOTE) { + yylval.nd = new_xstr(p, tok(p), toklen(p)); + return tXSTRING; + } + + if (type & STR_FUNC_REGEXP) { + int f = 0; + int re_opt; + char *s = strndup(tok(p), toklen(p)); + char flags[3]; + char *flag = flags; + char *dup; + + newtok(p); + while (re_opt = nextc(p), re_opt >= 0 && ISALPHA(re_opt)) { + switch (re_opt) { + case 'i': f |= 1; break; + case 'x': f |= 2; break; + case 'm': f |= 4; break; + default: tokadd(p, re_opt); break; + } + } + pushback(p, re_opt); + if (toklen(p)) { + char msg[128]; + tokfix(p); + snprintf(msg, sizeof(msg), "unknown regexp option%s - %s", + toklen(p) > 1 ? "s" : "", tok(p)); + yyerror(p, msg); + } + if (f != 0) { + if (f & 1) *flag++ = 'i'; + if (f & 2) *flag++ = 'x'; + if (f & 4) *flag++ = 'm'; + dup = strndup(flags, (size_t)(flag - flags)); + } + else { + dup = NULL; + } + yylval.nd = new_regx(p, s, dup); + + return tREGEXP; + } + + yylval.nd = new_str(p, tok(p), toklen(p)); + return tSTRING; +} + + +static int +heredoc_identifier(parser_state *p) +{ + int c; + int type = str_heredoc; + mrb_bool indent = FALSE; + mrb_bool quote = FALSE; + node *newnode; + parser_heredoc_info *info; + + c = nextc(p); + if (ISSPACE(c) || c == '=') { + pushback(p, c); + return 0; + } + if (c == '-') { + indent = TRUE; + c = nextc(p); + } + if (c == '\'' || c == '"') { + int term = c; + if (c == '\'') + quote = TRUE; + newtok(p); + while ((c = nextc(p)) >= 0 && c != term) { + if (c == '\n') { + c = -1; + break; + } + tokadd(p, c); + } + if (c < 0) { + yyerror(p, "unterminated here document identifier"); + return 0; + } + } + else { + if (c < 0) { + return 0; /* missing here document identifier */ + } + if (! identchar(c)) { + pushback(p, c); + if (indent) pushback(p, '-'); + return 0; + } + newtok(p); + do { + tokadd(p, c); + } while ((c = nextc(p)) >= 0 && identchar(c)); + pushback(p, c); + } + tokfix(p); + newnode = new_heredoc(p); + info = (parser_heredoc_info*)newnode->cdr; + info->term = strndup(tok(p), toklen(p)); + info->term_len = toklen(p); + if (! quote) + type |= STR_FUNC_EXPAND; + info->type = (string_type)type; + info->allow_indent = indent; + info->line_head = TRUE; + info->doc = NULL; + p->heredocs_from_nextline = push(p->heredocs_from_nextline, newnode); + p->lstate = EXPR_END; + + yylval.nd = newnode; + return tHEREDOC_BEG; +} + +static int +arg_ambiguous(parser_state *p) +{ + yywarning(p, "ambiguous first argument; put parentheses or even spaces"); + return 1; +} + +#include "lex.def" + +static int +parser_yylex(parser_state *p) +{ + int32_t c; + int space_seen = 0; + int cmd_state; + enum mrb_lex_state_enum last_state; + int token_column; + + if (p->lex_strterm) { + if (is_strterm_type(p, STR_FUNC_HEREDOC)) { + if (p->parsing_heredoc != NULL) + return parse_string(p); + } + else + return parse_string(p); + } + cmd_state = p->cmd_start; + p->cmd_start = FALSE; + retry: + last_state = p->lstate; + switch (c = nextc(p)) { + case '\0': /* NUL */ + case '\004': /* ^D */ + case '\032': /* ^Z */ + return 0; + case -1: /* end of script. */ + if (p->heredocs_from_nextline) + goto maybe_heredoc; + return 0; + + /* white spaces */ + case ' ': case '\t': case '\f': case '\r': + case '\13': /* '\v' */ + space_seen = 1; + goto retry; + + case '#': /* it's a comment */ + skip(p, '\n'); + /* fall through */ + case -2: /* end of a file */ + case '\n': + maybe_heredoc: + heredoc_treat_nextline(p); + switch (p->lstate) { + case EXPR_BEG: + case EXPR_FNAME: + case EXPR_DOT: + case EXPR_CLASS: + case EXPR_VALUE: + p->lineno++; + p->column = 0; + if (p->parsing_heredoc != NULL) { + return parse_string(p); + } + goto retry; + default: + break; + } + if (p->parsing_heredoc != NULL) { + return '\n'; + } + while ((c = nextc(p))) { + switch (c) { + case ' ': case '\t': case '\f': case '\r': + case '\13': /* '\v' */ + space_seen = 1; + break; + case '.': + if ((c = nextc(p)) != '.') { + pushback(p, c); + pushback(p, '.'); + goto retry; + } + case -1: /* EOF */ + case -2: /* end of a file */ + goto normal_newline; + default: + pushback(p, c); + goto normal_newline; + } + } + normal_newline: + p->cmd_start = TRUE; + p->lstate = EXPR_BEG; + return '\n'; + + case '*': + if ((c = nextc(p)) == '*') { + if ((c = nextc(p)) == '=') { + yylval.id = intern("**",2); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + c = tPOW; + } + else { + if (c == '=') { + yylval.id = intern_c('*'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + if (IS_SPCARG(c)) { + yywarning(p, "`*' interpreted as argument prefix"); + c = tSTAR; + } + else if (IS_BEG()) { + c = tSTAR; + } + else { + c = '*'; + } + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + return c; + + case '!': + c = nextc(p); + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + if (c == '@') { + return '!'; + } + } + else { + p->lstate = EXPR_BEG; + } + if (c == '=') { + return tNEQ; + } + if (c == '~') { + return tNMATCH; + } + pushback(p, c); + return '!'; + + case '=': + if (p->column == 1) { + static const char begin[] = "begin"; + static const char end[] = "\n=end"; + if (peeks(p, begin)) { + c = peekc_n(p, sizeof(begin)-1); + if (c < 0 || ISSPACE(c)) { + do { + if (!skips(p, end)) { + yyerror(p, "embedded document meets end of file"); + return 0; + } + c = nextc(p); + } while (!(c < 0 || ISSPACE(c))); + if (c != '\n') skip(p, '\n'); + p->lineno++; + p->column = 0; + goto retry; + } + } + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + if ((c = nextc(p)) == '=') { + if ((c = nextc(p)) == '=') { + return tEQQ; + } + pushback(p, c); + return tEQ; + } + if (c == '~') { + return tMATCH; + } + else if (c == '>') { + return tASSOC; + } + pushback(p, c); + return '='; + + case '<': + c = nextc(p); + if (c == '<' && + p->lstate != EXPR_DOT && + p->lstate != EXPR_CLASS && + !IS_END() && + (!IS_ARG() || space_seen)) { + int token = heredoc_identifier(p); + if (token) + return token; + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + if (p->lstate == EXPR_CLASS) { + p->cmd_start = TRUE; + } + } + if (c == '=') { + if ((c = nextc(p)) == '>') { + return tCMP; + } + pushback(p, c); + return tLEQ; + } + if (c == '<') { + if ((c = nextc(p)) == '=') { + yylval.id = intern("<<",2); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + return tLSHFT; + } + pushback(p, c); + return '<'; + + case '>': + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + if ((c = nextc(p)) == '=') { + return tGEQ; + } + if (c == '>') { + if ((c = nextc(p)) == '=') { + yylval.id = intern(">>",2); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + return tRSHFT; + } + pushback(p, c); + return '>'; + + case '"': + p->lex_strterm = new_strterm(p, str_dquote, '"', 0); + return tSTRING_BEG; + + case '\'': + p->lex_strterm = new_strterm(p, str_squote, '\'', 0); + return parse_string(p); + + case '`': + if (p->lstate == EXPR_FNAME) { + p->lstate = EXPR_ENDFN; + return '`'; + } + if (p->lstate == EXPR_DOT) { + if (cmd_state) + p->lstate = EXPR_CMDARG; + else + p->lstate = EXPR_ARG; + return '`'; + } + p->lex_strterm = new_strterm(p, str_xquote, '`', 0); + return tXSTRING_BEG; + + case '?': + if (IS_END()) { + p->lstate = EXPR_VALUE; + return '?'; + } + c = nextc(p); + if (c < 0) { + yyerror(p, "incomplete character syntax"); + return 0; + } + if (ISSPACE(c)) { + if (!IS_ARG()) { + int c2; + switch (c) { + case ' ': + c2 = 's'; + break; + case '\n': + c2 = 'n'; + break; + case '\t': + c2 = 't'; + break; + case '\v': + c2 = 'v'; + break; + case '\r': + c2 = 'r'; + break; + case '\f': + c2 = 'f'; + break; + default: + c2 = 0; + break; + } + if (c2) { + char buf[256]; + snprintf(buf, sizeof(buf), "invalid character syntax; use ?\\%c", c2); + yyerror(p, buf); + } + } + ternary: + pushback(p, c); + p->lstate = EXPR_VALUE; + return '?'; + } + newtok(p); + /* need support UTF-8 if configured */ + if ((isalnum(c) || c == '_')) { + int c2 = nextc(p); + pushback(p, c2); + if ((isalnum(c2) || c2 == '_')) { + goto ternary; + } + } + if (c == '\\') { + c = read_escape(p); + tokadd(p, c); + } + else { + tokadd(p, c); + } + tokfix(p); + yylval.nd = new_str(p, tok(p), toklen(p)); + p->lstate = EXPR_END; + return tCHAR; + + case '&': + if ((c = nextc(p)) == '&') { + p->lstate = EXPR_BEG; + if ((c = nextc(p)) == '=') { + yylval.id = intern("&&",2); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + return tANDOP; + } + else if (c == '=') { + yylval.id = intern_c('&'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + if (IS_SPCARG(c)) { + yywarning(p, "`&' interpreted as argument prefix"); + c = tAMPER; + } + else if (IS_BEG()) { + c = tAMPER; + } + else { + c = '&'; + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + return c; + + case '|': + if ((c = nextc(p)) == '|') { + p->lstate = EXPR_BEG; + if ((c = nextc(p)) == '=') { + yylval.id = intern("||",2); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + return tOROP; + } + if (c == '=') { + yylval.id = intern_c('|'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + pushback(p, c); + return '|'; + + case '+': + c = nextc(p); + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + if (c == '@') { + return tUPLUS; + } + pushback(p, c); + return '+'; + } + if (c == '=') { + yylval.id = intern_c('+'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) { + p->lstate = EXPR_BEG; + pushback(p, c); + if (c >= 0 && ISDIGIT(c)) { + c = '+'; + goto start_num; + } + return tUPLUS; + } + p->lstate = EXPR_BEG; + pushback(p, c); + return '+'; + + case '-': + c = nextc(p); + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + if (c == '@') { + return tUMINUS; + } + pushback(p, c); + return '-'; + } + if (c == '=') { + yylval.id = intern_c('-'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + if (c == '>') { + p->lstate = EXPR_ENDFN; + return tLAMBDA; + } + if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) { + p->lstate = EXPR_BEG; + pushback(p, c); + if (c >= 0 && ISDIGIT(c)) { + return tUMINUS_NUM; + } + return tUMINUS; + } + p->lstate = EXPR_BEG; + pushback(p, c); + return '-'; + + case '.': + p->lstate = EXPR_BEG; + if ((c = nextc(p)) == '.') { + if ((c = nextc(p)) == '.') { + return tDOT3; + } + pushback(p, c); + return tDOT2; + } + pushback(p, c); + if (c >= 0 && ISDIGIT(c)) { + yyerror(p, "no .<digit> floating literal anymore; put 0 before dot"); + } + p->lstate = EXPR_DOT; + return '.'; + + start_num: + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + { + int is_float, seen_point, seen_e, nondigit; + + is_float = seen_point = seen_e = nondigit = 0; + p->lstate = EXPR_END; + newtok(p); + if (c == '-' || c == '+') { + tokadd(p, c); + c = nextc(p); + } + if (c == '0') { +#define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0) + int start = toklen(p); + c = nextc(p); + if (c == 'x' || c == 'X') { + /* hexadecimal */ + c = nextc(p); + if (c >= 0 && ISXDIGIT(c)) { + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (!ISXDIGIT(c)) break; + nondigit = 0; + tokadd(p, tolower(c)); + } while ((c = nextc(p)) >= 0); + } + pushback(p, c); + tokfix(p); + if (toklen(p) == start) { + no_digits(); + } + else if (nondigit) goto trailing_uc; + yylval.nd = new_int(p, tok(p), 16); + return tINTEGER; + } + if (c == 'b' || c == 'B') { + /* binary */ + c = nextc(p); + if (c == '0' || c == '1') { + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (c != '0' && c != '1') break; + nondigit = 0; + tokadd(p, c); + } while ((c = nextc(p)) >= 0); + } + pushback(p, c); + tokfix(p); + if (toklen(p) == start) { + no_digits(); + } + else if (nondigit) goto trailing_uc; + yylval.nd = new_int(p, tok(p), 2); + return tINTEGER; + } + if (c == 'd' || c == 'D') { + /* decimal */ + c = nextc(p); + if (c >= 0 && ISDIGIT(c)) { + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (!ISDIGIT(c)) break; + nondigit = 0; + tokadd(p, c); + } while ((c = nextc(p)) >= 0); + } + pushback(p, c); + tokfix(p); + if (toklen(p) == start) { + no_digits(); + } + else if (nondigit) goto trailing_uc; + yylval.nd = new_int(p, tok(p), 10); + return tINTEGER; + } + if (c == '_') { + /* 0_0 */ + goto octal_number; + } + if (c == 'o' || c == 'O') { + /* prefixed octal */ + c = nextc(p); + if (c < 0 || c == '_' || !ISDIGIT(c)) { + no_digits(); + } + } + if (c >= '0' && c <= '7') { + /* octal */ + octal_number: + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (c < '0' || c > '9') break; + if (c > '7') goto invalid_octal; + nondigit = 0; + tokadd(p, c); + } while ((c = nextc(p)) >= 0); + + if (toklen(p) > start) { + pushback(p, c); + tokfix(p); + if (nondigit) goto trailing_uc; + yylval.nd = new_int(p, tok(p), 8); + return tINTEGER; + } + if (nondigit) { + pushback(p, c); + goto trailing_uc; + } + } + if (c > '7' && c <= '9') { + invalid_octal: + yyerror(p, "Invalid octal digit"); + } + else if (c == '.' || c == 'e' || c == 'E') { + tokadd(p, '0'); + } + else { + pushback(p, c); + yylval.nd = new_int(p, "0", 10); + return tINTEGER; + } + } + + for (;;) { + switch (c) { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + nondigit = 0; + tokadd(p, c); + break; + + case '.': + if (nondigit) goto trailing_uc; + if (seen_point || seen_e) { + goto decode_num; + } + else { + int c0 = nextc(p); + if (c0 < 0 || !ISDIGIT(c0)) { + pushback(p, c0); + goto decode_num; + } + c = c0; + } + tokadd(p, '.'); + tokadd(p, c); + is_float++; + seen_point++; + nondigit = 0; + break; + + case 'e': + case 'E': + if (nondigit) { + pushback(p, c); + c = nondigit; + goto decode_num; + } + if (seen_e) { + goto decode_num; + } + tokadd(p, c); + seen_e++; + is_float++; + nondigit = c; + c = nextc(p); + if (c != '-' && c != '+') continue; + tokadd(p, c); + nondigit = c; + break; + + case '_': /* `_' in number just ignored */ + if (nondigit) goto decode_num; + nondigit = c; + break; + + default: + goto decode_num; + } + c = nextc(p); + } + + decode_num: + pushback(p, c); + if (nondigit) { + trailing_uc: + yyerror_i(p, "trailing `%c' in number", nondigit); + } + tokfix(p); + if (is_float) { + double d; + char *endp; + + errno = 0; + d = strtod(tok(p), &endp); + if (d == 0 && endp == tok(p)) { + yywarning_s(p, "corrupted float value %s", tok(p)); + } + else if (errno == ERANGE) { + yywarning_s(p, "float %s out of range", tok(p)); + errno = 0; + } + yylval.nd = new_float(p, tok(p)); + return tFLOAT; + } + yylval.nd = new_int(p, tok(p), 10); + return tINTEGER; + } + + case ')': + case ']': + p->paren_nest--; + case '}': + COND_LEXPOP(); + CMDARG_LEXPOP(); + if (c == ')') + p->lstate = EXPR_ENDFN; + else + p->lstate = EXPR_ENDARG; + return c; + + case ':': + c = nextc(p); + if (c == ':') { + if (IS_BEG() || p->lstate == EXPR_CLASS || IS_SPCARG(-1)) { + p->lstate = EXPR_BEG; + return tCOLON3; + } + p->lstate = EXPR_DOT; + return tCOLON2; + } + if (IS_END() || ISSPACE(c)) { + pushback(p, c); + p->lstate = EXPR_BEG; + return ':'; + } + pushback(p, c); + p->lstate = EXPR_FNAME; + return tSYMBEG; + + case '/': + if (IS_BEG()) { + p->lex_strterm = new_strterm(p, str_regexp, '/', 0); + return tREGEXP_BEG; + } + if ((c = nextc(p)) == '=') { + yylval.id = intern_c('/'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + pushback(p, c); + if (IS_SPCARG(c)) { + p->lex_strterm = new_strterm(p, str_regexp, '/', 0); + return tREGEXP_BEG; + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + return '/'; + + case '^': + if ((c = nextc(p)) == '=') { + yylval.id = intern_c('^'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + pushback(p, c); + return '^'; + + case ';': + p->lstate = EXPR_BEG; + return ';'; + + case ',': + p->lstate = EXPR_BEG; + return ','; + + case '~': + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + if ((c = nextc(p)) != '@') { + pushback(p, c); + } + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + return '~'; + + case '(': + if (IS_BEG()) { + c = tLPAREN; + } + else if (IS_SPCARG(-1)) { + c = tLPAREN_ARG; + } + p->paren_nest++; + COND_PUSH(0); + CMDARG_PUSH(0); + p->lstate = EXPR_BEG; + return c; + + case '[': + p->paren_nest++; + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + if ((c = nextc(p)) == ']') { + if ((c = nextc(p)) == '=') { + return tASET; + } + pushback(p, c); + return tAREF; + } + pushback(p, c); + return '['; + } + else if (IS_BEG()) { + c = tLBRACK; + } + else if (IS_ARG() && space_seen) { + c = tLBRACK; + } + p->lstate = EXPR_BEG; + COND_PUSH(0); + CMDARG_PUSH(0); + return c; + + case '{': + if (p->lpar_beg && p->lpar_beg == p->paren_nest) { + p->lstate = EXPR_BEG; + p->lpar_beg = 0; + p->paren_nest--; + COND_PUSH(0); + CMDARG_PUSH(0); + return tLAMBEG; + } + if (IS_ARG() || p->lstate == EXPR_END || p->lstate == EXPR_ENDFN) + c = '{'; /* block (primary) */ + else if (p->lstate == EXPR_ENDARG) + c = tLBRACE_ARG; /* block (expr) */ + else + c = tLBRACE; /* hash */ + COND_PUSH(0); + CMDARG_PUSH(0); + p->lstate = EXPR_BEG; + return c; + + case '\\': + c = nextc(p); + if (c == '\n') { + p->lineno++; + p->column = 0; + space_seen = 1; + goto retry; /* skip \\n */ + } + pushback(p, c); + return '\\'; + + case '%': + if (IS_BEG()) { + int term; + int paren; + + c = nextc(p); + quotation: + if (c < 0 || !ISALNUM(c)) { + term = c; + c = 'Q'; + } + else { + term = nextc(p); + if (isalnum(term)) { + yyerror(p, "unknown type of %string"); + return 0; + } + } + if (c < 0 || term < 0) { + yyerror(p, "unterminated quoted string meets end of file"); + return 0; + } + paren = term; + if (term == '(') term = ')'; + else if (term == '[') term = ']'; + else if (term == '{') term = '}'; + else if (term == '<') term = '>'; + else paren = 0; + + switch (c) { + case 'Q': + p->lex_strterm = new_strterm(p, str_dquote, term, paren); + return tSTRING_BEG; + + case 'q': + p->lex_strterm = new_strterm(p, str_squote, term, paren); + return parse_string(p); + + case 'W': + p->lex_strterm = new_strterm(p, str_dword, term, paren); + return tWORDS_BEG; + + case 'w': + p->lex_strterm = new_strterm(p, str_sword, term, paren); + return tWORDS_BEG; + + case 'x': + p->lex_strterm = new_strterm(p, str_xquote, term, paren); + return tXSTRING_BEG; + + case 'r': + p->lex_strterm = new_strterm(p, str_regexp, term, paren); + return tREGEXP_BEG; + + case 's': + p->lex_strterm = new_strterm(p, str_ssym, term, paren); + return tSYMBEG; + + case 'I': + p->lex_strterm = new_strterm(p, str_dsymbols, term, paren); + return tSYMBOLS_BEG; + + case 'i': + p->lex_strterm = new_strterm(p, str_ssymbols, term, paren); + return tSYMBOLS_BEG; + + default: + yyerror(p, "unknown type of %string"); + return 0; + } + } + if ((c = nextc(p)) == '=') { + yylval.id = intern_c('%'); + p->lstate = EXPR_BEG; + return tOP_ASGN; + } + if (IS_SPCARG(c)) { + goto quotation; + } + if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) { + p->lstate = EXPR_ARG; + } + else { + p->lstate = EXPR_BEG; + } + pushback(p, c); + return '%'; + + case '$': + p->lstate = EXPR_END; + token_column = newtok(p); + c = nextc(p); + if (c < 0) { + yyerror(p, "incomplete global variable syntax"); + return 0; + } + switch (c) { + case '_': /* $_: last read line string */ + c = nextc(p); + if (c >= 0 && identchar(c)) { /* if there is more after _ it is a variable */ + tokadd(p, '$'); + tokadd(p, c); + break; + } + pushback(p, c); + c = '_'; + /* fall through */ + case '~': /* $~: match-data */ + case '*': /* $*: argv */ + case '$': /* $$: pid */ + case '?': /* $?: last status */ + case '!': /* $!: error string */ + case '@': /* $@: error position */ + case '/': /* $/: input record separator */ + case '\\': /* $\: output record separator */ + case ';': /* $;: field separator */ + case ',': /* $,: output field separator */ + case '.': /* $.: last read line number */ + case '=': /* $=: ignorecase */ + case ':': /* $:: load path */ + case '<': /* $<: reading filename */ + case '>': /* $>: default output handle */ + case '\"': /* $": already loaded files */ + tokadd(p, '$'); + tokadd(p, c); + tokfix(p); + yylval.id = intern_cstr(tok(p)); + return tGVAR; + + case '-': + tokadd(p, '$'); + tokadd(p, c); + c = nextc(p); + pushback(p, c); + gvar: + tokfix(p); + yylval.id = intern_cstr(tok(p)); + return tGVAR; + + case '&': /* $&: last match */ + case '`': /* $`: string before last match */ + case '\'': /* $': string after last match */ + case '+': /* $+: string matches last pattern */ + if (last_state == EXPR_FNAME) { + tokadd(p, '$'); + tokadd(p, c); + goto gvar; + } + yylval.nd = new_back_ref(p, c); + return tBACK_REF; + + case '1': case '2': case '3': + case '4': case '5': case '6': + case '7': case '8': case '9': + do { + tokadd(p, c); + c = nextc(p); + } while (c >= 0 && isdigit(c)); + pushback(p, c); + if (last_state == EXPR_FNAME) goto gvar; + tokfix(p); + yylval.nd = new_nth_ref(p, atoi(tok(p))); + return tNTH_REF; + + default: + if (!identchar(c)) { + pushback(p, c); + return '$'; + } + case '0': + tokadd(p, '$'); + } + break; + + case '@': + c = nextc(p); + token_column = newtok(p); + tokadd(p, '@'); + if (c == '@') { + tokadd(p, '@'); + c = nextc(p); + } + if (c < 0) { + if (p->bidx == 1) { + yyerror(p, "incomplete instance variable syntax"); + } + else { + yyerror(p, "incomplete class variable syntax"); + } + return 0; + } + else if (isdigit(c)) { + if (p->bidx == 1) { + yyerror_i(p, "`@%c' is not allowed as an instance variable name", c); + } + else { + yyerror_i(p, "`@@%c' is not allowed as a class variable name", c); + } + return 0; + } + if (!identchar(c)) { + pushback(p, c); + return '@'; + } + break; + + case '_': + token_column = newtok(p); + break; + + default: + if (!identchar(c)) { + yyerror_i(p, "Invalid char `\\x%02X' in expression", c); + goto retry; + } + + token_column = newtok(p); + break; + } + + do { + tokadd(p, c); + c = nextc(p); + if (c < 0) break; + } while (identchar(c)); + if (token_column == 0 && toklen(p) == 7 && (c < 0 || c == '\n') && + strncmp(tok(p), "__END__", toklen(p)) == 0) + return -1; + + switch (tok(p)[0]) { + case '@': case '$': + pushback(p, c); + break; + default: + if ((c == '!' || c == '?') && !peek(p, '=')) { + tokadd(p, c); + } + else { + pushback(p, c); + } + } + tokfix(p); + { + int result = 0; + + switch (tok(p)[0]) { + case '$': + p->lstate = EXPR_END; + result = tGVAR; + break; + case '@': + p->lstate = EXPR_END; + if (tok(p)[1] == '@') + result = tCVAR; + else + result = tIVAR; + break; + + default: + if (toklast(p) == '!' || toklast(p) == '?') { + result = tFID; + } + else { + if (p->lstate == EXPR_FNAME) { + if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') && + (!peek(p, '=') || (peek_n(p, '>', 1)))) { + result = tIDENTIFIER; + tokadd(p, c); + tokfix(p); + } + else { + pushback(p, c); + } + } + if (result == 0 && ISUPPER(tok(p)[0])) { + result = tCONSTANT; + } + else { + result = tIDENTIFIER; + } + } + + if (IS_LABEL_POSSIBLE()) { + if (IS_LABEL_SUFFIX(0)) { + p->lstate = EXPR_BEG; + nextc(p); + tokfix(p); + yylval.id = intern_cstr(tok(p)); + return tLABEL; + } + } + if (p->lstate != EXPR_DOT) { + const struct kwtable *kw; + + /* See if it is a reserved word. */ + kw = mrb_reserved_word(tok(p), toklen(p)); + if (kw) { + enum mrb_lex_state_enum state = p->lstate; + yylval.num = p->lineno; + p->lstate = kw->state; + if (state == EXPR_FNAME) { + yylval.id = intern_cstr(kw->name); + return kw->id[0]; + } + if (p->lstate == EXPR_BEG) { + p->cmd_start = TRUE; + } + if (kw->id[0] == keyword_do) { + if (p->lpar_beg && p->lpar_beg == p->paren_nest) { + p->lpar_beg = 0; + p->paren_nest--; + return keyword_do_LAMBDA; + } + if (COND_P()) return keyword_do_cond; + if (CMDARG_P() && state != EXPR_CMDARG) + return keyword_do_block; + if (state == EXPR_ENDARG || state == EXPR_BEG) + return keyword_do_block; + return keyword_do; + } + if (state == EXPR_BEG || state == EXPR_VALUE) + return kw->id[0]; + else { + if (kw->id[0] != kw->id[1]) + p->lstate = EXPR_BEG; + return kw->id[1]; + } + } + } + + if (IS_BEG() || p->lstate == EXPR_DOT || IS_ARG()) { + if (cmd_state) { + p->lstate = EXPR_CMDARG; + } + else { + p->lstate = EXPR_ARG; + } + } + else if (p->lstate == EXPR_FNAME) { + p->lstate = EXPR_ENDFN; + } + else { + p->lstate = EXPR_END; + } + } + { + mrb_sym ident = intern_cstr(tok(p)); + + yylval.id = ident; +#if 0 + if (last_state != EXPR_DOT && islower(tok(p)[0]) && lvar_defined(ident)) { + p->lstate = EXPR_END; + } +#endif + } + return result; + } +} + +static int +yylex(void *lval, parser_state *p) +{ + p->ylval = lval; + return parser_yylex(p); +} + +static void +parser_init_cxt(parser_state *p, mrbc_context *cxt) +{ + if (!cxt) return; + if (cxt->filename) mrb_parser_set_filename(p, cxt->filename); + if (cxt->lineno) p->lineno = cxt->lineno; + if (cxt->syms) { + int i; + + p->locals = cons(0,0); + for (i=0; i<cxt->slen; i++) { + local_add_f(p, cxt->syms[i]); + } + } + p->capture_errors = cxt->capture_errors; + p->no_optimize = cxt->no_optimize; + if (cxt->partial_hook) { + p->cxt = cxt; + } +} + +static void +parser_update_cxt(parser_state *p, mrbc_context *cxt) +{ + node *n, *n0; + int i = 0; + + if (!cxt) return; + if ((int)(intptr_t)p->tree->car != NODE_SCOPE) return; + n0 = n = p->tree->cdr->car; + while (n) { + i++; + n = n->cdr; + } + cxt->syms = (mrb_sym *)mrb_realloc(p->mrb, cxt->syms, i*sizeof(mrb_sym)); + cxt->slen = i; + for (i=0, n=n0; n; i++,n=n->cdr) { + cxt->syms[i] = sym(n->car); + } +} + +void mrb_codedump_all(mrb_state*, struct RProc*); +void mrb_parser_dump(mrb_state *mrb, node *tree, int offset); + +MRB_API void +mrb_parser_parse(parser_state *p, mrbc_context *c) +{ + struct mrb_jmpbuf buf; + p->jmp = &buf; + + MRB_TRY(p->jmp) { + + p->cmd_start = TRUE; + p->in_def = p->in_single = 0; + p->nerr = p->nwarn = 0; + p->lex_strterm = NULL; + + parser_init_cxt(p, c); + yyparse(p); + if (!p->tree) { + p->tree = new_nil(p); + } + parser_update_cxt(p, c); + if (c && c->dump_result) { + mrb_parser_dump(p->mrb, p->tree, 0); + } + + } + MRB_CATCH(p->jmp) { + yyerror(p, "memory allocation error"); + p->nerr++; + p->tree = 0; + return; + } + MRB_END_EXC(p->jmp); +} + +MRB_API parser_state* +mrb_parser_new(mrb_state *mrb) +{ + mrb_pool *pool; + parser_state *p; + static const parser_state parser_state_zero = { 0 }; + + pool = mrb_pool_open(mrb); + if (!pool) return NULL; + p = (parser_state *)mrb_pool_alloc(pool, sizeof(parser_state)); + if (!p) return NULL; + + *p = parser_state_zero; + p->mrb = mrb; + p->pool = pool; + + p->s = p->send = NULL; +#ifdef ENABLE_STDIO + p->f = NULL; +#endif + + p->cmd_start = TRUE; + p->in_def = p->in_single = 0; + + p->capture_errors = FALSE; + p->lineno = 1; + p->column = 0; +#if defined(PARSER_TEST) || defined(PARSER_DEBUG) + yydebug = 1; +#endif + + p->lex_strterm = NULL; + p->all_heredocs = p->parsing_heredoc = NULL; + p->lex_strterm_before_heredoc = NULL; + + p->current_filename_index = -1; + p->filename_table = NULL; + p->filename_table_length = 0; + + return p; +} + +MRB_API void +mrb_parser_free(parser_state *p) { + mrb_pool_close(p->pool); +} + +MRB_API mrbc_context* +mrbc_context_new(mrb_state *mrb) +{ + return (mrbc_context *)mrb_calloc(mrb, 1, sizeof(mrbc_context)); +} + +MRB_API void +mrbc_context_free(mrb_state *mrb, mrbc_context *cxt) +{ + mrb_free(mrb, cxt->syms); + mrb_free(mrb, cxt); +} + +MRB_API const char* +mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s) +{ + if (s) { + int len = strlen(s); + char *p = (char *)mrb_alloca(mrb, len + 1); + + memcpy(p, s, len + 1); + c->filename = p; + } + return c->filename; +} + +MRB_API void +mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*func)(struct mrb_parser_state*), void *data) +{ + c->partial_hook = func; + c->partial_data = data; +} + +MRB_API void +mrb_parser_set_filename(struct mrb_parser_state *p, const char *f) +{ + mrb_sym sym; + size_t i; + mrb_sym* new_table; + + sym = mrb_intern_cstr(p->mrb, f); + p->filename = mrb_sym2name_len(p->mrb, sym, NULL); + p->lineno = (p->filename_table_length > 0)? 0 : 1; + + for (i = 0; i < p->filename_table_length; ++i) { + if (p->filename_table[i] == sym) { + p->current_filename_index = i; + return; + } + } + + p->current_filename_index = p->filename_table_length++; + + new_table = (mrb_sym*)parser_palloc(p, sizeof(mrb_sym) * p->filename_table_length); + if (p->filename_table) { + memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->filename_table_length); + } + p->filename_table = new_table; + p->filename_table[p->filename_table_length - 1] = sym; +} + +MRB_API char const* +mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) { + if (idx >= p->filename_table_length) { return NULL; } + else { + return mrb_sym2name_len(p->mrb, p->filename_table[idx], NULL); + } +} + +#ifdef ENABLE_STDIO +MRB_API parser_state* +mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c) +{ + parser_state *p; + + p = mrb_parser_new(mrb); + if (!p) return NULL; + p->s = p->send = NULL; + p->f = f; + + mrb_parser_parse(p, c); + return p; +} +#endif + +MRB_API parser_state* +mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c) +{ + parser_state *p; + + p = mrb_parser_new(mrb); + if (!p) return NULL; + p->s = s; + p->send = s + len; + + mrb_parser_parse(p, c); + return p; +} + +MRB_API parser_state* +mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c) +{ + return mrb_parse_nstring(mrb, s, strlen(s), c); +} + +static mrb_value +load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c) +{ + struct RClass *target = mrb->object_class; + struct RProc *proc; + mrb_value v; + unsigned int keep = 0; + + if (!p) { + return mrb_undef_value(); + } + if (!p->tree || p->nerr) { + if (p->capture_errors) { + char buf[256]; + int n; + + n = snprintf(buf, sizeof(buf), "line %d: %s\n", + p->error_buffer[0].lineno, p->error_buffer[0].message); + mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, n)); + mrb_parser_free(p); + return mrb_undef_value(); + } + else { + mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error")); + mrb_parser_free(p); + return mrb_undef_value(); + } + } + proc = mrb_generate_code(mrb, p); + mrb_parser_free(p); + if (proc == NULL) { + mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error")); + return mrb_undef_value(); + } + if (c) { + if (c->dump_result) mrb_codedump_all(mrb, proc); + if (c->no_exec) return mrb_obj_value(proc); + if (c->target_class) { + target = c->target_class; + } + if (c->keep_lv) { + keep = c->slen + 1; + } + else { + c->keep_lv = TRUE; + } + } + proc->target_class = target; + if (mrb->c->ci) { + mrb->c->ci->target_class = target; + } + v = mrb_toplevel_run_keep(mrb, proc, keep); + if (mrb->exc) return mrb_nil_value(); + return v; +} + +#ifdef ENABLE_STDIO +MRB_API mrb_value +mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c) +{ + return load_exec(mrb, mrb_parse_file(mrb, f, c), c); +} + +MRB_API mrb_value +mrb_load_file(mrb_state *mrb, FILE *f) +{ + return mrb_load_file_cxt(mrb, f, NULL); +} +#endif + +MRB_API mrb_value +mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c) +{ + return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c); +} + +MRB_API mrb_value +mrb_load_nstring(mrb_state *mrb, const char *s, int len) +{ + return mrb_load_nstring_cxt(mrb, s, len, NULL); +} + +MRB_API mrb_value +mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c) +{ + return mrb_load_nstring_cxt(mrb, s, strlen(s), c); +} + +MRB_API mrb_value +mrb_load_string(mrb_state *mrb, const char *s) +{ + return mrb_load_string_cxt(mrb, s, NULL); +} + +#ifdef ENABLE_STDIO + +static void +dump_prefix(node *tree, int offset) +{ + printf("%05d ", tree->lineno); + while (offset--) { + putc(' ', stdout); + putc(' ', stdout); + } +} + +static void +dump_recur(mrb_state *mrb, node *tree, int offset) +{ + while (tree) { + mrb_parser_dump(mrb, tree->car, offset); + tree = tree->cdr; + } +} + +#endif + +void +mrb_parser_dump(mrb_state *mrb, node *tree, int offset) +{ +#ifdef ENABLE_STDIO + int nodetype; + + if (!tree) return; + again: + dump_prefix(tree, offset); + nodetype = (int)(intptr_t)tree->car; + tree = tree->cdr; + switch (nodetype) { + case NODE_BEGIN: + printf("NODE_BEGIN:\n"); + dump_recur(mrb, tree, offset+1); + break; + + case NODE_RESCUE: + printf("NODE_RESCUE:\n"); + if (tree->car) { + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + } + tree = tree->cdr; + if (tree->car) { + node *n2 = tree->car; + + dump_prefix(n2, offset+1); + printf("rescue:\n"); + while (n2) { + node *n3 = n2->car; + if (n3->car) { + dump_prefix(n2, offset+2); + printf("handle classes:\n"); + dump_recur(mrb, n3->car, offset+3); + } + if (n3->cdr->car) { + dump_prefix(n3, offset+2); + printf("exc_var:\n"); + mrb_parser_dump(mrb, n3->cdr->car, offset+3); + } + if (n3->cdr->cdr->car) { + dump_prefix(n3, offset+2); + printf("rescue body:\n"); + mrb_parser_dump(mrb, n3->cdr->cdr->car, offset+3); + } + n2 = n2->cdr; + } + } + tree = tree->cdr; + if (tree->car) { + dump_prefix(tree, offset+1); + printf("else:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + } + break; + + case NODE_ENSURE: + printf("NODE_ENSURE:\n"); + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + dump_prefix(tree, offset+1); + printf("ensure:\n"); + mrb_parser_dump(mrb, tree->cdr->cdr, offset+2); + break; + + case NODE_LAMBDA: + printf("NODE_BLOCK:\n"); + goto block; + + case NODE_BLOCK: + block: + printf("NODE_BLOCK:\n"); + tree = tree->cdr; + if (tree->car) { + node *n = tree->car; + + if (n->car) { + dump_prefix(n, offset+1); + printf("mandatory args:\n"); + dump_recur(mrb, n->car, offset+2); + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("optional args:\n"); + { + node *n2 = n->car; + + while (n2) { + dump_prefix(n2, offset+2); + printf("%s=", mrb_sym2name(mrb, sym(n2->car->car))); + mrb_parser_dump(mrb, n2->car->cdr, 0); + n2 = n2->cdr; + } + } + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car))); + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("post mandatory args:\n"); + dump_recur(mrb, n->car, offset+2); + } + n = n->cdr; + if (n) { + dump_prefix(n, offset+1); + printf("blk=&%s\n", mrb_sym2name(mrb, sym(n))); + } + } + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->cdr->car, offset+2); + break; + + case NODE_IF: + printf("NODE_IF:\n"); + dump_prefix(tree, offset+1); + printf("cond:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + dump_prefix(tree, offset+1); + printf("then:\n"); + mrb_parser_dump(mrb, tree->cdr->car, offset+2); + if (tree->cdr->cdr->car) { + dump_prefix(tree, offset+1); + printf("else:\n"); + mrb_parser_dump(mrb, tree->cdr->cdr->car, offset+2); + } + break; + + case NODE_AND: + printf("NODE_AND:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + mrb_parser_dump(mrb, tree->cdr, offset+1); + break; + + case NODE_OR: + printf("NODE_OR:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + mrb_parser_dump(mrb, tree->cdr, offset+1); + break; + + case NODE_CASE: + printf("NODE_CASE:\n"); + if (tree->car) { + mrb_parser_dump(mrb, tree->car, offset+1); + } + tree = tree->cdr; + while (tree) { + dump_prefix(tree, offset+1); + printf("case:\n"); + dump_recur(mrb, tree->car->car, offset+2); + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->car->cdr, offset+2); + tree = tree->cdr; + } + break; + + case NODE_WHILE: + printf("NODE_WHILE:\n"); + dump_prefix(tree, offset+1); + printf("cond:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->cdr, offset+2); + break; + + case NODE_UNTIL: + printf("NODE_UNTIL:\n"); + dump_prefix(tree, offset+1); + printf("cond:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->cdr, offset+2); + break; + + case NODE_FOR: + printf("NODE_FOR:\n"); + dump_prefix(tree, offset+1); + printf("var:\n"); + { + node *n2 = tree->car; + + if (n2->car) { + dump_prefix(n2, offset+2); + printf("pre:\n"); + dump_recur(mrb, n2->car, offset+3); + } + n2 = n2->cdr; + if (n2) { + if (n2->car) { + dump_prefix(n2, offset+2); + printf("rest:\n"); + mrb_parser_dump(mrb, n2->car, offset+3); + } + n2 = n2->cdr; + if (n2) { + if (n2->car) { + dump_prefix(n2, offset+2); + printf("post:\n"); + dump_recur(mrb, n2->car, offset+3); + } + } + } + } + tree = tree->cdr; + dump_prefix(tree, offset+1); + printf("in:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + tree = tree->cdr; + dump_prefix(tree, offset+1); + printf("do:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + break; + + case NODE_SCOPE: + printf("NODE_SCOPE:\n"); + { + node *n2 = tree->car; + mrb_bool first_lval = TRUE; + + if (n2 && (n2->car || n2->cdr)) { + dump_prefix(n2, offset+1); + printf("local variables:\n"); + dump_prefix(n2, offset+2); + while (n2) { + if (n2->car) { + if (!first_lval) printf(", "); + printf("%s", mrb_sym2name(mrb, sym(n2->car))); + first_lval = FALSE; + } + n2 = n2->cdr; + } + printf("\n"); + } + } + tree = tree->cdr; + offset++; + goto again; + + case NODE_FCALL: + case NODE_CALL: + printf("NODE_CALL:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + dump_prefix(tree, offset+1); + printf("method='%s' (%d)\n", + mrb_sym2name(mrb, sym(tree->cdr->car)), + (int)(intptr_t)tree->cdr->car); + tree = tree->cdr->cdr->car; + if (tree) { + dump_prefix(tree, offset+1); + printf("args:\n"); + dump_recur(mrb, tree->car, offset+2); + if (tree->cdr) { + dump_prefix(tree, offset+1); + printf("block:\n"); + mrb_parser_dump(mrb, tree->cdr, offset+2); + } + } + break; + + case NODE_DOT2: + printf("NODE_DOT2:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + mrb_parser_dump(mrb, tree->cdr, offset+1); + break; + + case NODE_DOT3: + printf("NODE_DOT3:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + mrb_parser_dump(mrb, tree->cdr, offset+1); + break; + + case NODE_COLON2: + printf("NODE_COLON2:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + dump_prefix(tree, offset+1); + printf("::%s\n", mrb_sym2name(mrb, sym(tree->cdr))); + break; + + case NODE_COLON3: + printf("NODE_COLON3:\n"); + dump_prefix(tree, offset+1); + printf("::%s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_ARRAY: + printf("NODE_ARRAY:\n"); + dump_recur(mrb, tree, offset+1); + break; + + case NODE_HASH: + printf("NODE_HASH:\n"); + while (tree) { + dump_prefix(tree, offset+1); + printf("key:\n"); + mrb_parser_dump(mrb, tree->car->car, offset+2); + dump_prefix(tree, offset+1); + printf("value:\n"); + mrb_parser_dump(mrb, tree->car->cdr, offset+2); + tree = tree->cdr; + } + break; + + case NODE_SPLAT: + printf("NODE_SPLAT:\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_ASGN: + printf("NODE_ASGN:\n"); + dump_prefix(tree, offset+1); + printf("lhs:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + dump_prefix(tree, offset+1); + printf("rhs:\n"); + mrb_parser_dump(mrb, tree->cdr, offset+2); + break; + + case NODE_MASGN: + printf("NODE_MASGN:\n"); + dump_prefix(tree, offset+1); + printf("mlhs:\n"); + { + node *n2 = tree->car; + + if (n2->car) { + dump_prefix(tree, offset+2); + printf("pre:\n"); + dump_recur(mrb, n2->car, offset+3); + } + n2 = n2->cdr; + if (n2) { + if (n2->car) { + dump_prefix(n2, offset+2); + printf("rest:\n"); + if (n2->car == (node*)-1) { + dump_prefix(n2, offset+2); + printf("(empty)\n"); + } + else { + mrb_parser_dump(mrb, n2->car, offset+3); + } + } + n2 = n2->cdr; + if (n2) { + if (n2->car) { + dump_prefix(n2, offset+2); + printf("post:\n"); + dump_recur(mrb, n2->car, offset+3); + } + } + } + } + dump_prefix(tree, offset+1); + printf("rhs:\n"); + mrb_parser_dump(mrb, tree->cdr, offset+2); + break; + + case NODE_OP_ASGN: + printf("NODE_OP_ASGN:\n"); + dump_prefix(tree, offset+1); + printf("lhs:\n"); + mrb_parser_dump(mrb, tree->car, offset+2); + tree = tree->cdr; + dump_prefix(tree, offset+1); + printf("op='%s' (%d)\n", mrb_sym2name(mrb, sym(tree->car)), (int)(intptr_t)tree->car); + tree = tree->cdr; + mrb_parser_dump(mrb, tree->car, offset+1); + break; + + case NODE_SUPER: + printf("NODE_SUPER:\n"); + if (tree) { + dump_prefix(tree, offset+1); + printf("args:\n"); + dump_recur(mrb, tree->car, offset+2); + if (tree->cdr) { + dump_prefix(tree, offset+1); + printf("block:\n"); + mrb_parser_dump(mrb, tree->cdr, offset+2); + } + } + break; + + case NODE_ZSUPER: + printf("NODE_ZSUPER\n"); + break; + + case NODE_RETURN: + printf("NODE_RETURN:\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_YIELD: + printf("NODE_YIELD:\n"); + dump_recur(mrb, tree, offset+1); + break; + + case NODE_BREAK: + printf("NODE_BREAK:\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_NEXT: + printf("NODE_NEXT:\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_REDO: + printf("NODE_REDO\n"); + break; + + case NODE_RETRY: + printf("NODE_RETRY\n"); + break; + + case NODE_LVAR: + printf("NODE_LVAR %s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_GVAR: + printf("NODE_GVAR %s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_IVAR: + printf("NODE_IVAR %s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_CVAR: + printf("NODE_CVAR %s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_CONST: + printf("NODE_CONST %s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_MATCH: + printf("NODE_MATCH:\n"); + dump_prefix(tree, offset + 1); + printf("lhs:\n"); + mrb_parser_dump(mrb, tree->car, offset + 2); + dump_prefix(tree, offset + 1); + printf("rhs:\n"); + mrb_parser_dump(mrb, tree->cdr, offset + 2); + break; + + case NODE_BACK_REF: + printf("NODE_BACK_REF: $%c\n", (int)(intptr_t)tree); + break; + + case NODE_NTH_REF: + printf("NODE_NTH_REF: $%d\n", (int)(intptr_t)tree); + break; + + case NODE_ARG: + printf("NODE_ARG %s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_BLOCK_ARG: + printf("NODE_BLOCK_ARG:\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_INT: + printf("NODE_INT %s base %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr->car); + break; + + case NODE_FLOAT: + printf("NODE_FLOAT %s\n", (char*)tree); + break; + + case NODE_NEGATE: + printf("NODE_NEGATE\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_STR: + printf("NODE_STR \"%s\" len %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr); + break; + + case NODE_DSTR: + printf("NODE_DSTR\n"); + dump_recur(mrb, tree, offset+1); + break; + + case NODE_XSTR: + printf("NODE_XSTR \"%s\" len %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr); + break; + + case NODE_DXSTR: + printf("NODE_DXSTR\n"); + dump_recur(mrb, tree, offset+1); + break; + + case NODE_REGX: + printf("NODE_REGX /%s/%s\n", (char*)tree->car, (char*)tree->cdr); + break; + + case NODE_DREGX: + printf("NODE_DREGX\n"); + dump_recur(mrb, tree->car, offset+1); + dump_prefix(tree, offset); + printf("tail: %s\n", (char*)tree->cdr->cdr->car); + dump_prefix(tree, offset); + printf("opt: %s\n", (char*)tree->cdr->cdr->cdr); + break; + + case NODE_SYM: + printf("NODE_SYM :%s\n", mrb_sym2name(mrb, sym(tree))); + break; + + case NODE_SELF: + printf("NODE_SELF\n"); + break; + + case NODE_NIL: + printf("NODE_NIL\n"); + break; + + case NODE_TRUE: + printf("NODE_TRUE\n"); + break; + + case NODE_FALSE: + printf("NODE_FALSE\n"); + break; + + case NODE_ALIAS: + printf("NODE_ALIAS %s %s:\n", + mrb_sym2name(mrb, sym(tree->car)), + mrb_sym2name(mrb, sym(tree->cdr))); + break; + + case NODE_UNDEF: + printf("NODE_UNDEF"); + { + node *t = tree; + while (t) { + printf(" %s", mrb_sym2name(mrb, sym(t->car))); + t = t->cdr; + } + } + printf(":\n"); + break; + + case NODE_CLASS: + printf("NODE_CLASS:\n"); + if (tree->car->car == (node*)0) { + dump_prefix(tree, offset+1); + printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + } + else if (tree->car->car == (node*)1) { + dump_prefix(tree, offset+1); + printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + } + else { + mrb_parser_dump(mrb, tree->car->car, offset+1); + dump_prefix(tree, offset+1); + printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + } + if (tree->cdr->car) { + dump_prefix(tree, offset+1); + printf("super:\n"); + mrb_parser_dump(mrb, tree->cdr->car, offset+2); + } + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->cdr->cdr->car->cdr, offset+2); + break; + + case NODE_MODULE: + printf("NODE_MODULE:\n"); + if (tree->car->car == (node*)0) { + dump_prefix(tree, offset+1); + printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + } + else if (tree->car->car == (node*)1) { + dump_prefix(tree, offset+1); + printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + } + else { + mrb_parser_dump(mrb, tree->car->car, offset+1); + dump_prefix(tree, offset+1); + printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + } + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2); + break; + + case NODE_SCLASS: + printf("NODE_SCLASS:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + dump_prefix(tree, offset+1); + printf("body:\n"); + mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2); + break; + + case NODE_DEF: + printf("NODE_DEF:\n"); + dump_prefix(tree, offset+1); + printf("%s\n", mrb_sym2name(mrb, sym(tree->car))); + tree = tree->cdr; + { + node *n2 = tree->car; + mrb_bool first_lval = TRUE; + + if (n2 && (n2->car || n2->cdr)) { + dump_prefix(n2, offset+1); + printf("local variables:\n"); + dump_prefix(n2, offset+2); + while (n2) { + if (n2->car) { + if (!first_lval) printf(", "); + printf("%s", mrb_sym2name(mrb, sym(n2->car))); + first_lval = FALSE; + } + n2 = n2->cdr; + } + printf("\n"); + } + } + tree = tree->cdr; + if (tree->car) { + node *n = tree->car; + + if (n->car) { + dump_prefix(n, offset+1); + printf("mandatory args:\n"); + dump_recur(mrb, n->car, offset+2); + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("optional args:\n"); + { + node *n2 = n->car; + + while (n2) { + dump_prefix(n2, offset+2); + printf("%s=", mrb_sym2name(mrb, sym(n2->car->car))); + mrb_parser_dump(mrb, n2->car->cdr, 0); + n2 = n2->cdr; + } + } + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car))); + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("post mandatory args:\n"); + dump_recur(mrb, n->car, offset+2); + } + n = n->cdr; + if (n) { + dump_prefix(n, offset+1); + printf("blk=&%s\n", mrb_sym2name(mrb, sym(n))); + } + } + mrb_parser_dump(mrb, tree->cdr->car, offset+1); + break; + + case NODE_SDEF: + printf("NODE_SDEF:\n"); + mrb_parser_dump(mrb, tree->car, offset+1); + tree = tree->cdr; + dump_prefix(tree, offset+1); + printf(":%s\n", mrb_sym2name(mrb, sym(tree->car))); + tree = tree->cdr->cdr; + if (tree->car) { + node *n = tree->car; + + if (n->car) { + dump_prefix(n, offset+1); + printf("mandatory args:\n"); + dump_recur(mrb, n->car, offset+2); + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("optional args:\n"); + { + node *n2 = n->car; + + while (n2) { + dump_prefix(n2, offset+2); + printf("%s=", mrb_sym2name(mrb, sym(n2->car->car))); + mrb_parser_dump(mrb, n2->car->cdr, 0); + n2 = n2->cdr; + } + } + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car))); + } + n = n->cdr; + if (n->car) { + dump_prefix(n, offset+1); + printf("post mandatory args:\n"); + dump_recur(mrb, n->car, offset+2); + } + n = n->cdr; + if (n) { + dump_prefix(n, offset+1); + printf("blk=&%s\n", mrb_sym2name(mrb, sym(n))); + } + } + tree = tree->cdr; + mrb_parser_dump(mrb, tree->car, offset+1); + break; + + case NODE_POSTEXE: + printf("NODE_POSTEXE:\n"); + mrb_parser_dump(mrb, tree, offset+1); + break; + + case NODE_HEREDOC: + printf("NODE_HEREDOC:\n"); + mrb_parser_dump(mrb, ((parser_heredoc_info*)tree)->doc, offset+1); + break; + + default: + printf("node type: %d (0x%x)\n", nodetype, (unsigned)nodetype); + break; + } +#endif +} + +