Ruby: parse.c Source File

00001 /* A Bison parser, made by GNU Bison 2.5.  */
00002 
00003 /* Bison implementation for Yacc-like parsers in C
00004    
00005       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
00006    
00007    This program is free software: you can redistribute it and/or modify
00008    it under the terms of the GNU General Public License as published by
00009    the Free Software Foundation, either version 3 of the License, or
00010    (at your option) any later version.
00011    
00012    This program is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015    GNU General Public License for more details.
00016    
00017    You should have received a copy of the GNU General Public License
00018    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00019 
00020 /* As a special exception, you may create a larger work that contains
00021    part or all of the Bison parser skeleton and distribute that work
00022    under terms of your choice, so long as that work isn't itself a
00023    parser generator using the skeleton or a modified version thereof
00024    as a parser skeleton.  Alternatively, if you modify or redistribute
00025    the parser skeleton itself, you may (at your option) remove this
00026    special exception, which will cause the skeleton and the resulting
00027    Bison output files to be licensed under the GNU General Public
00028    License without this special exception.
00029    
00030    This special exception was added by the Free Software Foundation in
00031    version 2.2 of Bison.  */
00032 
00033 /* C LALR(1) parser skeleton written by Richard Stallman, by
00034    simplifying the original so-called "semantic" parser.  */
00035 
00036 /* All symbols defined below should begin with yy or YY, to avoid
00037    infringing on user name space.  This should be done even for local
00038    variables, as they might otherwise be expanded by user macros.
00039    There are some unavoidable exceptions within include files to
00040    define necessary library symbols; they are noted "INFRINGES ON
00041    USER NAME SPACE" below.  */
00042 
00043 /* Identify Bison output.  */
00044 #define YYBISON 1
00045 
00046 /* Bison version.  */
00047 #define YYBISON_VERSION "2.5"
00048 
00049 /* Skeleton name.  */
00050 #define YYSKELETON_NAME "yacc.c"
00051 
00052 /* Pure parsers.  */
00053 #define YYPURE 1
00054 
00055 /* Push parsers.  */
00056 #define YYPUSH 0
00057 
00058 /* Pull parsers.  */
00059 #define YYPULL 1
00060 
00061 /* Using locations.  */
00062 #define YYLSP_NEEDED 0
00063 
00064 
00065 
00066 /* Copy the first part of user declarations.  */
00067 
00068 /* Line 268 of yacc.c  */
00069 #line 12 "parse.y"
00070 
00071 
00072 #ifndef PARSER_DEBUG
00073 #define PARSER_DEBUG 0
00074 #endif
00075 #define YYDEBUG 1
00076 #define YYERROR_VERBOSE 1
00077 #define YYSTACK_USE_ALLOCA 0
00078 
00079 #include "ruby/ruby.h"
00080 #include "ruby/st.h"
00081 #include "ruby/encoding.h"
00082 #include "internal.h"
00083 #include "node.h"
00084 #include "parse.h"
00085 #include "id.h"
00086 #include "regenc.h"
00087 #include <stdio.h>
00088 #include <errno.h>
00089 #include <ctype.h>
00090 #include "probes.h"
00091 
00092 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
00093 
00094 #define YYMALLOC(size)          rb_parser_malloc(parser, (size))
00095 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, (ptr), (size))
00096 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, (nelem), (size))
00097 #define YYFREE(ptr)             rb_parser_free(parser, (ptr))
00098 #define malloc  YYMALLOC
00099 #define realloc YYREALLOC
00100 #define calloc  YYCALLOC
00101 #define free    YYFREE
00102 
00103 #ifndef RIPPER
00104 static ID register_symid(ID, const char *, long, rb_encoding *);
00105 static ID register_symid_str(ID, VALUE);
00106 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
00107 #include "id.c"
00108 #endif
00109 
00110 #define is_notop_id(id) ((id)>tLAST_OP_ID)
00111 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00112 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00113 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00114 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00115 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00116 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00117 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00118 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
00119 
00120 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00121         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00122          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00123          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00124 
00125 enum lex_state_bits {
00126     EXPR_BEG_bit,               /* ignore newline, +/- is a sign. */
00127     EXPR_END_bit,               /* newline significant, +/- is an operator. */
00128     EXPR_ENDARG_bit,            /* ditto, and unbound braces. */
00129     EXPR_ENDFN_bit,             /* ditto, and unbound braces. */
00130     EXPR_ARG_bit,               /* newline significant, +/- is an operator. */
00131     EXPR_CMDARG_bit,            /* newline significant, +/- is an operator. */
00132     EXPR_MID_bit,               /* newline significant, +/- is an operator. */
00133     EXPR_FNAME_bit,             /* ignore newline, no reserved words. */
00134     EXPR_DOT_bit,               /* right after `.' or `::', no reserved words. */
00135     EXPR_CLASS_bit,             /* immediate after `class', no here document. */
00136     EXPR_VALUE_bit,             /* alike EXPR_BEG but label is disallowed. */
00137     EXPR_MAX_STATE
00138 };
00139 /* examine combinations */
00140 enum lex_state_e {
00141 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
00142     DEF_EXPR(BEG),
00143     DEF_EXPR(END),
00144     DEF_EXPR(ENDARG),
00145     DEF_EXPR(ENDFN),
00146     DEF_EXPR(ARG),
00147     DEF_EXPR(CMDARG),
00148     DEF_EXPR(MID),
00149     DEF_EXPR(FNAME),
00150     DEF_EXPR(DOT),
00151     DEF_EXPR(CLASS),
00152     DEF_EXPR(VALUE),
00153     EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS),
00154     EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG),
00155     EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
00156 };
00157 #define IS_lex_state_for(x, ls) ((x) & (ls))
00158 #define IS_lex_state(ls)        IS_lex_state_for(lex_state, (ls))
00159 
00160 #if PARSER_DEBUG
00161 static const char *lex_state_name(enum lex_state_e state);
00162 #endif
00163 
00164 typedef VALUE stack_type;
00165 
00166 # define BITSTACK_PUSH(stack, n)        ((stack) = ((stack)<<1)|((n)&1))
00167 # define BITSTACK_POP(stack)    ((stack) = (stack) >> 1)
00168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
00169 # define BITSTACK_SET_P(stack)  ((stack)&1)
00170 
00171 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, (n))
00172 #define COND_POP()      BITSTACK_POP(cond_stack)
00173 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00174 #define COND_P()        BITSTACK_SET_P(cond_stack)
00175 
00176 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, (n))
00177 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00179 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00180 
00181 struct vtable {
00182     ID *tbl;
00183     int pos;
00184     int capa;
00185     struct vtable *prev;
00186 };
00187 
00188 struct local_vars {
00189     struct vtable *args;
00190     struct vtable *vars;
00191     struct vtable *used;
00192     struct local_vars *prev;
00193     stack_type cmdargs;
00194 };
00195 
00196 #define DVARS_INHERIT ((void*)1)
00197 #define DVARS_TOPSCOPE NULL
00198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00200 
00201 static int
00202 vtable_size(const struct vtable *tbl)
00203 {
00204     if (POINTER_P(tbl)) {
00205         return tbl->pos;
00206     }
00207     else {
00208         return 0;
00209     }
00210 }
00211 
00212 #define VTBL_DEBUG 0
00213 
00214 static struct vtable *
00215 vtable_alloc(struct vtable *prev)
00216 {
00217     struct vtable *tbl = ALLOC(struct vtable);
00218     tbl->pos = 0;
00219     tbl->capa = 8;
00220     tbl->tbl = ALLOC_N(ID, tbl->capa);
00221     tbl->prev = prev;
00222     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00223     return tbl;
00224 }
00225 
00226 static void
00227 vtable_free(struct vtable *tbl)
00228 {
00229     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00230     if (POINTER_P(tbl)) {
00231         if (tbl->tbl) {
00232             xfree(tbl->tbl);
00233         }
00234         xfree(tbl);
00235     }
00236 }
00237 
00238 static void
00239 vtable_add(struct vtable *tbl, ID id)
00240 {
00241     if (!POINTER_P(tbl)) {
00242         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00243     }
00244     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00245 
00246     if (tbl->pos == tbl->capa) {
00247         tbl->capa = tbl->capa * 2;
00248         REALLOC_N(tbl->tbl, ID, tbl->capa);
00249     }
00250     tbl->tbl[tbl->pos++] = id;
00251 }
00252 
00253 static int
00254 vtable_included(const struct vtable * tbl, ID id)
00255 {
00256     int i;
00257 
00258     if (POINTER_P(tbl)) {
00259         for (i = 0; i < tbl->pos; i++) {
00260             if (tbl->tbl[i] == id) {
00261                 return i+1;
00262             }
00263         }
00264     }
00265     return 0;
00266 }
00267 
00268 
00269 #ifndef RIPPER
00270 typedef struct token_info {
00271     const char *token;
00272     int linenum;
00273     int column;
00274     int nonspc;
00275     struct token_info *next;
00276 } token_info;
00277 #endif
00278 
00279 /*
00280     Structure of Lexer Buffer:
00281 
00282  lex_pbeg      tokp         lex_p        lex_pend
00283     |           |              |            |
00284     |-----------+--------------+------------|
00285                 |<------------>|
00286                      token
00287 */
00288 struct parser_params {
00289     int is_ripper;
00290     NODE *heap;
00291 
00292     YYSTYPE *parser_yylval;
00293     VALUE eofp;
00294 
00295     NODE *parser_lex_strterm;
00296     enum lex_state_e parser_lex_state;
00297     stack_type parser_cond_stack;
00298     stack_type parser_cmdarg_stack;
00299     int parser_class_nest;
00300     int parser_paren_nest;
00301     int parser_lpar_beg;
00302     int parser_in_single;
00303     int parser_in_def;
00304     int parser_brace_nest;
00305     int parser_compile_for_eval;
00306     VALUE parser_cur_mid;
00307     int parser_in_defined;
00308     char *parser_tokenbuf;
00309     int parser_tokidx;
00310     int parser_toksiz;
00311     int parser_tokline;
00312     VALUE parser_lex_input;
00313     VALUE parser_lex_lastline;
00314     VALUE parser_lex_nextline;
00315     const char *parser_lex_pbeg;
00316     const char *parser_lex_p;
00317     const char *parser_lex_pend;
00318     int parser_heredoc_end;
00319     int parser_command_start;
00320     NODE *parser_deferred_nodes;
00321     long parser_lex_gets_ptr;
00322     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00323     struct local_vars *parser_lvtbl;
00324     int parser_ruby__end__seen;
00325     int line_count;
00326     int has_shebang;
00327     char *parser_ruby_sourcefile; /* current source file */
00328     int parser_ruby_sourceline; /* current line no. */
00329     VALUE parser_ruby_sourcefile_string;
00330     rb_encoding *enc;
00331 
00332     int parser_yydebug;
00333 
00334 #ifndef RIPPER
00335     /* Ruby core only */
00336     NODE *parser_eval_tree_begin;
00337     NODE *parser_eval_tree;
00338     VALUE debug_lines;
00339     VALUE coverage;
00340     int nerr;
00341 
00342     int parser_token_info_enabled;
00343     token_info *parser_token_info;
00344 #else
00345     /* Ripper only */
00346     const char *tokp;
00347     VALUE delayed;
00348     int delayed_line;
00349     int delayed_col;
00350 
00351     VALUE value;
00352     VALUE result;
00353     VALUE parsing_thread;
00354     int toplevel_p;
00355 #endif
00356 };
00357 
00358 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
00359 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
00360 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
00361 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
00362 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00363 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
00364 
00365 static int parser_yyerror(struct parser_params*, const char*);
00366 #define yyerror(msg) parser_yyerror(parser, (msg))
00367 
00368 #define lex_strterm             (parser->parser_lex_strterm)
00369 #define lex_state               (parser->parser_lex_state)
00370 #define cond_stack              (parser->parser_cond_stack)
00371 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00372 #define class_nest              (parser->parser_class_nest)
00373 #define paren_nest              (parser->parser_paren_nest)
00374 #define lpar_beg                (parser->parser_lpar_beg)
00375 #define brace_nest              (parser->parser_brace_nest)
00376 #define in_single               (parser->parser_in_single)
00377 #define in_def                  (parser->parser_in_def)
00378 #define compile_for_eval        (parser->parser_compile_for_eval)
00379 #define cur_mid                 (parser->parser_cur_mid)
00380 #define in_defined              (parser->parser_in_defined)
00381 #define tokenbuf                (parser->parser_tokenbuf)
00382 #define tokidx                  (parser->parser_tokidx)
00383 #define toksiz                  (parser->parser_toksiz)
00384 #define tokline                 (parser->parser_tokline)
00385 #define lex_input               (parser->parser_lex_input)
00386 #define lex_lastline            (parser->parser_lex_lastline)
00387 #define lex_nextline            (parser->parser_lex_nextline)
00388 #define lex_pbeg                (parser->parser_lex_pbeg)
00389 #define lex_p                   (parser->parser_lex_p)
00390 #define lex_pend                (parser->parser_lex_pend)
00391 #define heredoc_end             (parser->parser_heredoc_end)
00392 #define command_start           (parser->parser_command_start)
00393 #define deferred_nodes          (parser->parser_deferred_nodes)
00394 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00395 #define lex_gets                (parser->parser_lex_gets)
00396 #define lvtbl                   (parser->parser_lvtbl)
00397 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00398 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00399 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00400 #define ruby_sourcefile_string  (parser->parser_ruby_sourcefile_string)
00401 #define current_enc             (parser->enc)
00402 #define yydebug                 (parser->parser_yydebug)
00403 #ifdef RIPPER
00404 #else
00405 #define ruby_eval_tree          (parser->parser_eval_tree)
00406 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00407 #define ruby_debug_lines        (parser->debug_lines)
00408 #define ruby_coverage           (parser->coverage)
00409 #endif
00410 
00411 #if YYPURE
00412 static int yylex(void*, void*);
00413 #else
00414 static int yylex(void*);
00415 #endif
00416 
00417 #ifndef RIPPER
00418 #define yyparse ruby_yyparse
00419 
00420 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00421 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
00422 
00423 static NODE *cond_gen(struct parser_params*,NODE*);
00424 #define cond(node) cond_gen(parser, (node))
00425 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00426 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
00427 
00428 static NODE *newline_node(NODE*);
00429 static void fixpos(NODE*,NODE*);
00430 
00431 static int value_expr_gen(struct parser_params*,NODE*);
00432 static void void_expr_gen(struct parser_params*,NODE*);
00433 static NODE *remove_begin(NODE*);
00434 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00435 #define void_expr0(node) void_expr_gen(parser, (node))
00436 #define void_expr(node) void_expr0((node) = remove_begin(node))
00437 static void void_stmts_gen(struct parser_params*,NODE*);
00438 #define void_stmts(node) void_stmts_gen(parser, (node))
00439 static void reduce_nodes_gen(struct parser_params*,NODE**);
00440 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
00441 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00442 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
00443 
00444 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00445 #define block_append(h,t) block_append_gen(parser,(h),(t))
00446 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00447 #define list_append(l,i) list_append_gen(parser,(l),(i))
00448 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00449 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
00450 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00451 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
00452 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00453 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
00454 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00455 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
00456 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00457 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00458 #define new_evstr(n) new_evstr_gen(parser,(n))
00459 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00460 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
00461 static NODE *splat_array(NODE*);
00462 
00463 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00464 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
00465 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00466 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
00467 
00468 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
00469 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00470 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
00471 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00472 
00473 static NODE *negate_lit(NODE*);
00474 static NODE *ret_args_gen(struct parser_params*,NODE*);
00475 #define ret_args(node) ret_args_gen(parser, (node))
00476 static NODE *arg_blk_pass(NODE*,NODE*);
00477 static NODE *new_yield_gen(struct parser_params*,NODE*);
00478 #define new_yield(node) new_yield_gen(parser, (node))
00479 static NODE *dsym_node_gen(struct parser_params*,NODE*);
00480 #define dsym_node(node) dsym_node_gen(parser, (node))
00481 
00482 static NODE *gettable_gen(struct parser_params*,ID);
00483 #define gettable(id) gettable_gen(parser,(id))
00484 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00485 #define assignable(id,node) assignable_gen(parser, (id), (node))
00486 
00487 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00488 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
00489 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00490 #define attrset(node,id) attrset_gen(parser, (node), (id))
00491 
00492 static void rb_backref_error_gen(struct parser_params*,NODE*);
00493 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
00494 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00495 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
00496 
00497 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00498 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
00499 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
00500 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00501 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
00502 
00503 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00504 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
00505 
00506 static ID  *local_tbl_gen(struct parser_params*);
00507 #define local_tbl() local_tbl_gen(parser)
00508 
00509 static void fixup_nodes(NODE **);
00510 
00511 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00512 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
00513 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00514 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
00515 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00516 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
00517 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00518 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
00519 
00520 #define get_id(id) (id)
00521 #define get_value(val) (val)
00522 #else
00523 #define value_expr(node) ((void)(node))
00524 #define remove_begin(node) (node)
00525 #define rb_dvar_defined(id) 0
00526 #define rb_local_defined(id) 0
00527 static ID ripper_get_id(VALUE);
00528 #define get_id(id) ripper_get_id(id)
00529 static VALUE ripper_get_value(VALUE);
00530 #define get_value(val) ripper_get_value(val)
00531 static VALUE assignable_gen(struct parser_params*,VALUE);
00532 #define assignable(lhs,node) assignable_gen(parser, (lhs))
00533 static int id_is_var_gen(struct parser_params *parser, ID id);
00534 #define id_is_var(id) id_is_var_gen(parser, (id))
00535 
00536 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
00537 
00538 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
00539 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
00540 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
00541 
00542 #endif /* !RIPPER */
00543 
00544 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
00545 
00546 static ID formal_argument_gen(struct parser_params*, ID);
00547 #define formal_argument(id) formal_argument_gen(parser, (id))
00548 static ID shadowing_lvar_gen(struct parser_params*,ID);
00549 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
00550 static void new_bv_gen(struct parser_params*,ID);
00551 #define new_bv(id) new_bv_gen(parser, (id))
00552 
00553 static void local_push_gen(struct parser_params*,int);
00554 #define local_push(top) local_push_gen(parser,(top))
00555 static void local_pop_gen(struct parser_params*);
00556 #define local_pop() local_pop_gen(parser)
00557 static int local_var_gen(struct parser_params*, ID);
00558 #define local_var(id) local_var_gen(parser, (id))
00559 static int arg_var_gen(struct parser_params*, ID);
00560 #define arg_var(id) arg_var_gen(parser, (id))
00561 static int  local_id_gen(struct parser_params*, ID);
00562 #define local_id(id) local_id_gen(parser, (id))
00563 static ID   internal_id_gen(struct parser_params*);
00564 #define internal_id() internal_id_gen(parser)
00565 
00566 static const struct vtable *dyna_push_gen(struct parser_params *);
00567 #define dyna_push() dyna_push_gen(parser)
00568 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00569 #define dyna_pop(node) dyna_pop_gen(parser, (node))
00570 static int dyna_in_block_gen(struct parser_params*);
00571 #define dyna_in_block() dyna_in_block_gen(parser)
00572 #define dyna_var(id) local_var(id)
00573 static int dvar_defined_gen(struct parser_params*,ID,int);
00574 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
00575 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
00576 static int dvar_curr_gen(struct parser_params*,ID);
00577 #define dvar_curr(id) dvar_curr_gen(parser, (id))
00578 
00579 static int lvar_defined_gen(struct parser_params*, ID);
00580 #define lvar_defined(id) lvar_defined_gen(parser, (id))
00581 
00582 #define RE_OPTION_ONCE (1<<16)
00583 #define RE_OPTION_ENCODING_SHIFT 8
00584 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00585 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00586 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00587 #define RE_OPTION_MASK  0xff
00588 #define RE_OPTION_ARG_ENCODING_NONE 32
00589 
00590 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00591 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00592 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00593 #define nd_func u1.id
00594 #if SIZEOF_SHORT == 2
00595 #define nd_term(node) ((signed short)(node)->u2.id)
00596 #else
00597 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00598 #endif
00599 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00600 #define nd_nest u3.cnt
00601 
00602 /****** Ripper *******/
00603 
00604 #ifdef RIPPER
00605 #define RIPPER_VERSION "0.1.0"
00606 
00607 #include "eventids1.c"
00608 #include "eventids2.c"
00609 
00610 static VALUE ripper_dispatch0(struct parser_params*,ID);
00611 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00612 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00613 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00614 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00615 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00616 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
00617 
00618 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00619 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
00620 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
00621 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
00622 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
00623 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
00624 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
00625 
00626 #define yyparse ripper_yyparse
00627 
00628 #define ripper_intern(s) ID2SYM(rb_intern(s))
00629 static VALUE ripper_id2sym(ID);
00630 #ifdef __GNUC__
00631 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00632                            ID2SYM(id) : ripper_id2sym(id))
00633 #endif
00634 
00635 #define arg_new() dispatch0(args_new)
00636 #define arg_add(l,a) dispatch2(args_add, (l), (a))
00637 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
00638 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
00639 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
00640 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
00641 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
00642 
00643 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
00644 #define mrhs_new() dispatch0(mrhs_new)
00645 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
00646 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
00647 
00648 #define mlhs_new() dispatch0(mlhs_new)
00649 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
00650 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
00651 
00652 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
00653         dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
00654 
00655 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
00656 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
00657 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
00658 
00659 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
00660 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
00661 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
00662 
00663 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00664 
00665 static inline VALUE
00666 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
00667 {
00668     NODE *t = (NODE *)tail;
00669     VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
00670     return params_new(f, o, r, p, k, kr, escape_Qundef(b));
00671 }
00672 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00673 
00674 static inline VALUE
00675 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
00676 {
00677     return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
00678 }
00679 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00680 
00681 #define FIXME 0
00682 
00683 #endif /* RIPPER */
00684 
00685 #ifndef RIPPER
00686 # define Qnone 0
00687 # define ifndef_ripper(x) (x)
00688 #else
00689 # define Qnone Qnil
00690 # define ifndef_ripper(x)
00691 #endif
00692 
00693 #ifndef RIPPER
00694 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
00695 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00696 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00697 # define rb_warn4S(file,line,fmt,a)  rb_compile_warn((file), (line), (fmt), (a))
00698 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
00699 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00700 #else
00701 # define rb_warn0(fmt)    ripper_warn0(parser, (fmt))
00702 # define rb_warnI(fmt,a)  ripper_warnI(parser, (fmt), (a))
00703 # define rb_warnS(fmt,a)  ripper_warnS(parser, (fmt), (a))
00704 # define rb_warn4S(file,line,fmt,a)  ripper_warnS(parser, (fmt), (a))
00705 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
00706 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
00707 static void ripper_warn0(struct parser_params*, const char*);
00708 static void ripper_warnI(struct parser_params*, const char*, int);
00709 static void ripper_warnS(struct parser_params*, const char*, const char*);
00710 static void ripper_warning0(struct parser_params*, const char*);
00711 static void ripper_warningS(struct parser_params*, const char*, const char*);
00712 #endif
00713 
00714 #ifdef RIPPER
00715 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00716 # define rb_compile_error ripper_compile_error
00717 # define compile_error ripper_compile_error
00718 # define PARSER_ARG parser,
00719 #else
00720 # define rb_compile_error rb_compile_error_with_enc
00721 # define compile_error parser->nerr++,rb_compile_error_with_enc
00722 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
00723 #endif
00724 
00725 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00726    for instance).  This is too low for Ruby to parse some files, such as
00727    date/format.rb, therefore bump the value up to at least Bison's default. */
00728 #ifdef OLD_YACC
00729 #ifndef YYMAXDEPTH
00730 #define YYMAXDEPTH 10000
00731 #endif
00732 #endif
00733 
00734 #ifndef RIPPER
00735 static void token_info_push(struct parser_params*, const char *token);
00736 static void token_info_pop(struct parser_params*, const char *token);
00737 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
00738 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
00739 #else
00740 #define token_info_push(token) /* nothing */
00741 #define token_info_pop(token) /* nothing */
00742 #endif
00743 
00744 
00745 /* Line 268 of yacc.c  */
00746 #line 747 "parse.c"
00747 
00748 /* Enabling traces.  */
00749 #ifndef YYDEBUG
00750 # define YYDEBUG 0
00751 #endif
00752 
00753 /* Enabling verbose error messages.  */
00754 #ifdef YYERROR_VERBOSE
00755 # undef YYERROR_VERBOSE
00756 # define YYERROR_VERBOSE 1
00757 #else
00758 # define YYERROR_VERBOSE 0
00759 #endif
00760 
00761 /* Enabling the token table.  */
00762 #ifndef YYTOKEN_TABLE
00763 # define YYTOKEN_TABLE 0
00764 #endif
00765 
00766 
00767 /* Tokens.  */
00768 #ifndef YYTOKENTYPE
00769 # define YYTOKENTYPE
00770    /* Put the tokens into the symbol table, so that GDB and other debuggers
00771       know about them.  */
00772    enum yytokentype {
00773      END_OF_INPUT = 0,
00774      keyword_class = 258,
00775      keyword_module = 259,
00776      keyword_def = 260,
00777      keyword_undef = 261,
00778      keyword_begin = 262,
00779      keyword_rescue = 263,
00780      keyword_ensure = 264,
00781      keyword_end = 265,
00782      keyword_if = 266,
00783      keyword_unless = 267,
00784      keyword_then = 268,
00785      keyword_elsif = 269,
00786      keyword_else = 270,
00787      keyword_case = 271,
00788      keyword_when = 272,
00789      keyword_while = 273,
00790      keyword_until = 274,
00791      keyword_for = 275,
00792      keyword_break = 276,
00793      keyword_next = 277,
00794      keyword_redo = 278,
00795      keyword_retry = 279,
00796      keyword_in = 280,
00797      keyword_do = 281,
00798      keyword_do_cond = 282,
00799      keyword_do_block = 283,
00800      keyword_do_LAMBDA = 284,
00801      keyword_return = 285,
00802      keyword_yield = 286,
00803      keyword_super = 287,
00804      keyword_self = 288,
00805      keyword_nil = 289,
00806      keyword_true = 290,
00807      keyword_false = 291,
00808      keyword_and = 292,
00809      keyword_or = 293,
00810      keyword_not = 294,
00811      modifier_if = 295,
00812      modifier_unless = 296,
00813      modifier_while = 297,
00814      modifier_until = 298,
00815      modifier_rescue = 299,
00816      keyword_alias = 300,
00817      keyword_defined = 301,
00818      keyword_BEGIN = 302,
00819      keyword_END = 303,
00820      keyword__LINE__ = 304,
00821      keyword__FILE__ = 305,
00822      keyword__ENCODING__ = 306,
00823      tIDENTIFIER = 307,
00824      tFID = 308,
00825      tGVAR = 309,
00826      tIVAR = 310,
00827      tCONSTANT = 311,
00828      tCVAR = 312,
00829      tLABEL = 313,
00830      tINTEGER = 314,
00831      tFLOAT = 315,
00832      tSTRING_CONTENT = 316,
00833      tCHAR = 317,
00834      tNTH_REF = 318,
00835      tBACK_REF = 319,
00836      tREGEXP_END = 320,
00837      tUPLUS = 130,
00838      tUMINUS = 131,
00839      tPOW = 132,
00840      tCMP = 134,
00841      tEQ = 139,
00842      tEQQ = 140,
00843      tNEQ = 141,
00844      tGEQ = 138,
00845      tLEQ = 137,
00846      tANDOP = 321,
00847      tOROP = 322,
00848      tMATCH = 142,
00849      tNMATCH = 143,
00850      tDOT2 = 128,
00851      tDOT3 = 129,
00852      tAREF = 144,
00853      tASET = 145,
00854      tLSHFT = 135,
00855      tRSHFT = 136,
00856      tCOLON2 = 323,
00857      tCOLON3 = 324,
00858      tOP_ASGN = 325,
00859      tASSOC = 326,
00860      tLPAREN = 327,
00861      tLPAREN_ARG = 328,
00862      tRPAREN = 329,
00863      tLBRACK = 330,
00864      tLBRACE = 331,
00865      tLBRACE_ARG = 332,
00866      tSTAR = 333,
00867      tDSTAR = 334,
00868      tAMPER = 335,
00869      tLAMBDA = 336,
00870      tSYMBEG = 337,
00871      tSTRING_BEG = 338,
00872      tXSTRING_BEG = 339,
00873      tREGEXP_BEG = 340,
00874      tWORDS_BEG = 341,
00875      tQWORDS_BEG = 342,
00876      tSYMBOLS_BEG = 343,
00877      tQSYMBOLS_BEG = 344,
00878      tSTRING_DBEG = 345,
00879      tSTRING_DEND = 346,
00880      tSTRING_DVAR = 347,
00881      tSTRING_END = 348,
00882      tLAMBEG = 349,
00883      tLOWEST = 350,
00884      tUMINUS_NUM = 351,
00885      tLAST_TOKEN = 352
00886    };
00887 #endif
00888 
00889 
00890 
00891 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00892 typedef union YYSTYPE
00893 {
00894 
00895 /* Line 293 of yacc.c  */
00896 #line 691 "parse.y"
00897 
00898     VALUE val;
00899     NODE *node;
00900     ID id;
00901     int num;
00902     const struct vtable *vars;
00903 
00904 
00905 
00906 /* Line 293 of yacc.c  */
00907 #line 908 "parse.c"
00908 } YYSTYPE;
00909 # define YYSTYPE_IS_TRIVIAL 1
00910 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00911 # define YYSTYPE_IS_DECLARED 1
00912 #endif
00913 
00914 
00915 /* Copy the second part of user declarations.  */
00916 
00917 
00918 /* Line 343 of yacc.c  */
00919 #line 920 "parse.c"
00920 
00921 #ifdef short
00922 # undef short
00923 #endif
00924 
00925 #ifdef YYTYPE_UINT8
00926 typedef YYTYPE_UINT8 yytype_uint8;
00927 #else
00928 typedef unsigned char yytype_uint8;
00929 #endif
00930 
00931 #ifdef YYTYPE_INT8
00932 typedef YYTYPE_INT8 yytype_int8;
00933 #elif (defined __STDC__ || defined __C99__FUNC__ \
00934      || defined __cplusplus || defined _MSC_VER)
00935 typedef signed char yytype_int8;
00936 #else
00937 typedef short int yytype_int8;
00938 #endif
00939 
00940 #ifdef YYTYPE_UINT16
00941 typedef YYTYPE_UINT16 yytype_uint16;
00942 #else
00943 typedef unsigned short int yytype_uint16;
00944 #endif
00945 
00946 #ifdef YYTYPE_INT16
00947 typedef YYTYPE_INT16 yytype_int16;
00948 #else
00949 typedef short int yytype_int16;
00950 #endif
00951 
00952 #ifndef YYSIZE_T
00953 # ifdef __SIZE_TYPE__
00954 #  define YYSIZE_T __SIZE_TYPE__
00955 # elif defined size_t
00956 #  define YYSIZE_T size_t
00957 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00958      || defined __cplusplus || defined _MSC_VER)
00959 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00960 #  define YYSIZE_T size_t
00961 # else
00962 #  define YYSIZE_T unsigned int
00963 # endif
00964 #endif
00965 
00966 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00967 
00968 #ifndef YY_
00969 # if defined YYENABLE_NLS && YYENABLE_NLS
00970 #  if ENABLE_NLS
00971 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00972 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00973 #  endif
00974 # endif
00975 # ifndef YY_
00976 #  define YY_(msgid) msgid
00977 # endif
00978 #endif
00979 
00980 /* Suppress unused-variable warnings by "using" E.  */
00981 #if ! defined lint || defined __GNUC__
00982 # define YYUSE(e) ((void) (e))
00983 #else
00984 # define YYUSE(e) /* empty */
00985 #endif
00986 
00987 /* Identity function, used to suppress warnings about constant conditions.  */
00988 #ifndef lint
00989 # define YYID(n) (n)
00990 #else
00991 #if (defined __STDC__ || defined __C99__FUNC__ \
00992      || defined __cplusplus || defined _MSC_VER)
00993 static int
00994 YYID (int yyi)
00995 #else
00996 static int
00997 YYID (yyi)
00998     int yyi;
00999 #endif
01000 {
01001   return yyi;
01002 }
01003 #endif
01004 
01005 #if ! defined yyoverflow || YYERROR_VERBOSE
01006 
01007 /* The parser invokes alloca or malloc; define the necessary symbols.  */
01008 
01009 # ifdef YYSTACK_USE_ALLOCA
01010 #  if YYSTACK_USE_ALLOCA
01011 #   ifdef __GNUC__
01012 #    define YYSTACK_ALLOC __builtin_alloca
01013 #   elif defined __BUILTIN_VA_ARG_INCR
01014 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
01015 #   elif defined _AIX
01016 #    define YYSTACK_ALLOC __alloca
01017 #   elif defined _MSC_VER
01018 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
01019 #    define alloca _alloca
01020 #   else
01021 #    define YYSTACK_ALLOC alloca
01022 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01023      || defined __cplusplus || defined _MSC_VER)
01024 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01025 #     ifndef EXIT_SUCCESS
01026 #      define EXIT_SUCCESS 0
01027 #     endif
01028 #    endif
01029 #   endif
01030 #  endif
01031 # endif
01032 
01033 # ifdef YYSTACK_ALLOC
01034    /* Pacify GCC's `empty if-body' warning.  */
01035 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
01036 #  ifndef YYSTACK_ALLOC_MAXIMUM
01037     /* The OS might guarantee only one guard page at the bottom of the stack,
01038        and a page size can be as small as 4096 bytes.  So we cannot safely
01039        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01040        to allow for a few compiler-allocated temporary stack slots.  */
01041 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01042 #  endif
01043 # else
01044 #  define YYSTACK_ALLOC YYMALLOC
01045 #  define YYSTACK_FREE YYFREE
01046 #  ifndef YYSTACK_ALLOC_MAXIMUM
01047 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01048 #  endif
01049 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
01050        && ! ((defined YYMALLOC || defined malloc) \
01051              && (defined YYFREE || defined free)))
01052 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01053 #   ifndef EXIT_SUCCESS
01054 #    define EXIT_SUCCESS 0
01055 #   endif
01056 #  endif
01057 #  ifndef YYMALLOC
01058 #   define YYMALLOC malloc
01059 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01060      || defined __cplusplus || defined _MSC_VER)
01061 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01062 #   endif
01063 #  endif
01064 #  ifndef YYFREE
01065 #   define YYFREE free
01066 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01067      || defined __cplusplus || defined _MSC_VER)
01068 void free (void *); /* INFRINGES ON USER NAME SPACE */
01069 #   endif
01070 #  endif
01071 # endif
01072 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01073 
01074 
01075 #if (! defined yyoverflow \
01076      && (! defined __cplusplus \
01077          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01078 
01079 /* A type that is properly aligned for any stack member.  */
01080 union yyalloc
01081 {
01082   yytype_int16 yyss_alloc;
01083   YYSTYPE yyvs_alloc;
01084 };
01085 
01086 /* The size of the maximum gap between one aligned stack and the next.  */
01087 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01088 
01089 /* The size of an array large to enough to hold all stacks, each with
01090    N elements.  */
01091 # define YYSTACK_BYTES(N) \
01092      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01093       + YYSTACK_GAP_MAXIMUM)
01094 
01095 # define YYCOPY_NEEDED 1
01096 
01097 /* Relocate STACK from its old location to the new one.  The
01098    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01099    elements in the stack, and YYPTR gives the new location of the
01100    stack.  Advance YYPTR to a properly aligned location for the next
01101    stack.  */
01102 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01103     do                                                                  \
01104       {                                                                 \
01105         YYSIZE_T yynewbytes;                                            \
01106         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01107         Stack = &yyptr->Stack_alloc;                                    \
01108         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01109         yyptr += yynewbytes / sizeof (*yyptr);                          \
01110       }                                                                 \
01111     while (YYID (0))
01112 
01113 #endif
01114 
01115 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
01116 /* Copy COUNT objects from FROM to TO.  The source and destination do
01117    not overlap.  */
01118 # ifndef YYCOPY
01119 #  if defined __GNUC__ && 1 < __GNUC__
01120 #   define YYCOPY(To, From, Count) \
01121       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01122 #  else
01123 #   define YYCOPY(To, From, Count)              \
01124       do                                        \
01125         {                                       \
01126           YYSIZE_T yyi;                         \
01127           for (yyi = 0; yyi < (Count); yyi++)   \
01128             (To)[yyi] = (From)[yyi];            \
01129         }                                       \
01130       while (YYID (0))
01131 #  endif
01132 # endif
01133 #endif /* !YYCOPY_NEEDED */
01134 
01135 /* YYFINAL -- State number of the termination state.  */
01136 #define YYFINAL  3
01137 /* YYLAST -- Last index in YYTABLE.  */
01138 #define YYLAST   10700
01139 
01140 /* YYNTOKENS -- Number of terminals.  */
01141 #define YYNTOKENS  142
01142 /* YYNNTS -- Number of nonterminals.  */
01143 #define YYNNTS  199
01144 /* YYNRULES -- Number of rules.  */
01145 #define YYNRULES  620
01146 /* YYNRULES -- Number of states.  */
01147 #define YYNSTATES  1057
01148 
01149 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01150 #define YYUNDEFTOK  2
01151 #define YYMAXUTOK   352
01152 
01153 #define YYTRANSLATE(YYX)                                                \
01154   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01155 
01156 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01157 static const yytype_uint8 yytranslate[] =
01158 {
01159        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01160      141,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01161        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01162        2,     2,   140,   127,     2,     2,     2,   125,   120,     2,
01163      136,   137,   123,   121,   134,   122,   133,   124,     2,     2,
01164        2,     2,     2,     2,     2,     2,     2,     2,   115,   139,
01165      117,   113,   116,   114,     2,     2,     2,     2,     2,     2,
01166        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01167        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01168        2,   132,     2,   138,   119,     2,   135,     2,     2,     2,
01169        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01170        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01171        2,     2,     2,   130,   118,   131,   128,     2,    79,    80,
01172       66,    67,    68,     2,    69,    83,    84,    74,    73,    70,
01173       71,    72,    77,    78,    81,    82,     2,     2,     2,     2,
01174        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01175        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01176        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01177        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01178        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01179        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01180        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01181        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01182        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01183        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01184        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01185        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01186       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01187       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01188       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01189       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01190       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01191       65,    75,    76,    85,    86,    87,    88,    89,    90,    91,
01192       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
01193      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
01194      112,   126,   129
01195 };
01196 
01197 #if YYDEBUG
01198 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01199    YYRHS.  */
01200 static const yytype_uint16 yyprhs[] =
01201 {
01202        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01203       23,    24,    30,    35,    38,    40,    42,    46,    49,    51,
01204       52,    58,    59,    64,    68,    72,    76,    79,    83,    87,
01205       91,    95,    99,   104,   106,   110,   114,   121,   127,   133,
01206      139,   145,   149,   153,   157,   161,   163,   167,   171,   173,
01207      177,   181,   185,   188,   190,   192,   194,   196,   198,   203,
01208      204,   210,   212,   215,   219,   224,   230,   235,   241,   244,
01209      247,   250,   253,   256,   258,   262,   264,   268,   270,   273,
01210      277,   283,   286,   291,   294,   299,   301,   305,   307,   311,
01211      314,   318,   320,   324,   326,   328,   333,   337,   341,   345,
01212      349,   352,   354,   356,   358,   363,   367,   371,   375,   379,
01213      382,   384,   386,   388,   391,   393,   397,   399,   401,   403,
01214      405,   407,   409,   411,   413,   415,   417,   418,   423,   425,
01215      427,   429,   431,   433,   435,   437,   439,   441,   443,   445,
01216      447,   449,   451,   453,   455,   457,   459,   461,   463,   465,
01217      467,   469,   471,   473,   475,   477,   479,   481,   483,   485,
01218      487,   489,   491,   493,   495,   497,   499,   501,   503,   505,
01219      507,   509,   511,   513,   515,   517,   519,   521,   523,   525,
01220      527,   529,   531,   533,   535,   537,   539,   541,   543,   545,
01221      547,   549,   551,   553,   555,   557,   559,   561,   563,   565,
01222      569,   575,   579,   585,   592,   598,   604,   610,   616,   621,
01223      625,   629,   633,   637,   641,   645,   649,   653,   657,   662,
01224      667,   670,   673,   677,   681,   685,   689,   693,   697,   701,
01225      705,   709,   713,   717,   721,   725,   728,   731,   735,   739,
01226      743,   747,   748,   753,   760,   762,   764,   766,   769,   774,
01227      777,   781,   783,   785,   787,   789,   792,   797,   800,   802,
01228      805,   808,   813,   815,   816,   819,   822,   825,   827,   829,
01229      832,   836,   841,   845,   850,   853,   855,   857,   859,   861,
01230      863,   865,   867,   869,   871,   873,   875,   876,   881,   882,
01231      886,   887,   888,   894,   898,   902,   905,   909,   913,   915,
01232      920,   924,   926,   927,   934,   939,   943,   946,   948,   951,
01233      954,   961,   968,   969,   970,   978,   979,   980,   988,   994,
01234      999,  1000,  1001,  1011,  1012,  1019,  1020,  1021,  1030,  1031,
01235     1037,  1038,  1045,  1046,  1047,  1057,  1059,  1061,  1063,  1065,
01236     1067,  1069,  1071,  1073,  1075,  1077,  1079,  1081,  1083,  1085,
01237     1087,  1089,  1091,  1093,  1096,  1098,  1100,  1102,  1108,  1110,
01238     1113,  1115,  1117,  1119,  1123,  1125,  1129,  1131,  1136,  1143,
01239     1147,  1153,  1156,  1161,  1163,  1167,  1172,  1175,  1178,  1180,
01240     1183,  1184,  1191,  1200,  1205,  1212,  1217,  1220,  1227,  1230,
01241     1235,  1242,  1245,  1250,  1253,  1258,  1260,  1262,  1264,  1268,
01242     1270,  1275,  1277,  1282,  1284,  1288,  1290,  1292,  1293,  1294,
01243     1295,  1301,  1306,  1308,  1312,  1316,  1317,  1323,  1326,  1331,
01244     1337,  1343,  1346,  1347,  1353,  1354,  1360,  1364,  1365,  1370,
01245     1371,  1376,  1379,  1381,  1386,  1387,  1393,  1394,  1400,  1406,
01246     1408,  1410,  1417,  1419,  1421,  1423,  1425,  1428,  1430,  1433,
01247     1435,  1437,  1439,  1441,  1443,  1445,  1447,  1450,  1454,  1458,
01248     1462,  1466,  1470,  1471,  1475,  1477,  1480,  1484,  1488,  1489,
01249     1493,  1497,  1501,  1505,  1509,  1510,  1514,  1515,  1519,  1520,
01250     1523,  1524,  1527,  1528,  1531,  1533,  1534,  1538,  1539,  1540,
01251     1541,  1548,  1550,  1552,  1554,  1556,  1559,  1561,  1563,  1565,
01252     1567,  1571,  1573,  1575,  1578,  1581,  1583,  1585,  1587,  1589,
01253     1591,  1593,  1595,  1597,  1599,  1601,  1603,  1605,  1607,  1609,
01254     1611,  1613,  1615,  1617,  1619,  1620,  1625,  1628,  1632,  1635,
01255     1640,  1643,  1646,  1648,  1651,  1652,  1659,  1668,  1673,  1680,
01256     1685,  1692,  1695,  1700,  1707,  1710,  1715,  1718,  1723,  1725,
01257     1726,  1728,  1730,  1732,  1734,  1736,  1738,  1740,  1744,  1746,
01258     1750,  1753,  1756,  1758,  1762,  1764,  1768,  1770,  1772,  1775,
01259     1777,  1781,  1785,  1787,  1791,  1793,  1797,  1799,  1801,  1804,
01260     1806,  1808,  1810,  1813,  1816,  1818,  1820,  1821,  1826,  1828,
01261     1831,  1833,  1837,  1841,  1844,  1847,  1849,  1851,  1853,  1855,
01262     1857,  1859,  1861,  1863,  1865,  1867,  1869,  1871,  1872,  1874,
01263     1875,  1877,  1880,  1883,  1884,  1886,  1888,  1890,  1892,  1894,
01264     1897
01265 };
01266 
01267 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01268 static const yytype_int16 yyrhs[] =
01269 {
01270      143,     0,    -1,    -1,   144,   145,    -1,   146,   333,    -1,
01271      340,    -1,   147,    -1,   146,   339,   147,    -1,     1,   147,
01272       -1,   154,    -1,    -1,    47,   148,   130,   145,   131,    -1,
01273      150,   262,   230,   265,    -1,   151,   333,    -1,   340,    -1,
01274      152,    -1,   151,   339,   152,    -1,     1,   154,    -1,   154,
01275       -1,    -1,    47,   153,   130,   145,   131,    -1,    -1,    45,
01276      177,   155,   177,    -1,    45,    54,    54,    -1,    45,    54,
01277       64,    -1,    45,    54,    63,    -1,     6,   178,    -1,   154,
01278       40,   158,    -1,   154,    41,   158,    -1,   154,    42,   158,
01279       -1,   154,    43,   158,    -1,   154,    44,   154,    -1,    48,
01280      130,   150,   131,    -1,   156,    -1,   165,   113,   159,    -1,
01281      297,    87,   159,    -1,   215,   132,   188,   336,    87,   159,
01282       -1,   215,   133,    52,    87,   159,    -1,   215,   133,    56,
01283       87,   159,    -1,   215,    85,    56,    87,   159,    -1,   215,
01284       85,    52,    87,   159,    -1,   298,    87,   159,    -1,   172,
01285      113,   195,    -1,   165,   113,   184,    -1,   165,   113,   195,
01286       -1,   157,    -1,   172,   113,   159,    -1,   172,   113,   156,
01287       -1,   159,    -1,   157,    37,   157,    -1,   157,    38,   157,
01288       -1,    39,   334,   157,    -1,   127,   159,    -1,   182,    -1,
01289      157,    -1,   164,    -1,   160,    -1,   251,    -1,   251,   332,
01290      330,   190,    -1,    -1,    94,   162,   238,   150,   131,    -1,
01291      329,    -1,   163,   190,    -1,   163,   190,   161,    -1,   215,
01292      133,   330,   190,    -1,   215,   133,   330,   190,   161,    -1,
01293      215,    85,   330,   190,    -1,   215,    85,   330,   190,   161,
01294       -1,    32,   190,    -1,    31,   190,    -1,    30,   189,    -1,
01295       21,   189,    -1,    22,   189,    -1,   167,    -1,    89,   166,
01296      335,    -1,   167,    -1,    89,   166,   335,    -1,   169,    -1,
01297      169,   168,    -1,   169,    95,   171,    -1,   169,    95,   171,
01298      134,   170,    -1,   169,    95,    -1,   169,    95,   134,   170,
01299       -1,    95,   171,    -1,    95,   171,   134,   170,    -1,    95,
01300       -1,    95,   134,   170,    -1,   171,    -1,    89,   166,   335,
01301       -1,   168,   134,    -1,   169,   168,   134,    -1,   168,    -1,
01302      170,   134,   168,    -1,   294,    -1,   295,    -1,   215,   132,
01303      188,   336,    -1,   215,   133,    52,    -1,   215,    85,    52,
01304       -1,   215,   133,    56,    -1,   215,    85,    56,    -1,    86,
01305       56,    -1,   298,    -1,   294,    -1,   295,    -1,   215,   132,
01306      188,   336,    -1,   215,   133,    52,    -1,   215,    85,    52,
01307       -1,   215,   133,    56,    -1,   215,    85,    56,    -1,    86,
01308       56,    -1,   298,    -1,    52,    -1,    56,    -1,    86,   173,
01309       -1,   173,    -1,   215,    85,   173,    -1,    52,    -1,    56,
01310       -1,    53,    -1,   180,    -1,   181,    -1,   175,    -1,   290,
01311       -1,   176,    -1,   292,    -1,   177,    -1,    -1,   178,   134,
01312      179,   177,    -1,   118,    -1,   119,    -1,   120,    -1,    69,
01313       -1,    70,    -1,    71,    -1,    77,    -1,    78,    -1,   116,
01314       -1,    73,    -1,   117,    -1,    74,    -1,    72,    -1,    83,
01315       -1,    84,    -1,   121,    -1,   122,    -1,   123,    -1,    95,
01316       -1,   124,    -1,   125,    -1,    68,    -1,    96,    -1,   127,
01317       -1,   128,    -1,    66,    -1,    67,    -1,    81,    -1,    82,
01318       -1,   135,    -1,    49,    -1,    50,    -1,    51,    -1,    47,
01319       -1,    48,    -1,    45,    -1,    37,    -1,     7,    -1,    21,
01320       -1,    16,    -1,     3,    -1,     5,    -1,    46,    -1,    26,
01321       -1,    15,    -1,    14,    -1,    10,    -1,     9,    -1,    36,
01322       -1,    20,    -1,    25,    -1,     4,    -1,    22,    -1,    34,
01323       -1,    39,    -1,    38,    -1,    23,    -1,     8,    -1,    24,
01324       -1,    30,    -1,    33,    -1,    32,    -1,    13,    -1,    35,
01325       -1,     6,    -1,    17,    -1,    31,    -1,    11,    -1,    12,
01326       -1,    18,    -1,    19,    -1,   172,   113,   182,    -1,   172,
01327      113,   182,    44,   182,    -1,   297,    87,   182,    -1,   297,
01328       87,   182,    44,   182,    -1,   215,   132,   188,   336,    87,
01329      182,    -1,   215,   133,    52,    87,   182,    -1,   215,   133,
01330       56,    87,   182,    -1,   215,    85,    52,    87,   182,    -1,
01331      215,    85,    56,    87,   182,    -1,    86,    56,    87,   182,
01332       -1,   298,    87,   182,    -1,   182,    79,   182,    -1,   182,
01333       80,   182,    -1,   182,   121,   182,    -1,   182,   122,   182,
01334       -1,   182,   123,   182,    -1,   182,   124,   182,    -1,   182,
01335      125,   182,    -1,   182,    68,   182,    -1,   126,    59,    68,
01336      182,    -1,   126,    60,    68,   182,    -1,    66,   182,    -1,
01337       67,   182,    -1,   182,   118,   182,    -1,   182,   119,   182,
01338       -1,   182,   120,   182,    -1,   182,    69,   182,    -1,   182,
01339      116,   182,    -1,   182,    73,   182,    -1,   182,   117,   182,
01340       -1,   182,    74,   182,    -1,   182,    70,   182,    -1,   182,
01341       71,   182,    -1,   182,    72,   182,    -1,   182,    77,   182,
01342       -1,   182,    78,   182,    -1,   127,   182,    -1,   128,   182,
01343       -1,   182,    83,   182,    -1,   182,    84,   182,    -1,   182,
01344       75,   182,    -1,   182,    76,   182,    -1,    -1,    46,   334,
01345      183,   182,    -1,   182,   114,   182,   334,   115,   182,    -1,
01346      196,    -1,   182,    -1,   340,    -1,   194,   337,    -1,   194,
01347      134,   327,   337,    -1,   327,   337,    -1,   136,   188,   335,
01348       -1,   340,    -1,   186,    -1,   340,    -1,   189,    -1,   194,
01349      134,    -1,   194,   134,   327,   134,    -1,   327,   134,    -1,
01350      164,    -1,   194,   193,    -1,   327,   193,    -1,   194,   134,
01351      327,   193,    -1,   192,    -1,    -1,   191,   189,    -1,    97,
01352      184,    -1,   134,   192,    -1,   340,    -1,   184,    -1,    95,
01353      184,    -1,   194,   134,   184,    -1,   194,   134,    95,   184,
01354       -1,   194,   134,   184,    -1,   194,   134,    95,   184,    -1,
01355       95,   184,    -1,   266,    -1,   267,    -1,   270,    -1,   271,
01356       -1,   272,    -1,   277,    -1,   275,    -1,   278,    -1,   296,
01357       -1,   298,    -1,    53,    -1,    -1,   216,   197,   149,   226,
01358       -1,    -1,    90,   198,   335,    -1,    -1,    -1,    90,   199,
01359      157,   200,   335,    -1,    89,   150,   137,    -1,   215,    85,
01360       56,    -1,    86,    56,    -1,    92,   185,   138,    -1,    93,
01361      326,   131,    -1,    30,    -1,    31,   136,   189,   335,    -1,
01362       31,   136,   335,    -1,    31,    -1,    -1,    46,   334,   136,
01363      201,   157,   335,    -1,    39,   136,   157,   335,    -1,    39,
01364      136,   335,    -1,   163,   257,    -1,   252,    -1,   252,   257,
01365       -1,    98,   243,    -1,   217,   158,   227,   150,   229,   226,
01366       -1,   218,   158,   227,   150,   230,   226,    -1,    -1,    -1,
01367      219,   202,   158,   228,   203,   150,   226,    -1,    -1,    -1,
01368      220,   204,   158,   228,   205,   150,   226,    -1,   221,   158,
01369      333,   260,   226,    -1,   221,   333,   260,   226,    -1,    -1,
01370       -1,   222,   231,    25,   206,   158,   228,   207,   150,   226,
01371       -1,    -1,   223,   174,   299,   208,   149,   226,    -1,    -1,
01372       -1,   223,    83,   157,   209,   338,   210,   149,   226,    -1,
01373       -1,   224,   174,   211,   149,   226,    -1,    -1,   225,   175,
01374      212,   301,   149,   226,    -1,    -1,    -1,   225,   324,   332,
01375      213,   175,   214,   301,   149,   226,    -1,    21,    -1,    22,
01376       -1,    23,    -1,    24,    -1,   196,    -1,     7,    -1,    11,
01377       -1,    12,    -1,    18,    -1,    19,    -1,    16,    -1,    20,
01378       -1,     3,    -1,     4,    -1,     5,    -1,    10,    -1,   338,
01379       -1,    13,    -1,   338,    13,    -1,   338,    -1,    27,    -1,
01380      230,    -1,    14,   158,   227,   150,   229,    -1,   340,    -1,
01381       15,   150,    -1,   172,    -1,   165,    -1,   306,    -1,    89,
01382      234,   335,    -1,   232,    -1,   233,   134,   232,    -1,   233,
01383       -1,   233,   134,    95,   306,    -1,   233,   134,    95,   306,
01384      134,   233,    -1,   233,   134,    95,    -1,   233,   134,    95,
01385      134,   233,    -1,    95,   306,    -1,    95,   306,   134,   233,
01386       -1,    95,    -1,    95,   134,   233,    -1,   311,   134,   314,
01387      323,    -1,   311,   323,    -1,   314,   323,    -1,   322,    -1,
01388      134,   235,    -1,    -1,   308,   134,   317,   134,   320,   236,
01389       -1,   308,   134,   317,   134,   320,   134,   308,   236,    -1,
01390      308,   134,   317,   236,    -1,   308,   134,   317,   134,   308,
01391      236,    -1,   308,   134,   320,   236,    -1,   308,   134,    -1,
01392      308,   134,   320,   134,   308,   236,    -1,   308,   236,    -1,
01393      317,   134,   320,   236,    -1,   317,   134,   320,   134,   308,
01394      236,    -1,   317,   236,    -1,   317,   134,   308,   236,    -1,
01395      320,   236,    -1,   320,   134,   308,   236,    -1,   235,    -1,
01396      340,    -1,   239,    -1,   118,   240,   118,    -1,    76,    -1,
01397      118,   237,   240,   118,    -1,   334,    -1,   334,   139,   241,
01398      334,    -1,   242,    -1,   241,   134,   242,    -1,    52,    -1,
01399      305,    -1,    -1,    -1,    -1,   244,   245,   247,   246,   248,
01400       -1,   136,   304,   240,   137,    -1,   304,    -1,   111,   150,
01401      131,    -1,    29,   150,    10,    -1,    -1,    28,   250,   238,
01402      150,    10,    -1,   164,   249,    -1,   251,   332,   330,   187,
01403       -1,   251,   332,   330,   187,   257,    -1,   251,   332,   330,
01404      190,   249,    -1,   163,   186,    -1,    -1,   215,   133,   330,
01405      253,   187,    -1,    -1,   215,    85,   330,   254,   186,    -1,
01406      215,    85,   331,    -1,    -1,   215,   133,   255,   186,    -1,
01407       -1,   215,    85,   256,   186,    -1,    32,   186,    -1,    32,
01408       -1,   215,   132,   188,   336,    -1,    -1,   130,   258,   238,
01409      150,   131,    -1,    -1,    26,   259,   238,   150,    10,    -1,
01410       17,   194,   227,   150,   261,    -1,   230,    -1,   260,    -1,
01411        8,   263,   264,   227,   150,   262,    -1,   340,    -1,   184,
01412       -1,   195,    -1,   340,    -1,    88,   172,    -1,   340,    -1,
01413        9,   150,    -1,   340,    -1,   293,    -1,   290,    -1,   292,
01414       -1,   268,    -1,    62,    -1,   269,    -1,   268,   269,    -1,
01415      100,   281,   110,    -1,   101,   282,   110,    -1,   102,   283,
01416       65,    -1,   103,   140,   110,    -1,   103,   273,   110,    -1,
01417       -1,   273,   274,   140,    -1,   284,    -1,   274,   284,    -1,
01418      105,   140,   110,    -1,   105,   276,   110,    -1,    -1,   276,
01419      274,   140,    -1,   104,   140,   110,    -1,   104,   279,   110,
01420       -1,   106,   140,   110,    -1,   106,   280,   110,    -1,    -1,
01421      279,    61,   140,    -1,    -1,   280,    61,   140,    -1,    -1,
01422      281,   284,    -1,    -1,   282,   284,    -1,    -1,   283,   284,
01423       -1,    61,    -1,    -1,   109,   285,   289,    -1,    -1,    -1,
01424       -1,   107,   286,   287,   288,   150,   108,    -1,    54,    -1,
01425       55,    -1,    57,    -1,   298,    -1,    99,   291,    -1,   175,
01426       -1,    55,    -1,    54,    -1,    57,    -1,    99,   282,   110,
01427       -1,    59,    -1,    60,    -1,   126,    59,    -1,   126,    60,
01428       -1,    52,    -1,    55,    -1,    54,    -1,    56,    -1,    57,
01429       -1,    34,    -1,    33,    -1,    35,    -1,    36,    -1,    50,
01430       -1,    49,    -1,    51,    -1,   294,    -1,   295,    -1,   294,
01431       -1,   295,    -1,    63,    -1,    64,    -1,   338,    -1,    -1,
01432      117,   300,   158,   338,    -1,     1,   338,    -1,   136,   304,
01433      335,    -1,   304,   338,    -1,   312,   134,   314,   323,    -1,
01434      312,   323,    -1,   314,   323,    -1,   322,    -1,   134,   302,
01435       -1,    -1,   308,   134,   318,   134,   320,   303,    -1,   308,
01436      134,   318,   134,   320,   134,   308,   303,    -1,   308,   134,
01437      318,   303,    -1,   308,   134,   318,   134,   308,   303,    -1,
01438      308,   134,   320,   303,    -1,   308,   134,   320,   134,   308,
01439      303,    -1,   308,   303,    -1,   318,   134,   320,   303,    -1,
01440      318,   134,   320,   134,   308,   303,    -1,   318,   303,    -1,
01441      318,   134,   308,   303,    -1,   320,   303,    -1,   320,   134,
01442      308,   303,    -1,   302,    -1,    -1,    56,    -1,    55,    -1,
01443       54,    -1,    57,    -1,   305,    -1,    52,    -1,   306,    -1,
01444       89,   234,   335,    -1,   307,    -1,   308,   134,   307,    -1,
01445       58,   184,    -1,    58,   215,    -1,   310,    -1,   311,   134,
01446      310,    -1,   309,    -1,   312,   134,   309,    -1,    68,    -1,
01447       96,    -1,   313,    52,    -1,   313,    -1,    52,   113,   184,
01448       -1,    52,   113,   215,    -1,   316,    -1,   317,   134,   316,
01449       -1,   315,    -1,   318,   134,   315,    -1,   123,    -1,    95,
01450       -1,   319,    52,    -1,   319,    -1,   120,    -1,    97,    -1,
01451      321,    52,    -1,   134,   322,    -1,   340,    -1,   296,    -1,
01452       -1,   136,   325,   157,   335,    -1,   340,    -1,   327,   337,
01453       -1,   328,    -1,   327,   134,   328,    -1,   184,    88,   184,
01454       -1,    58,   184,    -1,    96,   184,    -1,    52,    -1,    56,
01455       -1,    53,    -1,    52,    -1,    56,    -1,    53,    -1,   180,
01456       -1,    52,    -1,    53,    -1,   180,    -1,   133,    -1,    85,
01457       -1,    -1,   339,    -1,    -1,   141,    -1,   334,   137,    -1,
01458      334,   138,    -1,    -1,   141,    -1,   134,    -1,   139,    -1,
01459      141,    -1,   338,    -1,   339,   139,    -1,    -1
01460 };
01461 
01462 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01463 static const yytype_uint16 yyrline[] =
01464 {
01465        0,   855,   855,   855,   886,   897,   906,   914,   922,   928,
01466      930,   929,   950,   983,   994,  1003,  1011,  1019,  1025,  1030,
01467     1029,  1050,  1050,  1058,  1066,  1077,  1087,  1095,  1104,  1113,
01468     1126,  1139,  1148,  1160,  1161,  1171,  1176,  1197,  1202,  1207,
01469     1217,  1222,  1232,  1241,  1250,  1259,  1262,  1271,  1283,  1284,
01470     1292,  1300,  1308,  1316,  1319,  1331,  1332,  1335,  1336,  1348,
01471     1347,  1369,  1379,  1388,  1401,  1410,  1422,  1431,  1443,  1452,
01472     1461,  1469,  1477,  1487,  1488,  1498,  1499,  1509,  1517,  1525,
01473     1533,  1542,  1550,  1559,  1567,  1576,  1584,  1595,  1596,  1606,
01474     1614,  1624,  1632,  1642,  1646,  1650,  1658,  1666,  1674,  1682,
01475     1694,  1704,  1716,  1725,  1734,  1742,  1750,  1758,  1766,  1779,
01476     1792,  1803,  1811,  1814,  1822,  1830,  1840,  1841,  1842,  1843,
01477     1848,  1859,  1860,  1863,  1871,  1874,  1882,  1882,  1892,  1893,
01478     1894,  1895,  1896,  1897,  1898,  1899,  1900,  1901,  1902,  1903,
01479     1904,  1905,  1906,  1907,  1908,  1909,  1910,  1911,  1912,  1913,
01480     1914,  1915,  1916,  1917,  1918,  1919,  1920,  1921,  1924,  1924,
01481     1924,  1925,  1925,  1926,  1926,  1926,  1927,  1927,  1927,  1927,
01482     1928,  1928,  1928,  1928,  1929,  1929,  1929,  1930,  1930,  1930,
01483     1930,  1931,  1931,  1931,  1931,  1932,  1932,  1932,  1932,  1933,
01484     1933,  1933,  1933,  1934,  1934,  1934,  1934,  1935,  1935,  1938,
01485     1947,  1957,  1962,  1972,  1998,  2003,  2008,  2013,  2023,  2033,
01486     2044,  2058,  2072,  2080,  2088,  2096,  2104,  2112,  2120,  2129,
01487     2138,  2146,  2154,  2162,  2170,  2178,  2186,  2194,  2202,  2210,
01488     2218,  2226,  2234,  2242,  2253,  2261,  2269,  2277,  2285,  2293,
01489     2301,  2309,  2309,  2319,  2329,  2335,  2347,  2348,  2352,  2360,
01490     2370,  2380,  2381,  2384,  2385,  2386,  2390,  2398,  2408,  2417,
01491     2425,  2435,  2444,  2453,  2453,  2465,  2475,  2479,  2485,  2493,
01492     2501,  2515,  2531,  2545,  2560,  2570,  2571,  2572,  2573,  2574,
01493     2575,  2576,  2577,  2578,  2579,  2580,  2589,  2588,  2616,  2616,
01494     2625,  2629,  2624,  2638,  2646,  2654,  2662,  2675,  2683,  2691,
01495     2699,  2707,  2715,  2715,  2725,  2733,  2741,  2751,  2752,  2762,
01496     2766,  2778,  2790,  2790,  2790,  2801,  2801,  2801,  2812,  2823,
01497     2832,  2834,  2831,  2898,  2897,  2919,  2924,  2918,  2943,  2942,
01498     2964,  2963,  2986,  2987,  2986,  3007,  3015,  3023,  3031,  3041,
01499     3053,  3059,  3065,  3071,  3077,  3083,  3089,  3095,  3101,  3107,
01500     3117,  3123,  3128,  3129,  3136,  3141,  3144,  3145,  3158,  3159,
01501     3169,  3170,  3173,  3181,  3191,  3199,  3209,  3217,  3226,  3235,
01502     3243,  3251,  3260,  3272,  3280,  3291,  3295,  3299,  3303,  3309,
01503     3314,  3319,  3323,  3327,  3331,  3335,  3339,  3347,  3351,  3355,
01504     3359,  3363,  3367,  3371,  3375,  3379,  3385,  3386,  3392,  3401,
01505     3410,  3421,  3425,  3435,  3442,  3451,  3459,  3465,  3468,  3473,
01506     3465,  3489,  3497,  3507,  3511,  3518,  3517,  3538,  3554,  3563,
01507     3575,  3589,  3599,  3598,  3615,  3614,  3630,  3639,  3638,  3656,
01508     3655,  3672,  3680,  3688,  3703,  3702,  3722,  3721,  3742,  3754,
01509     3755,  3758,  3777,  3780,  3788,  3796,  3799,  3803,  3806,  3814,
01510     3817,  3818,  3826,  3829,  3846,  3847,  3848,  3858,  3868,  3895,
01511     3960,  3969,  3980,  3987,  3997,  4005,  4015,  4024,  4035,  4042,
01512     4060,  4069,  4079,  4088,  4099,  4106,  4117,  4124,  4139,  4146,
01513     4157,  4164,  4175,  4182,  4211,  4213,  4212,  4229,  4235,  4240,
01514     4228,  4259,  4267,  4275,  4283,  4286,  4297,  4298,  4299,  4300,
01515     4303,  4314,  4315,  4316,  4324,  4334,  4335,  4336,  4337,  4338,
01516     4341,  4342,  4343,  4344,  4345,  4346,  4347,  4350,  4363,  4373,
01517     4381,  4391,  4392,  4395,  4404,  4403,  4412,  4424,  4434,  4442,
01518     4446,  4450,  4454,  4460,  4465,  4470,  4474,  4478,  4482,  4486,
01519     4490,  4494,  4498,  4502,  4506,  4510,  4514,  4518,  4522,  4527,
01520     4533,  4542,  4551,  4560,  4571,  4572,  4579,  4588,  4607,  4614,
01521     4627,  4639,  4651,  4659,  4676,  4684,  4700,  4701,  4704,  4709,
01522     4715,  4727,  4739,  4747,  4763,  4771,  4787,  4788,  4791,  4804,
01523     4815,  4816,  4819,  4836,  4840,  4850,  4860,  4860,  4889,  4890,
01524     4900,  4907,  4917,  4925,  4933,  4945,  4946,  4947,  4950,  4951,
01525     4952,  4953,  4956,  4957,  4958,  4961,  4966,  4973,  4974,  4977,
01526     4978,  4981,  4984,  4987,  4988,  4989,  4992,  4993,  4996,  4997,
01527     5001
01528 };
01529 #endif
01530 
01531 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01533    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01534 static const char *const yytname[] =
01535 {
01536   "\"end-of-input\"", "error", "$undefined", "keyword_class",
01537   "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
01538   "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
01539   "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
01540   "keyword_case", "keyword_when", "keyword_while", "keyword_until",
01541   "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
01542   "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
01543   "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
01544   "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
01545   "keyword_true", "keyword_false", "keyword_and", "keyword_or",
01546   "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
01547   "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
01548   "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
01549   "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
01550   "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
01551   "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
01552   "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
01553   "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
01554   "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
01555   "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
01556   "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
01557   "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
01558   "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
01559   "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
01560   "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
01561   "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
01562   "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
01563   "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
01564   "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
01565   "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
01566   "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
01567   "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
01568   "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
01569   "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
01570   "arg_value", "aref_args", "paren_args", "opt_paren_args",
01571   "opt_call_args", "call_args", "command_args", "@8", "block_arg",
01572   "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
01573   "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "@20", "@21",
01574   "@22", "@23", "@24", "$@25", "$@26", "primary_value", "k_begin", "k_if",
01575   "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
01576   "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
01577   "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
01578   "opt_block_args_tail", "block_param", "opt_block_param",
01579   "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@27",
01580   "@28", "@29", "f_larglist", "lambda_body", "do_block", "@30",
01581   "block_call", "method_call", "@31", "@32", "@33", "@34", "brace_block",
01582   "@35", "@36", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
01583   "opt_ensure", "literal", "strings", "string", "string1", "xstring",
01584   "regexp", "words", "word_list", "word", "symbols", "symbol_list",
01585   "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
01586   "xstring_contents", "regexp_contents", "string_content", "@37", "@38",
01587   "@39", "@40", "string_dvar", "symbol", "sym", "dsym", "numeric",
01588   "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
01589   "superclass", "$@41", "f_arglist", "args_tail", "opt_args_tail",
01590   "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
01591   "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
01592   "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
01593   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
01594   "singleton", "$@42", "assoc_list", "assocs", "assoc", "operation",
01595   "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
01596   "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01597 };
01598 #endif
01599 
01600 # ifdef YYPRINT
01601 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01602    token YYLEX-NUM.  */
01603 static const yytype_uint16 yytoknum[] =
01604 {
01605        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01606      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01607      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01608      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01609      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01610      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01611      315,   316,   317,   318,   319,   320,   130,   131,   132,   134,
01612      139,   140,   141,   138,   137,   321,   322,   142,   143,   128,
01613      129,   144,   145,   135,   136,   323,   324,   325,   326,   327,
01614      328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
01615      338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
01616      348,   349,   350,    61,    63,    58,    62,    60,   124,    94,
01617       38,    43,    45,    42,    47,    37,   351,    33,   126,   352,
01618      123,   125,    91,    46,    44,    96,    40,    41,    93,    59,
01619       32,    10
01620 };
01621 # endif
01622 
01623 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01624 static const yytype_uint16 yyr1[] =
01625 {
01626        0,   142,   144,   143,   145,   146,   146,   146,   146,   147,
01627      148,   147,   149,   150,   151,   151,   151,   151,   152,   153,
01628      152,   155,   154,   154,   154,   154,   154,   154,   154,   154,
01629      154,   154,   154,   154,   154,   154,   154,   154,   154,   154,
01630      154,   154,   154,   154,   154,   154,   156,   156,   157,   157,
01631      157,   157,   157,   157,   158,   159,   159,   160,   160,   162,
01632      161,   163,   164,   164,   164,   164,   164,   164,   164,   164,
01633      164,   164,   164,   165,   165,   166,   166,   167,   167,   167,
01634      167,   167,   167,   167,   167,   167,   167,   168,   168,   169,
01635      169,   170,   170,   171,   171,   171,   171,   171,   171,   171,
01636      171,   171,   172,   172,   172,   172,   172,   172,   172,   172,
01637      172,   173,   173,   174,   174,   174,   175,   175,   175,   175,
01638      175,   176,   176,   177,   177,   178,   179,   178,   180,   180,
01639      180,   180,   180,   180,   180,   180,   180,   180,   180,   180,
01640      180,   180,   180,   180,   180,   180,   180,   180,   180,   180,
01641      180,   180,   180,   180,   180,   180,   180,   180,   181,   181,
01642      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01643      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01644      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01645      181,   181,   181,   181,   181,   181,   181,   181,   181,   182,
01646      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01647      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01648      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01649      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01650      182,   183,   182,   182,   182,   184,   185,   185,   185,   185,
01651      186,   187,   187,   188,   188,   188,   188,   188,   189,   189,
01652      189,   189,   189,   191,   190,   192,   193,   193,   194,   194,
01653      194,   194,   195,   195,   195,   196,   196,   196,   196,   196,
01654      196,   196,   196,   196,   196,   196,   197,   196,   198,   196,
01655      199,   200,   196,   196,   196,   196,   196,   196,   196,   196,
01656      196,   196,   201,   196,   196,   196,   196,   196,   196,   196,
01657      196,   196,   202,   203,   196,   204,   205,   196,   196,   196,
01658      206,   207,   196,   208,   196,   209,   210,   196,   211,   196,
01659      212,   196,   213,   214,   196,   196,   196,   196,   196,   215,
01660      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
01661      226,   227,   227,   227,   228,   228,   229,   229,   230,   230,
01662      231,   231,   232,   232,   233,   233,   234,   234,   234,   234,
01663      234,   234,   234,   234,   234,   235,   235,   235,   235,   236,
01664      236,   237,   237,   237,   237,   237,   237,   237,   237,   237,
01665      237,   237,   237,   237,   237,   237,   238,   238,   239,   239,
01666      239,   240,   240,   241,   241,   242,   242,   244,   245,   246,
01667      243,   247,   247,   248,   248,   250,   249,   251,   251,   251,
01668      251,   252,   253,   252,   254,   252,   252,   255,   252,   256,
01669      252,   252,   252,   252,   258,   257,   259,   257,   260,   261,
01670      261,   262,   262,   263,   263,   263,   264,   264,   265,   265,
01671      266,   266,   266,   267,   268,   268,   268,   269,   270,   271,
01672      272,   272,   273,   273,   274,   274,   275,   275,   276,   276,
01673      277,   277,   278,   278,   279,   279,   280,   280,   281,   281,
01674      282,   282,   283,   283,   284,   285,   284,   286,   287,   288,
01675      284,   289,   289,   289,   289,   290,   291,   291,   291,   291,
01676      292,   293,   293,   293,   293,   294,   294,   294,   294,   294,
01677      295,   295,   295,   295,   295,   295,   295,   296,   296,   297,
01678      297,   298,   298,   299,   300,   299,   299,   301,   301,   302,
01679      302,   302,   302,   303,   303,   304,   304,   304,   304,   304,
01680      304,   304,   304,   304,   304,   304,   304,   304,   304,   304,
01681      305,   305,   305,   305,   306,   306,   307,   307,   308,   308,
01682      309,   310,   311,   311,   312,   312,   313,   313,   314,   314,
01683      315,   316,   317,   317,   318,   318,   319,   319,   320,   320,
01684      321,   321,   322,   323,   323,   324,   325,   324,   326,   326,
01685      327,   327,   328,   328,   328,   329,   329,   329,   330,   330,
01686      330,   330,   331,   331,   331,   332,   332,   333,   333,   334,
01687      334,   335,   336,   337,   337,   337,   338,   338,   339,   339,
01688      340
01689 };
01690 
01691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01692 static const yytype_uint8 yyr2[] =
01693 {
01694        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01695        0,     5,     4,     2,     1,     1,     3,     2,     1,     0,
01696        5,     0,     4,     3,     3,     3,     2,     3,     3,     3,
01697        3,     3,     4,     1,     3,     3,     6,     5,     5,     5,
01698        5,     3,     3,     3,     3,     1,     3,     3,     1,     3,
01699        3,     3,     2,     1,     1,     1,     1,     1,     4,     0,
01700        5,     1,     2,     3,     4,     5,     4,     5,     2,     2,
01701        2,     2,     2,     1,     3,     1,     3,     1,     2,     3,
01702        5,     2,     4,     2,     4,     1,     3,     1,     3,     2,
01703        3,     1,     3,     1,     1,     4,     3,     3,     3,     3,
01704        2,     1,     1,     1,     4,     3,     3,     3,     3,     2,
01705        1,     1,     1,     2,     1,     3,     1,     1,     1,     1,
01706        1,     1,     1,     1,     1,     1,     0,     4,     1,     1,
01707        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01708        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01709        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01710        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01711        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01712        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01713        1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
01714        5,     3,     5,     6,     5,     5,     5,     5,     4,     3,
01715        3,     3,     3,     3,     3,     3,     3,     3,     4,     4,
01716        2,     2,     3,     3,     3,     3,     3,     3,     3,     3,
01717        3,     3,     3,     3,     3,     2,     2,     3,     3,     3,
01718        3,     0,     4,     6,     1,     1,     1,     2,     4,     2,
01719        3,     1,     1,     1,     1,     2,     4,     2,     1,     2,
01720        2,     4,     1,     0,     2,     2,     2,     1,     1,     2,
01721        3,     4,     3,     4,     2,     1,     1,     1,     1,     1,
01722        1,     1,     1,     1,     1,     1,     0,     4,     0,     3,
01723        0,     0,     5,     3,     3,     2,     3,     3,     1,     4,
01724        3,     1,     0,     6,     4,     3,     2,     1,     2,     2,
01725        6,     6,     0,     0,     7,     0,     0,     7,     5,     4,
01726        0,     0,     9,     0,     6,     0,     0,     8,     0,     5,
01727        0,     6,     0,     0,     9,     1,     1,     1,     1,     1,
01728        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01729        1,     1,     1,     2,     1,     1,     1,     5,     1,     2,
01730        1,     1,     1,     3,     1,     3,     1,     4,     6,     3,
01731        5,     2,     4,     1,     3,     4,     2,     2,     1,     2,
01732        0,     6,     8,     4,     6,     4,     2,     6,     2,     4,
01733        6,     2,     4,     2,     4,     1,     1,     1,     3,     1,
01734        4,     1,     4,     1,     3,     1,     1,     0,     0,     0,
01735        5,     4,     1,     3,     3,     0,     5,     2,     4,     5,
01736        5,     2,     0,     5,     0,     5,     3,     0,     4,     0,
01737        4,     2,     1,     4,     0,     5,     0,     5,     5,     1,
01738        1,     6,     1,     1,     1,     1,     2,     1,     2,     1,
01739        1,     1,     1,     1,     1,     1,     2,     3,     3,     3,
01740        3,     3,     0,     3,     1,     2,     3,     3,     0,     3,
01741        3,     3,     3,     3,     0,     3,     0,     3,     0,     2,
01742        0,     2,     0,     2,     1,     0,     3,     0,     0,     0,
01743        6,     1,     1,     1,     1,     2,     1,     1,     1,     1,
01744        3,     1,     1,     2,     2,     1,     1,     1,     1,     1,
01745        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01746        1,     1,     1,     1,     0,     4,     2,     3,     2,     4,
01747        2,     2,     1,     2,     0,     6,     8,     4,     6,     4,
01748        6,     2,     4,     6,     2,     4,     2,     4,     1,     0,
01749        1,     1,     1,     1,     1,     1,     1,     3,     1,     3,
01750        2,     2,     1,     3,     1,     3,     1,     1,     2,     1,
01751        3,     3,     1,     3,     1,     3,     1,     1,     2,     1,
01752        1,     1,     2,     2,     1,     1,     0,     4,     1,     2,
01753        1,     3,     3,     2,     2,     1,     1,     1,     1,     1,
01754        1,     1,     1,     1,     1,     1,     1,     0,     1,     0,
01755        1,     2,     2,     0,     1,     1,     1,     1,     1,     2,
01756        0
01757 };
01758 
01759 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
01760    Performed when YYTABLE doesn't specify something else to do.  Zero
01761    means the default is an error.  */
01762 static const yytype_uint16 yydefact[] =
01763 {
01764        2,     0,     0,     1,     0,   347,   348,   349,     0,   340,
01765      341,   342,   345,   343,   344,   346,   335,   336,   337,   338,
01766      298,   263,   263,   511,   510,   512,   513,   609,     0,   609,
01767       10,     0,   515,   514,   516,   595,   597,   507,   506,   596,
01768      509,   501,   502,   454,   521,   522,     0,     0,     0,     0,
01769      290,   620,   620,    85,   407,   480,   478,   480,   482,   462,
01770      474,   468,   476,     0,     0,     0,     3,   607,     6,     9,
01771       33,    45,    48,    56,   263,    55,     0,    73,     0,    77,
01772       87,     0,    53,   244,     0,   286,     0,     0,   312,   315,
01773      607,     0,     0,     0,     0,    57,   307,   275,   276,   453,
01774      455,   277,   278,   279,   281,   280,   282,   451,   452,   450,
01775      517,   518,   283,     0,   284,    61,     5,     8,   168,   179,
01776      169,   192,   165,   185,   175,   174,   195,   196,   190,   173,
01777      172,   167,   193,   197,   198,   177,   166,   180,   184,   186,
01778      178,   171,   187,   194,   189,   188,   181,   191,   176,   164,
01779      183,   182,   163,   170,   161,   162,   158,   159,   160,   116,
01780      118,   117,   153,   154,   149,   131,   132,   133,   140,   137,
01781      139,   134,   135,   155,   156,   141,   142,   146,   150,   136,
01782      138,   128,   129,   130,   143,   144,   145,   147,   148,   151,
01783      152,   157,   121,   123,   125,    26,   119,   120,   122,   124,
01784        0,     0,     0,     0,     0,     0,     0,     0,   258,     0,
01785      245,   268,    71,   262,   620,     0,   517,   518,     0,   284,
01786      620,   590,    72,    70,   609,    69,     0,   620,   431,    68,
01787      609,   610,     0,     0,    21,   241,     0,     0,   335,   336,
01788      298,   301,   432,     0,   220,     0,   221,   295,     0,    19,
01789        0,     0,   607,    15,    18,   609,    75,    14,   609,     0,
01790        0,   613,   613,   246,     0,     0,   613,   588,   609,     0,
01791        0,     0,    83,   339,     0,    93,    94,   101,   309,   408,
01792      498,   497,   499,   496,     0,   495,     0,     0,     0,     0,
01793        0,     0,     0,     0,     0,     0,     0,   503,   504,    52,
01794      235,   236,   616,   617,     4,   618,   608,     0,     0,     0,
01795        0,     0,     0,     0,   436,   434,   421,    62,   306,   415,
01796      417,     0,    89,     0,    81,    78,     0,     0,     0,     0,
01797        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01798        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01799        0,     0,     0,   429,   620,   427,     0,    54,     0,     0,
01800        0,     0,   607,     0,   608,     0,   361,   360,     0,     0,
01801      517,   518,   284,   111,   112,     0,     0,   114,     0,     0,
01802      517,   518,   284,   328,   188,   181,   191,   176,   158,   159,
01803      160,   116,   117,   586,   330,   585,     0,   606,   605,     0,
01804      308,   456,     0,     0,   126,   593,   295,   269,   594,   265,
01805        0,     0,     0,   259,   267,   429,   620,   427,     0,     0,
01806        0,   260,   609,     0,   300,   264,   609,   254,   620,   620,
01807      253,   609,   305,    51,    23,    25,    24,     0,   302,     0,
01808        0,     0,   429,   427,     0,    17,     0,   609,   293,    13,
01809      608,    74,   289,   291,   296,   615,   614,   247,   615,   249,
01810      297,   589,     0,   100,   503,   504,    91,    86,     0,   429,
01811      620,   427,   549,   484,   487,   485,   500,   481,   457,   479,
01812      458,   459,   483,   460,   461,     0,   464,   470,     0,   471,
01813      466,   467,     0,   472,     0,   473,     0,     0,   619,     7,
01814       27,    28,    29,    30,    31,    49,    50,   620,   620,    59,
01815       63,   620,     0,    34,    43,     0,    44,   609,     0,    79,
01816       90,    47,    46,     0,   199,   268,    42,   217,   225,   230,
01817      231,   232,   227,   229,   239,   240,   233,   234,   210,   211,
01818      237,   238,   609,   226,   228,   222,   223,   224,   212,   213,
01819      214,   215,   216,   598,   600,   599,   601,     0,   263,   426,
01820      609,   598,   600,   599,   601,     0,   263,     0,   620,   352,
01821        0,   351,     0,     0,     0,     0,     0,     0,   295,   429,
01822      620,   427,   320,   325,   111,   112,   113,     0,   524,   323,
01823      523,   429,   620,   427,     0,     0,   549,   332,   598,   599,
01824      263,    35,   201,    41,   209,     0,   199,   592,     0,   270,
01825      266,   620,   598,   599,   609,   598,   599,   591,   299,   611,
01826      250,   255,   257,   304,    22,     0,   242,     0,    32,   424,
01827      422,   208,     0,    76,    16,   609,   613,     0,    84,    97,
01828       99,   609,   598,   599,   555,   552,   551,   550,   553,     0,
01829      566,     0,   577,   567,   581,   580,   576,   549,   409,   548,
01830      412,   554,   556,   558,   534,   564,   620,   569,   620,   574,
01831      534,   579,   534,     0,   532,   488,     0,   463,   465,   475,
01832      469,   477,   218,   219,   399,   609,     0,   397,   396,     0,
01833      620,     0,   274,     0,    88,    82,     0,     0,     0,     0,
01834        0,     0,   430,    66,     0,     0,   433,     0,     0,   428,
01835       64,   620,   350,   287,   620,   620,   442,   620,   353,   620,
01836      355,   313,   354,   316,     0,     0,   319,   602,   294,   609,
01837      598,   599,     0,     0,   526,     0,     0,   111,   112,   115,
01838      609,     0,   609,   549,     0,     0,     0,   252,   418,    58,
01839      251,     0,   127,   271,   261,     0,     0,   433,     0,     0,
01840      620,   609,    11,     0,   292,   248,    92,    95,     0,   560,
01841      555,     0,   373,   364,   366,   609,   362,   609,     0,     0,
01842      541,     0,   530,   584,   568,     0,   531,     0,   544,   578,
01843        0,   546,   582,   489,   491,   492,   493,   486,   494,   555,
01844        0,   395,   609,     0,   380,   562,   620,   620,   572,   380,
01845      380,   378,   401,     0,     0,     0,     0,     0,   272,    80,
01846      200,     0,    40,   206,    39,   207,    67,   425,   612,     0,
01847       37,   204,    38,   205,    65,   423,   443,   444,   620,   445,
01848        0,   620,   358,     0,     0,   356,     0,     0,     0,   318,
01849        0,     0,   433,     0,   326,     0,     0,   433,   329,   587,
01850      609,     0,   528,   333,   419,   420,   202,     0,   256,   303,
01851       20,   570,   609,     0,   371,     0,   557,     0,     0,     0,
01852      410,   533,   559,   534,   534,   565,   620,   583,   534,   575,
01853      534,   534,     0,     0,     0,   561,     0,   398,   386,   388,
01854        0,   376,   377,     0,   391,     0,   393,     0,   437,   435,
01855        0,   416,   273,   243,    36,   203,     0,     0,   447,   359,
01856        0,    12,   449,     0,   310,   311,     0,     0,   270,   620,
01857      321,     0,   525,   324,   527,   331,   549,   363,   374,     0,
01858      369,   365,   411,     0,     0,     0,   537,     0,   539,   529,
01859        0,   545,     0,   542,   547,     0,   571,   295,   429,   400,
01860      379,   380,   380,   563,   620,   380,   573,   380,   380,   405,
01861      609,   403,   406,    60,     0,   446,     0,   102,   103,   110,
01862        0,   448,     0,   314,   317,   439,   440,   438,     0,     0,
01863        0,     0,   372,     0,   367,   414,   413,   534,   534,   534,
01864      534,   490,   602,   294,     0,   383,     0,   385,   375,     0,
01865      392,     0,   389,   394,     0,   402,   109,   429,   620,   427,
01866      620,   620,     0,   327,     0,   370,     0,   538,     0,   535,
01867      540,   543,   380,   380,   380,   380,   404,   602,   108,   609,
01868      598,   599,   441,   357,   322,   334,   368,   534,   384,     0,
01869      381,   387,   390,   433,   536,   380,   382
01870 };
01871 
01872 /* YYDEFGOTO[NTERM-NUM].  */
01873 static const yytype_int16 yydefgoto[] =
01874 {
01875       -1,     1,     2,    66,    67,    68,   236,   567,   568,   252,
01876      253,   446,   254,   437,    70,    71,   358,    72,    73,   510,
01877      690,   243,    75,    76,   255,    77,    78,    79,   467,    80,
01878      209,   377,   378,   192,   193,   194,   195,   605,   556,   197,
01879       82,   439,   211,   260,   228,   748,   426,   427,   225,   226,
01880      213,   413,   428,   516,    83,   356,   258,   259,   635,   625,
01881      360,   847,   361,   848,   732,   988,   736,   733,   931,   594,
01882      596,   746,   936,   245,    85,    86,    87,    88,    89,    90,
01883       91,    92,    93,    94,   713,   570,   721,   844,   845,   369,
01884      773,   774,   775,   960,   899,   802,   686,   687,   803,   970,
01885      971,   278,   279,   472,   778,   658,   880,   320,   511,    95,
01886       96,   711,   704,   565,   557,   318,   508,   507,   577,   987,
01887      715,   838,   917,   921,    97,    98,    99,   100,   101,   102,
01888      103,   290,   485,   104,   294,   105,   106,   292,   296,   286,
01889      284,   288,   477,   676,   675,   793,   892,   797,   107,   285,
01890      108,   109,   216,   217,   112,   218,   219,   589,   735,   744,
01891      881,   780,   745,   661,   662,   663,   664,   665,   805,   806,
01892      666,   667,   668,   669,   808,   809,   670,   671,   672,   673,
01893      674,   782,   396,   595,   265,   429,   221,   115,   629,   559,
01894      399,   304,   423,   424,   706,   457,   571,   364,   257
01895 };
01896 
01897 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01898    STATE-NUM.  */
01899 #define YYPACT_NINF -808
01900 static const yytype_int16 yypact[] =
01901 {
01902     -808,   134,  2562,  -808,  7195,  -808,  -808,  -808,  6718,  -808,
01903     -808,  -808,  -808,  -808,  -808,  -808,  7308,  7308,  -808,  -808,
01904     7308,  3884,  3479,  -808,  -808,  -808,  -808,   455,  6585,    17,
01905     -808,    60,  -808,  -808,  -808,  2804,  3614,  -808,  -808,  2939,
01906     -808,  -808,  -808,  -808,  -808,  -808,  8664,  8664,   140,  4955,
01907      462,  7647,  7986,  6977,  -808,  6452,  -808,  -808,  -808,   103,
01908      115,   126,   206,   117,  8777,  8664,  -808,   -25,  -808,  1007,
01909     -808,   322,  -808,  -808,   141,   372,   352,  -808,   337,  9003,
01910     -808,   379,  2918,   247,   278,  -808,  8890,  8890,  -808,  -808,
01911     5842,  9112,  9221,  9330,  6318,    33,    65,  -808,  -808,   410,
01912     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01913      205,   409,  -808,   441,   433,  -808,  -808,  -808,  -808,  -808,
01914     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01915     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01916     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01917     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01918     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01919     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01920     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01921     -808,  -808,  -808,  -808,  -808,   396,  -808,  -808,  -808,  -808,
01922      427,  8664,   519,  5094,  8664,  8664,  8664,  8664,  -808,   468,
01923     2918,   500,  -808,  -808,   463,   304,    22,   344,   517,   363,
01924      479,  -808,  -808,  -808,  5729,  -808,  7308,  7308,  -808,  -808,
01925     5955,  -808,  8890,   498,  -808,   482,   491,  5233,  -808,  -808,
01926     -808,   497,   499,   141,  -808,   361,   570,   458,  7421,  -808,
01927     4955,   505,   -25,  -808,  1007,    17,   538,  -808,    17,  8890,
01928      515,   188,   318,  -808,   500,   523,   318,  -808,    17,   617,
01929      338,  9439,   540,  -808,   474,   572,   613,   674,  -808,  -808,
01930     -808,  -808,  -808,  -808,   522,  -808,   601,   669,   284,   576,
01931      752,   577,    58,   582,   759,   584,    68,   609,   612,  -808,
01932     -808,  -808,  -808,  -808,  -808,  -808,  6068,  8890,  8890,  8890,
01933     8890,  7421,  8890,  8890,  -808,  -808,  -808,   588,  -808,  -808,
01934     -808,  8099,  -808,  4955,  7086,   561,  8099,  8664,  8664,  8664,
01935     8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,
01936     8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,
01937     8664,  8664,  8664,  2012,  7308,  9718,  4312,   322,   109,   109,
01938     8890,  8890,   -25,   689,   563,   651,  -808,  -808,   685,   691,
01939       53,    57,   100,   328,   393,  8890,   568,  -808,   199,   708,
01940     -808,  -808,  -808,  -808,    55,   223,   249,   279,   283,   301,
01941      316,   384,   417,  -808,  -808,  -808,    33,  -808,  -808,  9795,
01942     -808,  -808,  8777,  8777,  -808,  -808,   414,  -808,  -808,  -808,
01943     8664,  8664,  7534,  -808,  -808,  9872,  7308,  9949,  8664,  8664,
01944     7760,  -808,    17,   595,  -808,  -808,    17,  -808,   580,   599,
01945     -808,    61,  -808,  -808,  -808,  -808,  -808,  6718,  -808,  8664,
01946     5364,   604,  9872,  9949,  8664,  1007,   607,    17,  -808,  -808,
01947     6181,   618,  -808,   322,  -808,  7873,  -808,  -808,  7986,  -808,
01948     -808,  -808,   482,   769,  -808,  -808,  -808,   622,  9439, 10026,
01949     7308, 10103,  1417,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01950     -808,  -808,  -808,  -808,  -808,   244,  -808,  -808,   611,  -808,
01951     -808,  -808,   347,  -808,   623,  -808,  8664,  8664,  -808,  -808,
01952     -808,  -808,  -808,  -808,  -808,  -808,  -808,    51,    51,  -808,
01953     -808,    51,  8664,  -808,   628,   634,  -808,    17,  9439,   655,
01954     -808,  -808,  -808,   678,  1866,  -808,  -808,   570,  2240,  2240,
01955     2240,  2240,   727,   727,  3323,  3188,  2240,  2240,  3053,  3053,
01956      415,   415,  1674,   727,   727,   907,   907,   660,    40,    40,
01957      570,   570,   570,  4019,  3074,  4154,  3209,   499,   661,  -808,
01958       17,   535,  -808,   688,  -808,   499,  3749,   737,   790,  -808,
01959     4451,   799,  4729,    66,    66,   689,  8212,   737,   147, 10180,
01960     7308, 10257,  -808,   322,  -808,   769,  -808,   -25,  -808,  -808,
01961     -808, 10334,  7308,  9795,  4312,  8890,  1538,  -808,  -808,  -808,
01962     4173,  -808,  2648,  -808,  2918,  6718,  2783,  -808,  8664,   500,
01963     -808,   479,  2669,  3344,    17,   420,   444,  -808,  -808,  -808,
01964     -808,  7534,  7760,  -808,  -808,  8890,  2918,   672,  -808,  -808,
01965     -808,  2918,  5364,     2,  -808,    17,   318,  9439,   622,   701,
01966      469,    17,   207,   224,   711,  -808,  -808,  -808,  -808,  8664,
01967     -808,   947,  -808,  -808,  -808,  -808,  -808,  1789,  -808,  -808,
01968     -808,  -808,  -808,  -808,   680,  -808,   687,   773,   694,  -808,
01969      698,   783,   704,   791,  -808,  -808,   834,  -808,  -808,  -808,
01970     -808,  -808,   570,   570,  -808,  1322,  5503,  -808,  -808,  5233,
01971       51,  5503,   721,  8325,  -808,   622,  9439,  8777,  8664,   741,
01972     8777,  8777,  -808,   588,   499,   722,   818,  8777,  8777,  -808,
01973      588,   499,  -808,  -808,  8438,   827,  -808,   597,  -808,   827,
01974     -808,  -808,  -808,  -808,   737,    70,  -808,    67,   136,    17,
01975      148,   149,  8890,   -25,  -808,  8890,  4312,   701,   469,  -808,
01976       17,   737,    61,  1789,  4312,   -25,  6851,  -808,    65,   372,
01977     -808,  8664,  -808,  -808,  -808,  8664,  8664,   466,  8664,  8664,
01978      731,    61,  -808,   736,  -808,  -808,  -808,   567,  8664,  -808,
01979     -808,   947,   350,  -808,   738,    17,  -808,    17,    72,  1789,
01980     -808,    42,  -808,  -808,  -808,   272,  -808,  1789,  -808,  -808,
01981      892,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,   762,
01982     9548,  -808,    17,   764,   746,  -808,   751,   694,  -808,   758,
01983      760,  -808,   761,   893,   775,  5233,   899,  8664,   776,   622,
01984     2918,  8664,  -808,  2918,  -808,  2918,  -808,  -808,  -808,  8777,
01985     -808,  2918,  -808,  2918,  -808,  -808,   628,  -808,   826,  -808,
01986     4842,   909,  -808,  8890,   737,  -808,   737,  5503,  5503,  -808,
01987     8551,  4590,   155,    66,  -808,   -25,   737,  -808,  -808,  -808,
01988       17,   737,  -808,  -808,  -808,  -808,  2918,  8664,  7760,  -808,
01989     -808,  -808,    17,  1011,   789,  1003,  -808,   793,  5503,  5233,
01990     -808,  -808,  -808,   798,   803,  -808,   694,  -808,   804,  -808,
01991      811,   804,  5616,  9548,   877,   792,   808,  -808,  1910,  -808,
01992      490,  -808,  -808,  1910,  -808,  1368,  -808,  1032,  -808,  -808,
01993      820,  -808,   819,  2918,  -808,  2918,  9657,   109,  -808,  -808,
01994     5503,  -808,  -808,   109,  -808,  -808,   737,   737,  -808,   130,
01995     -808,  4312,  -808,  -808,  -808,  -808,  1538,  -808,   821,  1011,
01996      434,  -808,  -808,   944,   832,  1789,  -808,   892,  -808,  -808,
01997      892,  -808,   892,  -808,  -808,   850,   792,  -808, 10411,  -808,
01998     -808,   830,   831,  -808,   694,   835,  -808,   837,   835,  -808,
01999      443,  -808,  -808,  -808,   910,  -808,   796,   572,   613,   674,
02000     4312,  -808,  4451,  -808,  -808,  -808,  -808,  -808,  5503,   737,
02001     4312,  1011,   821,  1011,   838,  -808,  -808,   804,   839,   804,
02002      804,  -808,   840,   841,  1910,  -808,  1368,  -808,  -808,  1368,
02003     -808,  1368,  -808,  -808,  1032,  -808,   769, 10488,  7308, 10565,
02004      790,   597,   737,  -808,   737,   821,  1011,  -808,   892,  -808,
02005     -808,  -808,   835,   844,   835,   835,  -808,    74,   469,    17,
02006      146,   158,  -808,  -808,  -808,  -808,   821,   804,  -808,  1368,
02007     -808,  -808,  -808,   176,  -808,   835,  -808
02008 };
02009 
02010 /* YYPGOTO[NTERM-NUM].  */
02011 static const yytype_int16 yypgoto[] =
02012 {
02013     -808,  -808,  -808,  -363,  -808,    27,  -808,  -550,   -21,  -808,
02014      518,  -808,    15,  -808,  -301,   -51,   -86,    41,  -808,  -268,
02015     -808,   413,    -7,   888,  -153,    -4,   -73,  -808,  -416,     7,
02016     1571,  -315,   889,   -53,  -808,    -5,  -808,  -808,    98,  -808,
02017      870,  -808,   735,  -808,   -44,   275,  -340,    87,   -11,  -808,
02018     -386,  -188,     4,  -311,   -20,  -808,  -808,  -808,  -808,  -808,
02019     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
02020     -808,  -808,  -808,    64,  -808,  -808,  -808,  -808,  -808,  -808,
02021     -808,  -808,  -808,  -808,   154,  -347,  -526,   -34,  -645,  -808,
02022     -785,  -779,   221,   309,   374,  -808,  -446,  -808,  -665,  -808,
02023      -18,  -808,  -808,  -808,  -808,  -808,  -808,   248,  -808,  -808,
02024     -808,  -808,  -808,  -808,  -808,   -93,  -808,  -808,  -535,  -808,
02025       -6,  -808,  -808,  -808,  -808,  -808,  -808,   918,  -808,  -808,
02026     -808,  -808,   712,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
02027      963,  -808,  -142,  -808,  -808,  -808,  -808,  -808,    10,  -808,
02028       14,  -808,  1081,  1361,   928,  1531,  1552,  -808,  -808,    89,
02029     -464,  -372,  -415,  -783,  -518,  -723,   234,   242,   133,  -808,
02030     -808,  -808,   289,  -708,  -807,   128,   255,  -808,  -638,  -808,
02031      228,  -622,  -808,  -808,  -808,    69,  -383,  -808,  -348,  -808,
02032      639,   -26,     0,    48,  -598,  -208,    21,   -14,    -2
02033 };
02034 
02035 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
02036    positive, shift that token.  If negative, reduce the rule which
02037    number is the opposite.  If YYTABLE_NINF, syntax error.  */
02038 #define YYTABLE_NINF -621
02039 static const yytype_int16 yytable[] =
02040 {
02041      116,   359,   283,   400,   362,   558,   325,   566,   659,   208,
02042      208,   229,   572,   208,   560,   526,   757,    69,   198,    69,
02043      214,   214,   199,   234,   214,   521,   610,   232,   251,   235,
02044      316,   117,   421,   273,   610,   357,   357,   617,   198,   357,
02045      724,   394,   199,   767,   741,   256,   786,   810,   723,   263,
02046      267,   600,   638,   306,   459,   261,   882,   660,   461,   273,
02047      272,   586,   689,   317,   363,   691,    84,   558,    84,   566,
02048      841,   273,   273,   273,   846,   617,   614,   627,  -102,   889,
02049      215,   215,  -103,   569,   215,   220,   220,  -106,   305,   220,
02050      941,   314,  -106,   720,   938,   630,   966,   447,   312,   313,
02051      649,   878,   695,   212,   222,   299,   196,   223,   327,  -519,
02052      650,   305,   877,    84,   302,   -74,   303,   274,   397,   488,
02053      262,   266,   569,   630,   972,  -110,   196,   684,   215,   494,
02054      641,   852,   659,   776,     3,  -102,   -88,   896,   653,   654,
02055     -511,   884,   857,   274,   479,   840,   482,   576,   486,   890,
02056      215,   215,   486,   196,   215,   368,   379,   379,   231,  -105,
02057      992,  -108,   655,   350,   351,   352,   398,   314,   489,   685,
02058      517,  -107,  -109,  -105,  -107,   882,   297,   298,   495,   431,
02059     -104,   433,   251,   879,   901,   902,   856,   -93,  -511,  -104,
02060      237,   -94,   196,   659,   861,   315,   247,   966,   466,   316,
02061      587,   -97,   231,  -598,   850,   302,   941,   303,   453,   302,
02062     -598,   303,   414,  -106,  1025,  -106,   441,   208,   414,   208,
02063      208,   500,   501,   502,   503,   430,   449,   882,   214,   251,
02064      214,   972,   -96,   630,  -101,   610,   610,   889,   450,   617,
02065      729,   421,   777,   289,   815,   630,   256,  1046,   302,   -98,
02066      303,   273,   740,   776,   874,   291,   357,   357,   357,   357,
02067      962,   505,   506,   445,   949,   967,   293,    84,   462,   763,
02068      -99,   315,  -599,   305,   573,   574,   739,   227,   432,   659,
02069      819,  -100,   -96,   -98,   985,  -105,   882,  -105,   215,   -95,
02070      215,   215,  -519,   220,   215,   220,   215,  -107,   788,  -107,
02071      791,    84,   251,   451,   273,   473,   452,   998,  -510,   357,
02072      357,   422,    84,   425,    84,  -104,   588,  -104,  -102,   256,
02073      -96,    69,   455,   215,   583,   515,   504,   930,   860,   456,
02074      515,   519,  -339,   499,  -512,   274,   575,   -98,   302,   -93,
02075      303,   -96,  1008,   678,   -96,   473,   295,   208,   -96,   481,
02076      678,   474,   430,   475,  -595,   776,  -510,   776,   -98,   312,
02077      313,   -98,   513,   353,  -513,   -98,  1033,   522,  -515,   654,
02078       84,   215,   215,   215,   215,    84,   215,   215,   851,  -339,
02079     -339,   989,  -512,   305,   677,   215,  -514,    84,   274,   415,
02080      215,   474,   655,   475,   986,   466,   521,   464,   465,   590,
02081      319,  -516,   770,   837,   645,   646,   647,   648,   473,   208,
02082      354,   355,  -513,  -505,   430,    74,  -515,    74,   215,  -596,
02083       84,   776,   994,   754,   215,   215,   414,   414,   765,    74,
02084       74,  -520,   624,    74,  -514,   826,   416,   417,   116,   215,
02085     1024,  1053,   834,   601,   603,   466,   442,   198,   273,  -516,
02086      419,   199,   458,   564,   474,    69,   475,  -103,  -595,   456,
02087     -505,  -505,    74,   208,  -595,   321,   215,   215,   430,  -505,
02088      618,   322,   659,   776,   620,   776,  -110,    74,  -508,   623,
02089      215,   611,   610,   327,   873,   617,   770,   680,   645,   646,
02090      647,   648,   326,   416,   443,   633,  -520,   564,   273,    74,
02091       74,   444,  -508,    74,    84,   688,   688,   758,   776,   688,
02092       56,   946,   948,   702,    84,   564,   951,  -505,   953,   954,
02093      403,   709,  -103,  -596,   636,  -508,  -508,  -109,   402,  -596,
02094      404,   759,   274,  -105,   215,   196,   348,   349,   350,   351,
02095      352,   564,   699,   -94,   742,   444,  -110,   703,   800,   717,
02096     -508,   719,   434,   867,  -294,   710,   747,  -107,   650,   469,
02097      705,   435,   436,   230,   766,   694,   716,  -101,   993,   564,
02098      980,  -109,   754,   208,   761,   406,   982,  1014,   430,  -104,
02099      725,   410,   274,   473,   231,   208,   653,   654,   411,   749,
02100      430,   230,  -100,  -433,   722,   722,   231,   412,   750,  -288,
02101      752,  -294,  -294,  -288,   418,  -599,   470,   471,   734,   414,
02102      655,   843,   840,   420,   705,   198,    74,   273,   438,   199,
02103      584,   440,   707,   466,   585,  1027,  1029,  1030,  1031,   474,
02104      116,   475,   476,   224,    84,   227,    84,    74,   327,    74,
02105       74,   705,   448,    74,   215,    74,   853,    69,  -105,   855,
02106       74,   -73,  -433,   454,   460,   864,   215,  -517,    84,   215,
02107      827,    74,   473,    74,   783,   813,   783,   747,   814,   -96,
02108      816,   630,    74,   463,   468,  1054,   273,   496,  1039,   564,
02109      497,   357,   509,   764,   357,   812,   483,   487,   688,   215,
02110      760,   564,   490,   863,   493,   520,    84,  -433,  -518,  -433,
02111     -433,   274,   498,   196,  -517,  -517,   576,   578,   474,   750,
02112      475,   478,   839,   842,   621,   842,   582,   842,   515,    74,
02113       74,    74,    74,    74,    74,    74,    74,  -602,   327,   705,
02114      473,   726,   619,   622,    74,   628,    74,   632,   522,    74,
02115      705,   822,   824,   340,   341,  -518,  -518,   712,   830,   832,
02116       84,   679,   -88,    84,   854,    84,   637,   923,   414,  -284,
02117      274,   215,  -268,   681,   215,   215,   862,    74,   693,    74,
02118      579,   215,   215,    74,    74,   708,   474,   812,   475,   480,
02119      273,   348,   349,   350,   351,   352,  -602,   264,    74,   696,
02120      859,   697,   357,   591,   910,   327,   215,  -424,   714,   215,
02121       84,  -107,   812,   762,   783,   783,  -284,  -284,    84,   869,
02122      340,   341,   718,   473,   779,    74,    74,   580,   581,   919,
02123      473,   781,   -98,   876,   768,   784,   926,   927,   785,    74,
02124      929,  -602,   787,  -602,  -602,   789,   918,  -598,   790,   922,
02125      592,   593,   840,   792,   196,   345,   346,   347,   348,   349,
02126      350,   351,   352,    74,  -295,  -269,   821,   943,   944,   474,
02127      828,   475,   484,    74,   895,   868,   474,   870,   475,   491,
02128      914,   955,   875,   273,   722,   893,   932,   958,   849,    84,
02129      898,  1017,   897,    74,   783,   900,   210,   210,   794,   795,
02130      210,   796,   903,   215,   905,   858,   273,    44,    45,   981,
02131      907,  -295,  -295,   908,    84,   829,   909,   215,   934,   911,
02132     -270,    84,    84,   811,   916,    84,   244,   246,   920,   804,
02133      937,   210,   210,   939,   592,   593,   959,   842,  1018,  1019,
02134      942,  -104,   945,   957,   300,   301,   405,   947,   950,   407,
02135      408,   409,    84,    84,   770,   952,   645,   646,   647,   648,
02136      649,   973,   -95,  -271,   995,   991,    84,   956,  1001,  1020,
02137      650,  1021,   783,   996,  1004,  1006,  1016,  1022,   634,  1009,
02138     1015,  1011,  1026,  1028,   807,   327,  -598,  -599,  1049,   366,
02139      976,   651,   383,    74,    84,    74,   835,  1043,   653,   654,
02140      340,   341,   872,    74,   801,    84,  1036,   865,   924,   770,
02141      925,   645,   646,   647,   648,    74,   492,    74,    74,   887,
02142      933,   208,   655,   887,  1042,   935,   430,   401,   716,   842,
02143      287,   888,   395,   885,   891,   990,   961,   347,   348,   349,
02144      350,   351,   352,   963,   883,   597,   771,     0,    74,   705,
02145        0,     0,   772,     0,    84,    74,    84,   307,   308,   309,
02146      310,   311,    84,     0,    84,   770,   514,   645,   646,   647,
02147      648,   525,     0,   770,     0,   645,   646,   647,   648,     0,
02148      886,   210,     0,     0,   210,   210,   210,   300,     0,     0,
02149      983,   984,   215,   110,   969,   110,   645,   646,   647,   648,
02150        0,     0,   771,     0,   210,     0,   210,   210,   940,    74,
02151      771,     0,    74,     0,    74,     0,     0,     0,     0,     0,
02152       74,     0,     0,    74,    74,     0,     0,   564,     0,     0,
02153       74,    74,     0,     0,     0,     0,   811,     0,   887,     0,
02154      110,   811,     0,   811,   275,     0,     0,   965,     0,   968,
02155        0,     0,     0,  1023,     0,    74,   607,   609,    74,    74,
02156        0,     0,     0,     0,     0,   264,     0,    74,     0,     0,
02157      275,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02158        0,     0,   370,   380,   380,   380,  1044,     0,  1045,   997,
02159        0,   999,     0,   904,   906,     0,  1000,   807,     0,   964,
02160      609,   210,   807,   264,   807,     0,   524,   527,   528,   529,
02161      530,   531,   532,   533,   534,   535,   536,   537,   538,   539,
02162      540,   541,   542,   543,   544,   545,   546,   547,   548,   549,
02163      550,   551,   552,     0,   210,     0,     0,     0,    74,     0,
02164        0,     0,   811,     0,   811,     0,     0,   811,  1032,   811,
02165     1034,     0,    74,     0,     0,  1035,     0,   692,     0,     0,
02166        0,     0,     0,    74,     0,     0,    74,     0,     0,     0,
02167       74,    74,  1047,     0,    74,     0,     0,     0,     0,     0,
02168        0,     0,   602,   604,     0,     0,     0,   811,     0,     0,
02169      606,   210,   210,  1055,   110,     0,   210,     0,   602,   604,
02170      210,    74,    74,   807,     0,   807,     0,     0,   807,     0,
02171      807,     0,     0,     0,     0,    74,     0,     0,     0,   626,
02172        0,   525,     0,     0,   631,     0,     0,     0,   110,     0,
02173        0,     0,     0,     0,     0,   210,     0,     0,   210,   110,
02174        0,   110,     0,    74,     0,  1005,  1007,     0,   807,  1010,
02175      210,  1012,  1013,   753,    74,     0,     0,     0,     0,     0,
02176        0,     0,   275,     0,     0,     0,   609,   264,     0,     0,
02177        0,     0,     0,   111,     0,   111,   682,   683,     0,     0,
02178        0,     0,     0,     0,   799,     0,   645,   646,   647,   648,
02179      800,     0,   210,     0,   769,     0,     0,   110,     0,     0,
02180      650,     0,   110,    74,     0,    74,     0,     0,     0,     0,
02181        0,    74,     0,    74,   110,   275,  1048,  1050,  1051,  1052,
02182      111,   651,     0,     0,   276,     0,     0,   652,   653,   654,
02183      770,     0,   645,   646,   647,   648,   800,     0,   818,  1056,
02184        0,    74,     0,     0,     0,     0,   650,   110,     0,     0,
02185      276,     0,   655,     0,     0,   656,   210,     0,     0,   836,
02186      210,     0,   371,   381,   381,   381,     0,   651,     0,     0,
02187        0,     0,   210,   231,   653,   654,     0,     0,     0,   644,
02188        0,   645,   646,   647,   648,   649,     0,     0,   210,     0,
02189        0,     0,     0,     0,     0,   650,     0,     0,   655,     0,
02190        0,   210,   210,     0,     0,     0,     0,     0,     0,     0,
02191        0,     0,     0,   871,     0,     0,   651,     0,     0,     0,
02192        0,     0,   652,   653,   654,     0,     0,     0,     0,   210,
02193        0,   110,     0,     0,     0,     0,     0,     0,     0,     0,
02194        0,   110,     0,   113,     0,   113,     0,   655,     0,     0,
02195      656,     0,     0,     0,     0,     0,     0,     0,     0,   275,
02196        0,     0,   912,   657,   114,     0,   114,     0,     0,     0,
02197        0,     0,     0,   210,   111,     0,     0,   606,   820,     0,
02198      823,   825,     0,    81,     0,    81,     0,   831,   833,     0,
02199      113,     0,     0,     0,   210,   928,     0,     0,     0,     0,
02200      644,     0,   645,   646,   647,   648,   649,     0,   111,   275,
02201        0,   114,     0,   264,     0,   277,   650,     0,     0,   111,
02202        0,   111,     0,     0,     0,     0,     0,     0,     0,     0,
02203       81,   866,     0,     0,     0,   823,   825,   651,   831,   833,
02204        0,   277,   276,   652,   653,   654,     0,     0,   210,     0,
02205        0,     0,     0,   372,   382,   382,     0,     0,     0,     0,
02206        0,   110,     0,   110,     0,     0,     0,     0,   655,     0,
02207        0,   656,   367,     0,     0,     0,     0,   111,     0,     0,
02208        0,     0,   111,     0,   743,   110,     0,     0,     0,     0,
02209        0,     0,     0,     0,   111,   276,     0,   210,     0,     0,
02210        0,   913,     0,     0,     0,     0,     0,     0,     0,   915,
02211        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02212        0,     0,     0,   110,     0,     0,     0,   111,   275,     0,
02213      210,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02214        0,     0,     0,     0,   113,     0,     0,   915,   210,     0,
02215        0,     0,   327,   328,   329,   330,   331,   332,   333,   334,
02216      335,   336,   337,   338,   339,   114,     0,   340,   341,     0,
02217        0,     0,     0,     0,     0,     0,     0,   110,   113,     0,
02218      110,     0,   110,     0,    81,     0,     0,   275,     0,   113,
02219        0,   113,     0,     0,     0,     0,     0,     0,   342,   114,
02220      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
02221      114,   111,   114,     0,     0,     0,     0,     0,    81,     0,
02222        0,   111,     0,     0,     0,   231,     0,   110,     0,    81,
02223        0,    81,     0,   277,     0,   110,     0,     0,     0,   276,
02224        0,     0,     0,     0,     0,     0,     0,   113,     0,     0,
02225        0,   644,   113,   645,   646,   647,   648,   649,     0,     0,
02226        0,     0,     0,     0,   113,     0,     0,   650,   114,     0,
02227        0,     0,     0,   114,     0,     0,     0,     0,     0,     0,
02228        0,     0,     0,     0,     0,   114,   277,    81,   651,   276,
02229        0,   380,    81,     0,   652,   653,   654,   113,   210,     0,
02230        0,     0,     0,     0,    81,     0,   110,   523,     0,     0,
02231        0,     0,     0,     0,     0,     0,     0,     0,   114,   655,
02232      698,     0,   656,     0,     0,     0,     0,     0,     0,     0,
02233        0,   110,     0,     0,     0,     0,     0,    81,   110,   110,
02234        0,   111,   110,   111,   327,   328,   329,   330,   331,   332,
02235      333,   334,   335,   336,   337,   338,   339,     0,     0,   340,
02236      341,     0,     0,     0,     0,   111,     0,     0,     0,   110,
02237      110,     0,   799,     0,   645,   646,   647,   648,   800,     0,
02238        0,   113,     0,   110,   380,     0,     0,     0,   650,     0,
02239      342,   113,   343,   344,   345,   346,   347,   348,   349,   350,
02240      351,   352,   114,   111,     0,     0,     0,   977,   276,   651,
02241     -245,   110,   114,     0,     0,   652,   653,   654,     0,     0,
02242        0,    81,   110,     0,     0,     0,     0,     0,     0,     0,
02243      277,    81,     0,     0,     0,     0,     0,     0,     0,     0,
02244      655,     0,     0,   656,     0,     0,     0,     0,     0,     0,
02245        0,     0,     0,     0,     0,     0,     0,   111,     0,     0,
02246      111,     0,   111,     0,     0,     0,     0,   276,     0,     0,
02247        0,   110,     0,   110,   553,   554,     0,     0,   555,   110,
02248      277,   110,     0,     0,     0,     0,     0,     0,   162,   163,
02249      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
02250      172,     0,     0,   173,   174,   175,   176,   111,     0,     0,
02251        0,   113,     0,   113,     0,   111,     0,   177,   178,     0,
02252        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02253        0,     0,   114,     0,   114,   113,     0,     0,   179,   180,
02254      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
02255      190,    81,     0,    81,     0,     0,   114,   191,     0,     0,
02256        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02257        0,   381,     0,   113,     0,    81,     0,     0,     0,     0,
02258        0,     0,     0,     0,     0,     0,   111,     0,     0,     0,
02259        0,     0,     0,     0,   114,     0,     0,     0,     0,   277,
02260        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02261        0,   111,     0,    81,     0,     0,     0,     0,   111,   111,
02262        0,     0,   111,     0,     0,     0,     0,   113,     0,     0,
02263      113,     0,   113,     0,     0,     0,     0,     0,   798,     0,
02264        0,     0,     0,     0,     0,     0,     0,     0,   114,   111,
02265      111,   114,     0,   114,     0,     0,     0,     0,   277,     0,
02266        0,     0,     0,   111,   381,     0,     0,    81,     0,     0,
02267       81,     0,    81,     0,     0,     0,     0,   113,   523,     0,
02268        0,     0,     0,     0,     0,   113,     0,   978,     0,     0,
02269        0,   111,     0,     0,     0,     0,     0,     0,   114,     0,
02270        0,     0,   111,     0,     0,     0,   114,     0,     0,     0,
02271        0,     0,     0,     0,     0,     0,     0,    81,   327,  -621,
02272     -621,  -621,  -621,   332,   333,    81,     0,  -621,  -621,     0,
02273        0,     0,     0,   340,   341,     0,     0,     0,     0,     0,
02274        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02275        0,   111,     0,   111,     0,     0,   113,     0,     0,   111,
02276        0,   111,   382,     0,     0,     0,   343,   344,   345,   346,
02277      347,   348,   349,   350,   351,   352,     0,   114,     0,     0,
02278        0,   113,     0,     0,     0,     0,     0,     0,   113,   113,
02279        0,     0,   113,     0,     0,     0,    81,     0,     0,     0,
02280        0,     0,   114,     0,     0,     0,     0,     0,     0,   114,
02281      114,     0,     0,   114,     0,     0,     0,     0,     0,   113,
02282      113,    81,     0,     0,     0,     0,     0,     0,    81,    81,
02283        0,     0,    81,   113,     0,     0,     0,     0,     0,     0,
02284      114,   114,     0,     0,     0,     0,     0,     0,     0,     0,
02285        0,     0,     0,     0,   114,   382,     0,     0,     0,    81,
02286       81,   113,     0,     0,     0,     0,     0,     0,     0,     0,
02287        0,     0,   113,    81,     0,     0,     0,     0,   979,     0,
02288        0,     0,   114,     0,     0,     0,     0,     0,     0,     0,
02289        0,     0,     0,   114,     0,     0,     0,   975,     0,     0,
02290        0,    81,     0,     0,     0,     0,     0,     0,     0,     0,
02291        0,     0,    81,     0,     0,     0,     0,     0,     0,     0,
02292        0,   113,     0,   113,     0,     0,     0,     0,     0,   113,
02293        0,   113,     0,     0,     0,     0,     0,     0,     0,     0,
02294        0,     0,   114,     0,   114,     0,     0,     0,     0,     0,
02295      114,     0,   114,     0,     0,     0,     0,     0,     0,     0,
02296        0,    81,     0,    81,     0,     0,     0,     0,     0,    81,
02297        0,    81,  -620,     4,     0,     5,     6,     7,     8,     9,
02298        0,     0,     0,    10,    11,     0,     0,     0,    12,     0,
02299       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02300        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02301        0,    27,     0,     0,     0,     0,     0,    28,    29,    30,
02302       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02303        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02304        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02305        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02306        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02307       54,    55,    56,    57,    58,    59,    60,    61,    62,  -602,
02308        0,     0,     0,     0,     0,     0,     0,  -602,  -602,  -602,
02309        0,     0,  -602,  -602,  -602,     0,  -602,     0,    63,    64,
02310       65,     0,   751,     0,     0,  -602,  -602,  -602,  -602,     0,
02311        0,  -620,     0,  -620,     0,     0,  -602,  -602,     0,  -602,
02312     -602,  -602,  -602,  -602,     0,     0,   327,   328,   329,   330,
02313      331,   332,   333,   334,   335,   336,   337,   338,   339,     0,
02314        0,   340,   341,     0,     0,     0,     0,  -602,  -602,  -602,
02315     -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02316        0,     0,  -602,  -602,  -602,     0,   755,  -602,     0,     0,
02317        0,     0,   342,  -602,   343,   344,   345,   346,   347,   348,
02318      349,   350,   351,   352,     0,     0,     0,  -602,     0,     0,
02319     -602,     0,  -106,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02320     -602,  -602,  -602,  -602,  -602,     0,     0,     0,     0,  -602,
02321     -602,  -602,  -602,  -602,  -505,     0,  -602,  -602,  -602,     0,
02322     -602,     0,  -505,  -505,  -505,     0,     0,  -505,  -505,  -505,
02323        0,  -505,     0,     0,     0,     0,     0,   698,     0,  -505,
02324        0,  -505,  -505,  -505,     0,     0,     0,     0,     0,     0,
02325        0,  -505,  -505,     0,  -505,  -505,  -505,  -505,  -505,     0,
02326        0,   327,   328,   329,   330,   331,   332,   333,   334,   335,
02327      336,   337,   338,   339,     0,     0,   340,   341,     0,     0,
02328        0,     0,  -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,
02329     -505,  -505,  -505,  -505,  -505,     0,     0,  -505,  -505,  -505,
02330        0,  -505,  -505,     0,     0,     0,     0,   342,  -505,   343,
02331      344,   345,   346,   347,   348,   349,   350,   351,   352,     0,
02332        0,     0,  -505,     0,     0,  -505,     0,  -505,  -505,  -505,
02333     -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,
02334        0,     0,     0,     0,     0,  -505,  -505,  -505,  -505,  -508,
02335        0,  -505,  -505,  -505,     0,  -505,     0,  -508,  -508,  -508,
02336        0,     0,  -508,  -508,  -508,     0,  -508,     0,     0,     0,
02337        0,     0,     0,     0,  -508,     0,  -508,  -508,  -508,     0,
02338        0,     0,     0,     0,     0,     0,  -508,  -508,     0,  -508,
02339     -508,  -508,  -508,  -508,     0,     0,   327,   328,   329,   330,
02340      331,   332,   333,   334,   335,   336,   337,   338,   339,     0,
02341        0,   340,   341,     0,     0,     0,     0,  -508,  -508,  -508,
02342     -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
02343        0,     0,  -508,  -508,  -508,     0,  -508,  -508,     0,     0,
02344        0,     0,   342,  -508,   343,   344,   345,   346,   347,   348,
02345      349,   350,   351,   352,     0,     0,     0,  -508,     0,     0,
02346     -508,     0,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
02347     -508,  -508,  -508,  -508,  -508,     0,     0,     0,     0,     0,
02348     -508,  -508,  -508,  -508,  -603,     0,  -508,  -508,  -508,     0,
02349     -508,     0,  -603,  -603,  -603,     0,     0,  -603,  -603,  -603,
02350        0,  -603,     0,     0,     0,     0,     0,     0,     0,     0,
02351     -603,  -603,  -603,  -603,     0,     0,     0,     0,     0,     0,
02352        0,  -603,  -603,     0,  -603,  -603,  -603,  -603,  -603,     0,
02353        0,   327,   328,   329,   330,   331,   332,   333,   334,   335,
02354      336,   337,  -621,  -621,     0,     0,   340,   341,     0,     0,
02355        0,     0,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
02356     -603,  -603,  -603,  -603,  -603,     0,     0,  -603,  -603,  -603,
02357        0,     0,  -603,     0,     0,     0,     0,     0,  -603,   343,
02358      344,   345,   346,   347,   348,   349,   350,   351,   352,     0,
02359        0,     0,  -603,     0,     0,  -603,     0,     0,  -603,  -603,
02360     -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
02361        0,     0,     0,     0,  -603,  -603,  -603,  -603,  -603,  -604,
02362        0,  -603,  -603,  -603,     0,  -603,     0,  -604,  -604,  -604,
02363        0,     0,  -604,  -604,  -604,     0,  -604,     0,     0,     0,
02364        0,     0,     0,     0,     0,  -604,  -604,  -604,  -604,     0,
02365        0,     0,     0,     0,     0,     0,  -604,  -604,     0,  -604,
02366     -604,  -604,  -604,  -604,     0,     0,   327,   328,   329,   330,
02367      331,   332,   333,   334,     0,   336,   337,     0,     0,     0,
02368        0,   340,   341,     0,     0,     0,     0,  -604,  -604,  -604,
02369     -604,  -604,  -604,  -604,  -604,  -604,  -604,  -604,  -604,  -604,
02370        0,     0,  -604,  -604,  -604,     0,     0,  -604,     0,     0,
02371        0,     0,     0,  -604,   343,   344,   345,   346,   347,   348,
02372      349,   350,   351,   352,     0,     0,     0,  -604,     0,     0,
02373     -604,     0,     0,  -604,  -604,  -604,  -604,  -604,  -604,  -604,
02374     -604,  -604,  -604,  -604,  -604,     0,     0,     0,     0,  -604,
02375     -604,  -604,  -604,  -604,  -294,     0,  -604,  -604,  -604,     0,
02376     -604,     0,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02377        0,  -294,     0,     0,     0,     0,     0,     0,     0,     0,
02378        0,  -294,  -294,  -294,     0,     0,     0,     0,     0,     0,
02379        0,  -294,  -294,     0,  -294,  -294,  -294,  -294,  -294,     0,
02380        0,   327,   328,   329,   330,   331,   332,   333,     0,     0,
02381      336,   337,     0,     0,     0,     0,   340,   341,     0,     0,
02382        0,     0,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02383     -294,  -294,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02384        0,   756,  -294,     0,     0,     0,     0,     0,  -294,   343,
02385      344,   345,   346,   347,   348,   349,   350,   351,   352,     0,
02386        0,     0,  -294,     0,     0,  -294,     0,  -108,  -294,  -294,
02387     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02388        0,     0,     0,     0,     0,  -294,  -294,  -294,  -294,  -432,
02389        0,  -294,  -294,  -294,     0,  -294,     0,  -432,  -432,  -432,
02390        0,     0,  -432,  -432,  -432,     0,  -432,     0,     0,     0,
02391        0,     0,     0,     0,     0,  -432,  -432,  -432,     0,     0,
02392        0,     0,     0,     0,     0,     0,  -432,  -432,     0,  -432,
02393     -432,  -432,  -432,  -432,     0,     0,     0,     0,     0,     0,
02394        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02395        0,     0,     0,     0,     0,     0,     0,  -432,  -432,  -432,
02396     -432,  -432,  -432,  -432,  -432,  -432,  -432,  -432,  -432,  -432,
02397        0,     0,  -432,  -432,  -432,     0,     0,  -432,     0,     0,
02398        0,     0,     0,  -432,     0,     0,     0,     0,     0,     0,
02399        0,     0,     0,     0,     0,     0,     0,  -432,     0,     0,
02400        0,     0,     0,  -432,     0,  -432,  -432,  -432,  -432,  -432,
02401     -432,  -432,  -432,  -432,  -432,     0,     0,     0,     0,  -432,
02402     -432,  -432,  -432,  -432,  -285,   227,  -432,  -432,  -432,     0,
02403     -432,     0,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,
02404        0,  -285,     0,     0,     0,     0,     0,     0,     0,     0,
02405        0,  -285,  -285,  -285,     0,     0,     0,     0,     0,     0,
02406        0,  -285,  -285,     0,  -285,  -285,  -285,  -285,  -285,     0,
02407        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02408        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02409        0,     0,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02410     -285,  -285,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,
02411        0,     0,  -285,     0,     0,     0,     0,     0,  -285,     0,
02412        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02413        0,     0,  -285,     0,     0,  -285,     0,     0,  -285,  -285,
02414     -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02415        0,     0,     0,     0,     0,  -285,  -285,  -285,  -285,  -422,
02416        0,  -285,  -285,  -285,     0,  -285,     0,  -422,  -422,  -422,
02417        0,     0,  -422,  -422,  -422,     0,  -422,     0,     0,     0,
02418        0,     0,     0,     0,     0,  -422,  -422,  -422,     0,     0,
02419        0,     0,     0,     0,     0,     0,  -422,  -422,     0,  -422,
02420     -422,  -422,  -422,  -422,     0,     0,     0,     0,     0,     0,
02421        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02422        0,     0,     0,     0,     0,     0,     0,  -422,  -422,  -422,
02423     -422,  -422,  -422,  -422,  -422,  -422,  -422,  -422,  -422,  -422,
02424        0,     0,  -422,  -422,  -422,     0,     0,  -422,     0,     0,
02425        0,     0,     0,  -422,     0,     0,     0,     0,     0,     0,
02426        0,     0,     0,     0,     0,     0,     0,  -422,     0,     0,
02427        0,     0,     0,  -422,     0,  -422,  -422,  -422,  -422,  -422,
02428     -422,  -422,  -422,  -422,  -422,     0,     0,     0,     0,  -422,
02429     -422,  -422,  -422,  -422,  -301,  -422,  -422,  -422,  -422,     0,
02430     -422,     0,  -301,  -301,  -301,     0,     0,  -301,  -301,  -301,
02431        0,  -301,     0,     0,     0,     0,     0,     0,     0,     0,
02432        0,  -301,  -301,     0,     0,     0,     0,     0,     0,     0,
02433        0,  -301,  -301,     0,  -301,  -301,  -301,  -301,  -301,     0,
02434        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02435        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02436        0,     0,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02437     -301,  -301,  -301,  -301,  -301,     0,     0,  -301,  -301,  -301,
02438        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02439        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02440        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02441     -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02442        0,     0,     0,     0,     0,  -301,  -301,  -301,  -301,  -602,
02443      224,  -301,  -301,  -301,     0,  -301,     0,  -602,  -602,  -602,
02444        0,     0,     0,  -602,  -602,     0,  -602,     0,     0,     0,
02445        0,     0,     0,     0,     0,  -602,     0,     0,     0,     0,
02446        0,     0,     0,     0,     0,     0,  -602,  -602,     0,  -602,
02447     -602,  -602,  -602,  -602,     0,     0,     0,     0,     0,     0,
02448        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02449        0,     0,     0,     0,     0,     0,     0,  -602,  -602,  -602,
02450     -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02451        0,     0,  -602,  -602,  -602,     0,   700,     0,     0,     0,
02452        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02453        0,     0,     0,     0,     0,     0,     0,  -602,     0,     0,
02454        0,     0,  -106,  -602,     0,  -602,  -602,  -602,  -602,  -602,
02455     -602,  -602,  -602,  -602,  -602,     0,     0,     0,     0,  -602,
02456     -602,  -602,  -602,   -97,  -294,     0,  -602,     0,  -602,     0,
02457     -602,     0,  -294,  -294,  -294,     0,     0,     0,  -294,  -294,
02458        0,  -294,     0,  -620,     0,     0,     0,     0,     0,     0,
02459        0,  -620,  -620,  -620,     0,     0,  -620,  -620,  -620,     0,
02460     -620,  -294,  -294,     0,  -294,  -294,  -294,  -294,  -294,  -620,
02461     -620,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02462     -620,  -620,     0,  -620,  -620,  -620,  -620,  -620,     0,     0,
02463        0,     0,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02464     -294,  -294,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02465        0,   701,     0,     0,     0,     0,     0,     0,     0,     0,
02466        0,     0,     0,     0,     0,     0,     0,     0,  -620,     0,
02467        0,     0,  -294,     0,     0,     0,     0,  -108,  -294,     0,
02468     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02469        0,  -620,     0,     0,     0,  -294,  -294,  -294,   -99,     0,
02470        0,  -294,     0,  -294,     0,  -294,     0,     0,     0,     0,
02471        0,     0,     0,  -620,  -620,     0,  -620,     0,     0,   227,
02472     -620,     0,  -620,   248,  -620,     5,     6,     7,     8,     9,
02473     -620,  -620,  -620,    10,    11,     0,     0,  -620,    12,     0,
02474       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02475        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02476        0,    27,     0,     0,     0,     0,     0,    28,    29,   249,
02477       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02478        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02479        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02480        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02481        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02482       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02483        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02484        0,     0,     0,     0,     0,     0,     0,     0,    63,    64,
02485       65,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02486        0,  -620,   248,  -620,     5,     6,     7,     8,     9,     0,
02487        0,  -620,    10,    11,     0,  -620,  -620,    12,     0,    13,
02488       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02489        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02490       27,     0,     0,     0,     0,     0,    28,    29,   249,    31,
02491       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02492       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02493        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02494        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02495       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02496       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02497        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02498        0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
02499        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02500     -620,   248,  -620,     5,     6,     7,     8,     9,     0,     0,
02501     -620,    10,    11,     0,     0,  -620,    12,  -620,    13,    14,
02502       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02503       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02504        0,     0,     0,     0,     0,    28,    29,   249,    31,    32,
02505       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02506       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02507        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02508        0,     0,     0,     0,     0,     0,    48,     0,     0,    49,
02509       50,     0,    51,    52,     0,    53,     0,     0,    54,    55,
02510       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02511        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02512        0,     0,     0,     0,     0,     0,    63,    64,    65,     0,
02513        0,     0,     0,     0,     0,     0,     0,     0,     0,  -620,
02514      248,  -620,     5,     6,     7,     8,     9,     0,     0,  -620,
02515       10,    11,     0,     0,  -620,    12,     0,    13,    14,    15,
02516       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02517       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02518        0,     0,     0,     0,    28,    29,   249,    31,    32,    33,
02519       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02520        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02521        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02522        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02523        0,    51,    52,     0,    53,     0,     0,    54,    55,    56,
02524       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02525        0,     0,     0,   248,     0,     5,     6,     7,     8,     9,
02526        0,  -620,  -620,    10,    11,    63,    64,    65,    12,     0,
02527       13,    14,    15,    16,    17,    18,    19,     0,  -620,     0,
02528     -620,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02529        0,    27,     0,     0,     0,     0,     0,    28,    29,   249,
02530       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02531        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02532        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02533        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02534        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02535       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02536        0,     0,     0,     0,     0,     0,   248,     0,     5,     6,
02537        7,     8,     9,     0,     0,     0,    10,    11,    63,    64,
02538       65,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02539        0,  -620,     0,  -620,     0,    20,    21,    22,    23,    24,
02540       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02541       28,    29,   249,    31,    32,    33,    34,    35,    36,    37,
02542       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02543        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02544        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02545        0,    48,     0,     0,   250,    50,     0,    51,    52,     0,
02546       53,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02547       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02548        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02549        0,    63,    64,    65,     0,     0,     0,     0,     0,     0,
02550        0,     0,  -620,     0,  -620,   248,  -620,     5,     6,     7,
02551        8,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02552       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02553        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02554       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02555       29,   249,    31,    32,    33,    34,    35,    36,    37,    38,
02556       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02557       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02558        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02559       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02560        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02561       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02562        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02563       63,    64,    65,     0,     0,     0,     0,     0,     0,     0,
02564        0,  -620,     0,  -620,   248,  -620,     5,     6,     7,     8,
02565        9,     0,     0,     0,    10,    11,     0,     0,     0,    12,
02566        0,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02567        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02568        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02569      249,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02570       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02571       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02572        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02573        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02574        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02575        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02576        0,     0,     0,     0,     0,     0,     0,     0,     0,    63,
02577       64,    65,     0,     0,  -620,     4,     0,     5,     6,     7,
02578        8,     9,  -620,     0,  -620,    10,    11,     0,     0,     0,
02579       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02580        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02581       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02582       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
02583       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02584       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02585        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02586       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02587        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02588       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02589        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02590       63,    64,    65,     0,     0,  -620,     0,     0,     0,     0,
02591        0,     0,     0,  -620,   248,  -620,     5,     6,     7,     8,
02592        9,     0,     0,  -620,    10,    11,     0,     0,     0,    12,
02593        0,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02594        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02595        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02596      249,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02597       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02598       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02599        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02600        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02601        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02602        0,     0,     0,     0,     0,     0,     0,   248,     0,     5,
02603        6,     7,     8,     9,     0,     0,     0,    10,    11,    63,
02604       64,    65,    12,     0,    13,    14,    15,    16,    17,    18,
02605       19,     0,  -620,     0,  -620,     0,    20,    21,    22,    23,
02606       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02607        0,    28,    29,   249,    31,    32,    33,    34,    35,    36,
02608       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02609       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02610        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02611        0,     0,    48,     0,     0,    49,    50,     0,    51,    52,
02612        0,    53,     0,     0,    54,    55,    56,    57,    58,    59,
02613       60,    61,    62,     0,  -620,     0,     0,     0,     0,     0,
02614        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02615       10,    11,    63,    64,    65,    12,     0,    13,    14,    15,
02616       16,    17,    18,    19,     0,  -620,     0,  -620,     0,    20,
02617       21,    22,    23,    24,    25,    26,     0,     0,   200,     0,
02618        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02619       34,    35,    36,    37,    38,    39,    40,   201,    41,    42,
02620        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02621        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02622        0,     0,     0,     0,     0,   202,     0,     0,   203,    50,
02623        0,    51,    52,     0,   204,   205,   206,    54,    55,    56,
02624       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02625        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02626        0,     0,     0,    10,    11,    63,   207,    65,    12,     0,
02627       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02628      231,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02629        0,    27,     0,     0,     0,     0,     0,     0,    29,     0,
02630        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02631        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02632        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02633        0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
02634        0,   203,    50,     0,    51,    52,     0,     0,     0,     0,
02635       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02636        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02637        7,     0,     9,     0,     0,     0,    10,    11,    63,    64,
02638       65,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02639        0,   302,     0,   303,     0,    20,    21,    22,    23,    24,
02640       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02641        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02642       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02643        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02644        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02645        0,   202,     0,     0,   203,    50,     0,    51,    52,     0,
02646        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02647       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02648        0,     5,     6,     7,     8,     9,     0,     0,     0,    10,
02649       11,    63,    64,    65,    12,     0,    13,    14,    15,    16,
02650       17,    18,    19,     0,     0,     0,   231,     0,    20,    21,
02651       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02652        0,     0,     0,    28,    29,    30,    31,    32,    33,    34,
02653       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02654       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02655        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02656        0,     0,     0,     0,    48,     0,     0,    49,    50,     0,
02657       51,    52,     0,    53,     0,     0,    54,    55,    56,    57,
02658       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02659        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02660        0,     0,    10,    11,    63,    64,    65,    12,     0,    13,
02661       14,    15,    16,    17,    18,    19,     0,   498,     0,     0,
02662        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02663       27,     0,     0,     0,     0,     0,    28,    29,   249,    31,
02664       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02665       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02666        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02667        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02668       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02669       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02670        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02671        0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
02672        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02673      498,   118,   119,   120,   121,   122,   123,   124,   125,   126,
02674      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02675      137,   138,   139,   140,   141,     0,     0,     0,   142,   143,
02676      144,   384,   385,   386,   387,   149,   150,   151,     0,     0,
02677        0,     0,     0,   152,   153,   154,   155,   388,   389,   390,
02678      391,   160,    37,    38,   392,    40,     0,     0,     0,     0,
02679        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
02680      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
02681      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
02682        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
02683        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02684        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
02685      185,   186,   187,   188,     0,   189,   190,     0,     0,     0,
02686        0,     0,     0,   191,   393,   118,   119,   120,   121,   122,
02687      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02688      133,   134,   135,   136,   137,   138,   139,   140,   141,     0,
02689        0,     0,   142,   143,   144,   145,   146,   147,   148,   149,
02690      150,   151,     0,     0,     0,     0,     0,   152,   153,   154,
02691      155,   156,   157,   158,   159,   160,   280,   281,   161,   282,
02692        0,     0,     0,     0,     0,     0,     0,     0,   162,   163,
02693      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
02694      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
02695        0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
02696        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02697        0,     0,     0,     0,     0,     0,     0,     0,   179,   180,
02698      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
02699      190,     0,     0,     0,     0,     0,     0,   191,   118,   119,
02700      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
02701      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
02702      140,   141,     0,     0,     0,   142,   143,   144,   145,   146,
02703      147,   148,   149,   150,   151,     0,     0,     0,     0,     0,
02704      152,   153,   154,   155,   156,   157,   158,   159,   160,   233,
02705        0,   161,     0,     0,     0,     0,     0,     0,     0,     0,
02706        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
02707        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
02708        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02709      177,   178,     0,     0,    55,     0,     0,     0,     0,     0,
02710        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02711        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
02712      188,     0,   189,   190,     0,     0,     0,     0,     0,     0,
02713      191,   118,   119,   120,   121,   122,   123,   124,   125,   126,
02714      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02715      137,   138,   139,   140,   141,     0,     0,     0,   142,   143,
02716      144,   145,   146,   147,   148,   149,   150,   151,     0,     0,
02717        0,     0,     0,   152,   153,   154,   155,   156,   157,   158,
02718      159,   160,     0,     0,   161,     0,     0,     0,     0,     0,
02719        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
02720      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
02721      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
02722        0,     0,     0,   177,   178,     0,     0,    55,     0,     0,
02723        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02724        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
02725      185,   186,   187,   188,     0,   189,   190,     0,     0,     0,
02726        0,     0,     0,   191,   118,   119,   120,   121,   122,   123,
02727      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02728      134,   135,   136,   137,   138,   139,   140,   141,     0,     0,
02729        0,   142,   143,   144,   145,   146,   147,   148,   149,   150,
02730      151,     0,     0,     0,     0,     0,   152,   153,   154,   155,
02731      156,   157,   158,   159,   160,     0,     0,   161,     0,     0,
02732        0,     0,     0,     0,     0,     0,     0,   162,   163,   164,
02733      165,   166,   167,   168,   169,   170,     0,     0,   171,   172,
02734        0,     0,   173,   174,   175,   176,     0,     0,     0,     0,
02735        0,     0,     0,     0,     0,     0,   177,   178,     0,     0,
02736        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02737        0,     0,     0,     0,     0,     0,     0,   179,   180,   181,
02738      182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
02739        5,     6,     7,     0,     9,     0,   191,     0,    10,    11,
02740        0,     0,     0,    12,     0,    13,    14,    15,   238,   239,
02741       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
02742       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02743        0,     0,     0,   268,     0,     0,    32,    33,    34,    35,
02744       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02745       44,    45,     0,     0,     0,     0,     0,     0,     0,     0,
02746        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02747        0,     0,     0,   269,     0,     0,   203,    50,     0,    51,
02748       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
02749       59,    60,    61,    62,     0,     0,     0,     0,     0,     5,
02750        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02751        0,     0,    12,   270,    13,    14,    15,   238,   239,    18,
02752       19,   271,     0,     0,     0,     0,   240,   241,   242,    23,
02753       24,    25,    26,     0,     0,   200,     0,     0,     0,     0,
02754        0,     0,   268,     0,     0,    32,    33,    34,    35,    36,
02755       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02756       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02757        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02758        0,     0,   269,     0,     0,   203,    50,     0,    51,    52,
02759        0,     0,     0,     0,    54,    55,    56,    57,    58,    59,
02760       60,    61,    62,     0,     0,     0,     0,     0,     5,     6,
02761        7,     8,     9,     0,     0,     0,    10,    11,     0,     0,
02762        0,    12,   270,    13,    14,    15,    16,    17,    18,    19,
02763      518,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02764       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02765       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02766       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02767        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02768        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02769        0,    48,     0,     0,    49,    50,     0,    51,    52,     0,
02770       53,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02771       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02772        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02773       11,    63,    64,    65,    12,     0,    13,    14,    15,    16,
02774       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02775       22,    23,    24,    25,    26,     0,     0,   200,     0,     0,
02776        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02777       35,    36,    37,    38,    39,    40,   201,    41,    42,     0,
02778       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02779        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02780        0,     0,     0,     0,   202,     0,     0,   203,    50,     0,
02781       51,    52,     0,   204,   205,   206,    54,    55,    56,    57,
02782       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02783        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02784        0,     0,    10,    11,    63,   207,    65,    12,     0,    13,
02785       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02786        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02787       27,     0,     0,     0,     0,     0,    28,    29,     0,    31,
02788       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02789       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02790        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02791        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02792       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02793       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02794        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02795        0,     9,     0,     0,     0,    10,    11,    63,    64,    65,
02796       12,     0,    13,    14,    15,   238,   239,    18,    19,     0,
02797        0,     0,     0,     0,   240,   241,   242,    23,    24,    25,
02798       26,     0,     0,   200,     0,     0,     0,     0,     0,     0,
02799       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02800       39,    40,   201,    41,    42,     0,    43,    44,    45,     0,
02801       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02802        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02803      202,     0,     0,   203,    50,     0,    51,    52,     0,   608,
02804      205,   206,    54,    55,    56,    57,    58,    59,    60,    61,
02805       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02806        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02807       63,   207,    65,    12,     0,    13,    14,    15,   238,   239,
02808       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
02809       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02810        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02811       36,    37,    38,    39,    40,   201,    41,    42,     0,    43,
02812       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02813        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02814        0,     0,     0,   202,     0,     0,   203,    50,     0,    51,
02815       52,     0,   204,   205,     0,    54,    55,    56,    57,    58,
02816       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
02817        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02818        0,    10,    11,    63,   207,    65,    12,     0,    13,    14,
02819       15,   238,   239,    18,    19,     0,     0,     0,     0,     0,
02820      240,   241,   242,    23,    24,    25,    26,     0,     0,   200,
02821        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02822       33,    34,    35,    36,    37,    38,    39,    40,   201,    41,
02823       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02824        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02825        0,     0,     0,     0,     0,     0,   202,     0,     0,   203,
02826       50,     0,    51,    52,     0,     0,   205,   206,    54,    55,
02827       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02828        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02829        9,     0,     0,     0,    10,    11,    63,   207,    65,    12,
02830        0,    13,    14,    15,   238,   239,    18,    19,     0,     0,
02831        0,     0,     0,   240,   241,   242,    23,    24,    25,    26,
02832        0,     0,   200,     0,     0,     0,     0,     0,     0,    29,
02833        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02834       40,   201,    41,    42,     0,    43,    44,    45,     0,    46,
02835       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02836        0,     0,     0,     0,     0,     0,     0,     0,     0,   202,
02837        0,     0,   203,    50,     0,    51,    52,     0,   608,   205,
02838        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02839        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02840        6,     7,     0,     9,     0,     0,     0,    10,    11,    63,
02841      207,    65,    12,     0,    13,    14,    15,   238,   239,    18,
02842       19,     0,     0,     0,     0,     0,   240,   241,   242,    23,
02843       24,    25,    26,     0,     0,   200,     0,     0,     0,     0,
02844        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02845       37,    38,    39,    40,   201,    41,    42,     0,    43,    44,
02846       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02847        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02848        0,     0,   202,     0,     0,   203,    50,     0,    51,    52,
02849        0,     0,   205,     0,    54,    55,    56,    57,    58,    59,
02850       60,    61,    62,     0,     0,     0,     0,     0,     0,     0,
02851        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02852       10,    11,    63,   207,    65,    12,     0,    13,    14,    15,
02853       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02854       21,    22,    23,    24,    25,    26,     0,     0,   200,     0,
02855        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02856       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02857        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02858        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02859        0,     0,     0,     0,     0,   202,     0,     0,   203,    50,
02860        0,    51,    52,     0,   512,     0,     0,    54,    55,    56,
02861       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02862        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02863        0,     0,     0,    10,    11,    63,   207,    65,    12,     0,
02864       13,    14,    15,   238,   239,    18,    19,     0,     0,     0,
02865        0,     0,   240,   241,   242,    23,    24,    25,    26,     0,
02866        0,   200,     0,     0,     0,     0,     0,     0,    29,     0,
02867        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02868        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02869        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02870        0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
02871        0,   203,    50,     0,    51,    52,     0,   204,     0,     0,
02872       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02873        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02874        7,     0,     9,     0,     0,     0,    10,    11,    63,   207,
02875       65,    12,     0,    13,    14,    15,   238,   239,    18,    19,
02876        0,     0,     0,     0,     0,   240,   241,   242,    23,    24,
02877       25,    26,     0,     0,   200,     0,     0,     0,     0,     0,
02878        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02879       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02880        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02881        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02882        0,   202,     0,     0,   203,    50,     0,    51,    52,     0,
02883      817,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02884       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02885        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02886       11,    63,   207,    65,    12,     0,    13,    14,    15,   238,
02887      239,    18,    19,     0,     0,     0,     0,     0,   240,   241,
02888      242,    23,    24,    25,    26,     0,     0,   200,     0,     0,
02889        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02890       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02891       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02892        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02893        0,     0,     0,     0,   202,     0,     0,   203,    50,     0,
02894       51,    52,     0,   512,     0,     0,    54,    55,    56,    57,
02895       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02896        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02897        0,     0,    10,    11,    63,   207,    65,    12,     0,    13,
02898       14,    15,   238,   239,    18,    19,     0,     0,     0,     0,
02899        0,   240,   241,   242,    23,    24,    25,    26,     0,     0,
02900      200,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02901       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02902       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02903        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02904        0,     0,     0,     0,     0,     0,     0,   202,     0,     0,
02905      203,    50,     0,    51,    52,     0,   608,     0,     0,    54,
02906       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02907        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02908        0,     9,     0,     0,     0,    10,    11,    63,   207,    65,
02909       12,     0,    13,    14,    15,   238,   239,    18,    19,     0,
02910        0,     0,     0,     0,   240,   241,   242,    23,    24,    25,
02911       26,     0,     0,   200,     0,     0,     0,     0,     0,     0,
02912       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02913       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02914       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02915        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02916      202,     0,     0,   203,    50,     0,    51,    52,     0,     0,
02917        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02918       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02919        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02920       63,   207,    65,    12,     0,    13,    14,    15,    16,    17,
02921       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02922       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02923        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02924       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02925       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02926        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02927        0,     0,     0,   202,     0,     0,   203,    50,     0,    51,
02928       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
02929       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
02930        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02931        0,    10,    11,    63,   207,    65,    12,     0,    13,    14,
02932       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02933       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02934        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02935       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02936       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02937        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02938        0,     0,     0,     0,     0,     0,   202,     0,     0,   203,
02939       50,     0,    51,    52,     0,     0,     0,     0,    54,    55,
02940       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02941        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02942        9,     0,     0,     0,    10,    11,    63,    64,    65,    12,
02943        0,    13,    14,    15,   238,   239,    18,    19,     0,     0,
02944        0,     0,     0,   240,   241,   242,    23,    24,    25,    26,
02945        0,     0,   200,     0,     0,     0,     0,     0,     0,   268,
02946        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02947       40,     0,    41,    42,     0,    43,    44,    45,     0,     0,
02948        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02949        0,     0,     0,     0,     0,     0,     0,     0,     0,   269,
02950        0,     0,   323,    50,     0,    51,    52,     0,   324,     0,
02951        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02952        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02953        0,     0,     0,    10,    11,     0,     0,     0,    12,   270,
02954       13,    14,    15,   238,   239,    18,    19,     0,     0,     0,
02955        0,     0,   240,   241,   242,    23,    24,    25,    26,     0,
02956        0,   200,     0,     0,     0,     0,     0,     0,   268,     0,
02957        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02958        0,    41,    42,     0,    43,    44,    45,     0,     0,     0,
02959        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02960        0,     0,     0,     0,     0,     0,     0,     0,   365,     0,
02961        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02962       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02963        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02964        0,     0,    10,    11,     0,     0,     0,    12,   270,    13,
02965       14,    15,   238,   239,    18,    19,     0,     0,     0,     0,
02966        0,   240,   241,   242,    23,    24,    25,    26,     0,     0,
02967      200,     0,     0,     0,     0,     0,     0,   268,     0,     0,
02968       32,    33,    34,   373,    36,    37,    38,   374,    40,     0,
02969       41,    42,     0,    43,    44,    45,     0,     0,     0,     0,
02970        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02971        0,     0,     0,     0,   375,     0,     0,   376,     0,     0,
02972      203,    50,     0,    51,    52,     0,     0,     0,     0,    54,
02973       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02974        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02975        0,    10,    11,     0,     0,     0,    12,   270,    13,    14,
02976       15,   238,   239,    18,    19,     0,     0,     0,     0,     0,
02977      240,   241,   242,    23,    24,    25,    26,     0,     0,   200,
02978        0,     0,     0,     0,     0,     0,   268,     0,     0,    32,
02979       33,    34,   373,    36,    37,    38,   374,    40,     0,    41,
02980       42,     0,    43,    44,    45,     0,     0,     0,     0,     0,
02981        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02982        0,     0,     0,     0,     0,     0,   376,     0,     0,   203,
02983       50,     0,    51,    52,     0,     0,     0,     0,    54,    55,
02984       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02985        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02986       10,    11,     0,     0,     0,    12,   270,    13,    14,    15,
02987      238,   239,    18,    19,     0,     0,     0,     0,     0,   240,
02988      241,   242,    23,    24,    25,    26,     0,     0,   200,     0,
02989        0,     0,     0,     0,     0,   268,     0,     0,    32,    33,
02990       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02991        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02992        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02993        0,     0,     0,     0,     0,   269,     0,     0,   323,    50,
02994        0,    51,    52,     0,     0,     0,     0,    54,    55,    56,
02995       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02996        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02997       11,     0,     0,     0,    12,   270,    13,    14,    15,   238,
02998      239,    18,    19,     0,     0,     0,     0,     0,   240,   241,
02999      242,    23,    24,    25,    26,     0,     0,   200,     0,     0,
03000        0,     0,     0,     0,   268,     0,     0,    32,    33,    34,
03001       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
03002       43,    44,    45,     0,     0,     0,     0,     0,     0,     0,
03003        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03004        0,     0,     0,     0,   894,     0,     0,   203,    50,     0,
03005       51,    52,     0,     0,     0,     0,    54,    55,    56,    57,
03006       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
03007        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
03008        0,     0,     0,    12,   270,    13,    14,    15,   238,   239,
03009       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
03010       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
03011        0,     0,     0,   268,     0,     0,    32,    33,    34,    35,
03012       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
03013       44,    45,     0,     0,     0,     0,     0,     0,     0,     0,
03014        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03015        0,     0,     0,   974,     0,     0,   203,    50,     0,    51,
03016       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
03017       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
03018      561,   562,     0,     0,   563,     0,     0,     0,     0,     0,
03019        0,     0,     0,   270,   162,   163,   164,   165,   166,   167,
03020      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
03021      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
03022        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
03023        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03024        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
03025      185,   186,   187,   188,     0,   189,   190,   598,   562,     0,
03026        0,   599,     0,   191,     0,     0,     0,     0,     0,     0,
03027        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
03028        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
03029        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03030      177,   178,     0,     0,     0,     0,     0,     0,     0,     0,
03031        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03032        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
03033      188,     0,   189,   190,   612,   554,     0,     0,   613,     0,
03034      191,     0,     0,     0,     0,     0,     0,     0,   162,   163,
03035      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
03036      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
03037        0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
03038        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03039        0,     0,     0,     0,     0,     0,     0,     0,   179,   180,
03040      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
03041      190,   615,   562,     0,     0,   616,     0,   191,     0,     0,
03042        0,     0,     0,     0,     0,   162,   163,   164,   165,   166,
03043      167,   168,   169,   170,     0,     0,   171,   172,     0,     0,
03044      173,   174,   175,   176,     0,     0,     0,     0,     0,     0,
03045        0,     0,     0,     0,   177,   178,     0,     0,     0,     0,
03046        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03047        0,     0,     0,     0,     0,   179,   180,   181,   182,   183,
03048      184,   185,   186,   187,   188,     0,   189,   190,   639,   554,
03049        0,     0,   640,     0,   191,     0,     0,     0,     0,     0,
03050        0,     0,   162,   163,   164,   165,   166,   167,   168,   169,
03051      170,     0,     0,   171,   172,     0,     0,   173,   174,   175,
03052      176,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03053        0,   177,   178,     0,     0,     0,     0,     0,     0,     0,
03054        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03055        0,     0,   179,   180,   181,   182,   183,   184,   185,   186,
03056      187,   188,     0,   189,   190,   642,   562,     0,     0,   643,
03057        0,   191,     0,     0,     0,     0,     0,     0,     0,   162,
03058      163,   164,   165,   166,   167,   168,   169,   170,     0,     0,
03059      171,   172,     0,     0,   173,   174,   175,   176,     0,     0,
03060        0,     0,     0,     0,     0,     0,     0,     0,   177,   178,
03061        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03062        0,     0,     0,     0,     0,     0,     0,     0,     0,   179,
03063      180,   181,   182,   183,   184,   185,   186,   187,   188,     0,
03064      189,   190,   727,   554,     0,     0,   728,     0,   191,     0,
03065        0,     0,     0,     0,     0,     0,   162,   163,   164,   165,
03066      166,   167,   168,   169,   170,     0,     0,   171,   172,     0,
03067        0,   173,   174,   175,   176,     0,     0,     0,     0,     0,
03068        0,     0,     0,     0,     0,   177,   178,     0,     0,     0,
03069        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03070        0,     0,     0,     0,     0,     0,   179,   180,   181,   182,
03071      183,   184,   185,   186,   187,   188,     0,   189,   190,   730,
03072      562,     0,     0,   731,     0,   191,     0,     0,     0,     0,
03073        0,     0,     0,   162,   163,   164,   165,   166,   167,   168,
03074      169,   170,     0,     0,   171,   172,     0,     0,   173,   174,
03075      175,   176,     0,     0,     0,     0,     0,     0,     0,     0,
03076        0,     0,   177,   178,     0,     0,     0,     0,     0,     0,
03077        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03078        0,     0,     0,   179,   180,   181,   182,   183,   184,   185,
03079      186,   187,   188,     0,   189,   190,   737,   554,     0,     0,
03080      738,     0,   191,     0,     0,     0,     0,     0,     0,     0,
03081      162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
03082        0,   171,   172,     0,     0,   173,   174,   175,   176,     0,
03083        0,     0,     0,     0,     0,     0,     0,     0,     0,   177,
03084      178,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03085        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03086      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
03087        0,   189,   190,  1002,   554,     0,     0,  1003,     0,   191,
03088        0,     0,     0,     0,     0,     0,     0,   162,   163,   164,
03089      165,   166,   167,   168,   169,   170,     0,     0,   171,   172,
03090        0,     0,   173,   174,   175,   176,     0,     0,     0,     0,
03091        0,     0,     0,     0,     0,     0,   177,   178,     0,     0,
03092        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03093        0,     0,     0,     0,     0,     0,     0,   179,   180,   181,
03094      182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
03095     1037,   554,     0,     0,  1038,     0,   191,     0,     0,     0,
03096        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
03097      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
03098      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
03099        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
03100        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03101        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
03102      185,   186,   187,   188,     0,   189,   190,  1040,   562,     0,
03103        0,  1041,     0,   191,     0,     0,     0,     0,     0,     0,
03104        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
03105        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
03106        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03107      177,   178,     0,     0,     0,     0,     0,     0,     0,     0,
03108        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03109        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
03110      188,     0,   189,   190,     0,     0,     0,     0,     0,     0,
03111      191
03112 };
03113 
03114 #define yypact_value_is_default(yystate) \
03115   ((yystate) == (-808))
03116 
03117 #define yytable_value_is_error(yytable_value) \
03118   ((yytable_value) == (-621))
03119 
03120 static const yytype_int16 yycheck[] =
03121 {
03122        2,    87,    55,    96,    90,   353,    79,   355,   472,    16,
03123       17,    22,   359,    20,   354,   326,   614,     2,     8,     4,
03124       16,    17,     8,    28,    20,   326,   412,    27,    49,    29,
03125       74,     4,   220,    53,   420,    86,    87,   420,    28,    90,
03126      575,    94,    28,   641,   594,    49,   668,   685,   574,    51,
03127       52,   399,   468,    67,   262,    51,   779,   472,   266,    79,
03128       53,   376,   508,    74,    90,   511,     2,   415,     4,   417,
03129      715,    91,    92,    93,   719,   458,   416,   440,    25,   787,
03130       16,    17,    25,    13,    20,    16,    17,    13,    67,    20,
03131      875,    26,    25,    27,   873,   443,   903,   250,    37,    38,
03132       58,    29,   518,    16,    17,    64,     8,    20,    68,    87,
03133       68,    90,   777,    49,   139,   113,   141,    53,    85,    61,
03134       51,    52,    13,   471,   907,    25,    28,    76,    64,    61,
03135      470,   729,   596,   651,     0,   113,   134,   802,    96,    97,
03136       85,   779,   740,    79,   286,    15,   288,    17,   290,   787,
03137       86,    87,   294,    55,    90,    91,    92,    93,   141,    13,
03138      939,    25,   120,   123,   124,   125,   133,    26,   110,   118,
03139      323,    13,    25,    25,    25,   898,    59,    60,   110,   230,
03140       25,   232,   203,   111,   806,   807,   736,   134,   133,    13,
03141      130,   134,    94,   657,   744,   130,    56,  1004,   271,   243,
03142        1,   134,   141,   136,   134,   139,   991,   141,   259,   139,
03143      136,   141,   214,   139,   993,   141,   237,   224,   220,   226,
03144      227,   307,   308,   309,   310,   227,   252,   950,   224,   250,
03145      226,  1014,    25,   581,   134,   621,   622,   945,   252,   622,
03146      580,   429,   657,   140,   690,   593,   250,  1026,   139,    25,
03147      141,   271,   592,   771,   772,   140,   307,   308,   309,   310,
03148      898,   312,   313,   248,   886,   903,   140,   203,   268,   632,
03149      134,   130,   136,   252,   360,   361,   591,   136,   230,   743,
03150      696,   134,   134,   134,   929,   139,  1009,   141,   224,   134,
03151      226,   227,    87,   224,   230,   226,   232,   139,   670,   141,
03152      672,   237,   323,   255,   324,    61,   258,   945,    85,   360,
03153      361,   224,   248,   226,   250,   139,   117,   141,   113,   323,
03154      113,   306,   134,   259,   375,   321,   311,   853,   743,   141,
03155      326,   324,    85,   306,    85,   271,   362,   113,   139,   134,
03156      141,   134,   964,   485,   137,    61,   140,   354,   141,    65,
03157      492,   107,   354,   109,    26,   873,   133,   875,   134,    37,
03158       38,   137,   321,    85,    85,   141,  1004,   326,    85,    97,
03159      306,   307,   308,   309,   310,   311,   312,   313,   725,   132,
03160      133,   931,   133,   362,   140,   321,    85,   323,   324,    85,
03161      326,   107,   120,   109,   929,   468,   697,    59,    60,   378,
03162       28,    85,    52,   714,    54,    55,    56,    57,    61,   416,
03163      132,   133,   133,    85,   416,     2,   133,     4,   354,    26,
03164      356,   939,   940,   611,   360,   361,   428,   429,   636,    16,
03165       17,    87,   437,    20,   133,   703,   132,   133,   440,   375,
03166      990,  1039,   710,   402,   403,   518,    85,   437,   468,   133,
03167       87,   437,   134,   355,   107,   440,   109,   113,   130,   141,
03168      132,   133,    49,   470,   136,   113,   402,   403,   470,    85,
03169      422,   134,   936,   991,   426,   993,   113,    64,    85,   431,
03170      416,   412,   868,    68,   134,   868,    52,   140,    54,    55,
03171       56,    57,   113,   132,   133,   447,    87,   399,   518,    86,
03172       87,    87,    85,    90,   440,   507,   508,    87,  1026,   511,
03173      100,   883,   884,   557,   450,   417,   888,   133,   890,   891,
03174       87,   565,   113,   130,   455,   132,   133,   113,    87,   136,
03175      134,    87,   468,   113,   470,   437,   121,   122,   123,   124,
03176      125,   443,   542,   134,   595,    87,   113,   558,    58,   570,
03177      133,   572,    54,    87,    85,   566,   600,   113,    68,    85,
03178      560,    63,    64,   136,   637,   517,   568,   134,   134,   471,
03179      917,   113,   760,   580,   625,    56,   923,   134,   580,   113,
03180      576,   113,   518,    61,   141,   592,    96,    97,    88,   600,
03181      592,   136,   134,    26,   573,   574,   141,   134,   600,   137,
03182      605,   132,   133,   141,    87,   136,   132,   133,   587,   611,
03183      120,    14,    15,   134,   614,   605,   203,   637,   136,   605,
03184       52,   130,    87,   696,    56,   997,   998,   999,  1000,   107,
03185      632,   109,   110,   136,   570,   136,   572,   224,    68,   226,
03186      227,   641,   137,   230,   580,   232,   732,   632,   113,   735,
03187      237,   113,    85,   138,   131,   748,   592,    85,   594,   595,
03188      704,   248,    61,   250,   666,   686,   668,   711,   689,   134,
03189      691,  1019,   259,    56,   134,  1047,   696,    68,  1018,   581,
03190       68,   732,    94,   635,   735,   685,   110,   110,   690,   625,
03191      621,   593,   110,   746,   110,   134,   632,   130,    85,   132,
03192      133,   637,   139,   605,   132,   133,    17,    56,   107,   711,
03193      109,   110,   714,   715,   134,   717,    25,   719,   714,   306,
03194      307,   308,   309,   310,   311,   312,   313,    26,    68,   729,
03195       61,   577,   137,   134,   321,   131,   323,   130,   697,   326,
03196      740,   700,   701,    83,    84,   132,   133,    10,   707,   708,
03197      686,   140,   134,   689,   733,   691,   134,   843,   760,    85,
03198      696,   697,   134,   140,   700,   701,   745,   354,   134,   356,
03199       85,   707,   708,   360,   361,    87,   107,   777,   109,   110,
03200      800,   121,   122,   123,   124,   125,    85,    52,   375,   134,
03201      742,   113,   843,    85,   815,    68,   732,   136,     8,   735,
03202      736,   113,   802,   131,   806,   807,   132,   133,   744,   761,
03203       83,    84,    13,    61,   134,   402,   403,   132,   133,   840,
03204       61,   134,   134,   775,   113,    52,   847,   848,   134,   416,
03205      851,   130,   134,   132,   133,    52,   838,   136,   134,   841,
03206      132,   133,    15,    52,   746,   118,   119,   120,   121,   122,
03207      123,   124,   125,   440,    85,   134,   115,   878,   879,   107,
03208      138,   109,   110,   450,   800,   134,   107,   131,   109,   110,
03209      829,   892,   134,   893,   853,   113,   855,    85,   724,   815,
03210      134,    85,   118,   470,   886,   134,    16,    17,    54,    55,
03211       20,    57,   134,   829,   134,   741,   916,    63,    64,   920,
03212      139,   132,   133,    10,   840,    87,   131,   843,   860,    10,
03213      134,   847,   848,   685,    88,   851,    46,    47,     9,   685,
03214      872,    51,    52,   134,   132,   133,   118,   929,   132,   133,
03215      137,   113,   134,    56,    64,    65,   201,   134,   134,   204,
03216      205,   206,   878,   879,    52,   134,    54,    55,    56,    57,
03217       58,   131,   134,   134,    10,   134,   892,   893,   108,   980,
03218       68,   982,   964,   131,   134,   134,    56,   988,   450,   134,
03219      970,   134,   134,   134,   685,    68,   136,   136,   134,    91,
03220      916,    89,    93,   570,   920,   572,   711,  1021,    96,    97,
03221       83,    84,   771,   580,   685,   931,  1014,   749,   844,    52,
03222      846,    54,    55,    56,    57,   592,   294,   594,   595,   781,
03223      856,  1018,   120,   785,  1020,   861,  1018,    99,  1020,  1021,
03224       57,   787,    94,   781,   790,   936,   898,   120,   121,   122,
03225      123,   124,   125,   900,   779,   396,    89,    -1,   625,  1039,
03226       -1,    -1,    95,    -1,   980,   632,   982,    40,    41,    42,
03227       43,    44,   988,    -1,   990,    52,   321,    54,    55,    56,
03228       57,   326,    -1,    52,    -1,    54,    55,    56,    57,    -1,
03229      781,   201,    -1,    -1,   204,   205,   206,   207,    -1,    -1,
03230      926,   927,  1018,     2,    52,     4,    54,    55,    56,    57,
03231       -1,    -1,    89,    -1,   224,    -1,   226,   227,    95,   686,
03232       89,    -1,   689,    -1,   691,    -1,    -1,    -1,    -1,    -1,
03233      697,    -1,    -1,   700,   701,    -1,    -1,  1019,    -1,    -1,
03234      707,   708,    -1,    -1,    -1,    -1,   898,    -1,   900,    -1,
03235       49,   903,    -1,   905,    53,    -1,    -1,   903,    -1,   905,
03236       -1,    -1,    -1,   989,    -1,   732,   411,   412,   735,   736,
03237       -1,    -1,    -1,    -1,    -1,   420,    -1,   744,    -1,    -1,
03238       79,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03239       -1,    -1,    91,    92,    93,    94,  1022,    -1,  1024,   945,
03240       -1,   947,    -1,   809,   810,    -1,   952,   898,    -1,   900,
03241      455,   321,   903,   458,   905,    -1,   326,   327,   328,   329,
03242      330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
03243      340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
03244      350,   351,   352,    -1,   354,    -1,    -1,    -1,   815,    -1,
03245       -1,    -1,  1004,    -1,  1006,    -1,    -1,  1009,  1004,  1011,
03246     1006,    -1,   829,    -1,    -1,  1011,    -1,   512,    -1,    -1,
03247       -1,    -1,    -1,   840,    -1,    -1,   843,    -1,    -1,    -1,
03248      847,   848,  1028,    -1,   851,    -1,    -1,    -1,    -1,    -1,
03249       -1,    -1,   402,   403,    -1,    -1,    -1,  1049,    -1,    -1,
03250      410,   411,   412,  1049,   203,    -1,   416,    -1,   418,   419,
03251      420,   878,   879,  1004,    -1,  1006,    -1,    -1,  1009,    -1,
03252     1011,    -1,    -1,    -1,    -1,   892,    -1,    -1,    -1,   439,
03253       -1,   576,    -1,    -1,   444,    -1,    -1,    -1,   237,    -1,
03254       -1,    -1,    -1,    -1,    -1,   455,    -1,    -1,   458,   248,
03255       -1,   250,    -1,   920,    -1,   961,   962,    -1,  1049,   965,
03256      470,   967,   968,   608,   931,    -1,    -1,    -1,    -1,    -1,
03257       -1,    -1,   271,    -1,    -1,    -1,   621,   622,    -1,    -1,
03258       -1,    -1,    -1,     2,    -1,     4,   496,   497,    -1,    -1,
03259       -1,    -1,    -1,    -1,    52,    -1,    54,    55,    56,    57,
03260       58,    -1,   512,    -1,   649,    -1,    -1,   306,    -1,    -1,
03261       68,    -1,   311,   980,    -1,   982,    -1,    -1,    -1,    -1,
03262       -1,   988,    -1,   990,   323,   324,  1032,  1033,  1034,  1035,
03263       49,    89,    -1,    -1,    53,    -1,    -1,    95,    96,    97,
03264       52,    -1,    54,    55,    56,    57,    58,    -1,   693,  1055,
03265       -1,  1018,    -1,    -1,    -1,    -1,    68,   356,    -1,    -1,
03266       79,    -1,   120,    -1,    -1,   123,   576,    -1,    -1,   714,
03267      580,    -1,    91,    92,    93,    94,    -1,    89,    -1,    -1,
03268       -1,    -1,   592,   141,    96,    97,    -1,    -1,    -1,    52,
03269       -1,    54,    55,    56,    57,    58,    -1,    -1,   608,    -1,
03270       -1,    -1,    -1,    -1,    -1,    68,    -1,    -1,   120,    -1,
03271       -1,   621,   622,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03272       -1,    -1,    -1,   768,    -1,    -1,    89,    -1,    -1,    -1,
03273       -1,    -1,    95,    96,    97,    -1,    -1,    -1,    -1,   649,
03274       -1,   440,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03275       -1,   450,    -1,     2,    -1,     4,    -1,   120,    -1,    -1,
03276      123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   468,
03277       -1,    -1,   817,   136,     2,    -1,     4,    -1,    -1,    -1,
03278       -1,    -1,    -1,   693,   203,    -1,    -1,   697,   698,    -1,
03279      700,   701,    -1,     2,    -1,     4,    -1,   707,   708,    -1,
03280       49,    -1,    -1,    -1,   714,   850,    -1,    -1,    -1,    -1,
03281       52,    -1,    54,    55,    56,    57,    58,    -1,   237,   518,
03282       -1,    49,    -1,   868,    -1,    53,    68,    -1,    -1,   248,
03283       -1,   250,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03284       49,   751,    -1,    -1,    -1,   755,   756,    89,   758,   759,
03285       -1,    79,   271,    95,    96,    97,    -1,    -1,   768,    -1,
03286       -1,    -1,    -1,    91,    92,    93,    -1,    -1,    -1,    -1,
03287       -1,   570,    -1,   572,    -1,    -1,    -1,    -1,   120,    -1,
03288       -1,   123,    91,    -1,    -1,    -1,    -1,   306,    -1,    -1,
03289       -1,    -1,   311,    -1,   136,   594,    -1,    -1,    -1,    -1,
03290       -1,    -1,    -1,    -1,   323,   324,    -1,   817,    -1,    -1,
03291       -1,   821,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   829,
03292       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03293       -1,    -1,    -1,   632,    -1,    -1,    -1,   356,   637,    -1,
03294      850,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03295       -1,    -1,    -1,    -1,   203,    -1,    -1,   867,   868,    -1,
03296       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03297       76,    77,    78,    79,    80,   203,    -1,    83,    84,    -1,
03298       -1,    -1,    -1,    -1,    -1,    -1,    -1,   686,   237,    -1,
03299      689,    -1,   691,    -1,   203,    -1,    -1,   696,    -1,   248,
03300       -1,   250,    -1,    -1,    -1,    -1,    -1,    -1,   114,   237,
03301      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03302      248,   440,   250,    -1,    -1,    -1,    -1,    -1,   237,    -1,
03303       -1,   450,    -1,    -1,    -1,   141,    -1,   736,    -1,   248,
03304       -1,   250,    -1,   271,    -1,   744,    -1,    -1,    -1,   468,
03305       -1,    -1,    -1,    -1,    -1,    -1,    -1,   306,    -1,    -1,
03306       -1,    52,   311,    54,    55,    56,    57,    58,    -1,    -1,
03307       -1,    -1,    -1,    -1,   323,    -1,    -1,    68,   306,    -1,
03308       -1,    -1,    -1,   311,    -1,    -1,    -1,    -1,    -1,    -1,
03309       -1,    -1,    -1,    -1,    -1,   323,   324,   306,    89,   518,
03310       -1,   800,   311,    -1,    95,    96,    97,   356,  1018,    -1,
03311       -1,    -1,    -1,    -1,   323,    -1,   815,   326,    -1,    -1,
03312       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   356,   120,
03313       44,    -1,   123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03314       -1,   840,    -1,    -1,    -1,    -1,    -1,   356,   847,   848,
03315       -1,   570,   851,   572,    68,    69,    70,    71,    72,    73,
03316       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03317       84,    -1,    -1,    -1,    -1,   594,    -1,    -1,    -1,   878,
03318      879,    -1,    52,    -1,    54,    55,    56,    57,    58,    -1,
03319       -1,   440,    -1,   892,   893,    -1,    -1,    -1,    68,    -1,
03320      114,   450,   116,   117,   118,   119,   120,   121,   122,   123,
03321      124,   125,   440,   632,    -1,    -1,    -1,   916,   637,    89,
03322      134,   920,   450,    -1,    -1,    95,    96,    97,    -1,    -1,
03323       -1,   440,   931,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03324      468,   450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03325      120,    -1,    -1,   123,    -1,    -1,    -1,    -1,    -1,    -1,
03326       -1,    -1,    -1,    -1,    -1,    -1,    -1,   686,    -1,    -1,
03327      689,    -1,   691,    -1,    -1,    -1,    -1,   696,    -1,    -1,
03328       -1,   980,    -1,   982,    52,    53,    -1,    -1,    56,   988,
03329      518,   990,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03330       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03331       78,    -1,    -1,    81,    82,    83,    84,   736,    -1,    -1,
03332       -1,   570,    -1,   572,    -1,   744,    -1,    95,    96,    -1,
03333       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03334       -1,    -1,   570,    -1,   572,   594,    -1,    -1,   116,   117,
03335      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
03336      128,   570,    -1,   572,    -1,    -1,   594,   135,    -1,    -1,
03337       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03338       -1,   800,    -1,   632,    -1,   594,    -1,    -1,    -1,    -1,
03339       -1,    -1,    -1,    -1,    -1,    -1,   815,    -1,    -1,    -1,
03340       -1,    -1,    -1,    -1,   632,    -1,    -1,    -1,    -1,   637,
03341       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03342       -1,   840,    -1,   632,    -1,    -1,    -1,    -1,   847,   848,
03343       -1,    -1,   851,    -1,    -1,    -1,    -1,   686,    -1,    -1,
03344      689,    -1,   691,    -1,    -1,    -1,    -1,    -1,   676,    -1,
03345       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   686,   878,
03346      879,   689,    -1,   691,    -1,    -1,    -1,    -1,   696,    -1,
03347       -1,    -1,    -1,   892,   893,    -1,    -1,   686,    -1,    -1,
03348      689,    -1,   691,    -1,    -1,    -1,    -1,   736,   697,    -1,
03349       -1,    -1,    -1,    -1,    -1,   744,    -1,   916,    -1,    -1,
03350       -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,   736,    -1,
03351       -1,    -1,   931,    -1,    -1,    -1,   744,    -1,    -1,    -1,
03352       -1,    -1,    -1,    -1,    -1,    -1,    -1,   736,    68,    69,
03353       70,    71,    72,    73,    74,   744,    -1,    77,    78,    -1,
03354       -1,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,
03355       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03356       -1,   980,    -1,   982,    -1,    -1,   815,    -1,    -1,   988,
03357       -1,   990,   800,    -1,    -1,    -1,   116,   117,   118,   119,
03358      120,   121,   122,   123,   124,   125,    -1,   815,    -1,    -1,
03359       -1,   840,    -1,    -1,    -1,    -1,    -1,    -1,   847,   848,
03360       -1,    -1,   851,    -1,    -1,    -1,   815,    -1,    -1,    -1,
03361       -1,    -1,   840,    -1,    -1,    -1,    -1,    -1,    -1,   847,
03362      848,    -1,    -1,   851,    -1,    -1,    -1,    -1,    -1,   878,
03363      879,   840,    -1,    -1,    -1,    -1,    -1,    -1,   847,   848,
03364       -1,    -1,   851,   892,    -1,    -1,    -1,    -1,    -1,    -1,
03365      878,   879,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03366       -1,    -1,    -1,    -1,   892,   893,    -1,    -1,    -1,   878,
03367      879,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03368       -1,    -1,   931,   892,    -1,    -1,    -1,    -1,   916,    -1,
03369       -1,    -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03370       -1,    -1,    -1,   931,    -1,    -1,    -1,   916,    -1,    -1,
03371       -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03372       -1,    -1,   931,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03373       -1,   980,    -1,   982,    -1,    -1,    -1,    -1,    -1,   988,
03374       -1,   990,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03375       -1,    -1,   980,    -1,   982,    -1,    -1,    -1,    -1,    -1,
03376      988,    -1,   990,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03377       -1,   980,    -1,   982,    -1,    -1,    -1,    -1,    -1,   988,
03378       -1,   990,     0,     1,    -1,     3,     4,     5,     6,     7,
03379       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,
03380       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03381       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03382       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03383       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03384       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03385       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03386       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03387       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03388       98,    99,   100,   101,   102,   103,   104,   105,   106,     0,
03389       -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,     9,    10,
03390       -1,    -1,    13,    14,    15,    -1,    17,    -1,   126,   127,
03391      128,    -1,    44,    -1,    -1,    26,    27,    28,    29,    -1,
03392       -1,   139,    -1,   141,    -1,    -1,    37,    38,    -1,    40,
03393       41,    42,    43,    44,    -1,    -1,    68,    69,    70,    71,
03394       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03395       -1,    83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,
03396       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03397       -1,    -1,    83,    84,    85,    -1,    87,    88,    -1,    -1,
03398       -1,    -1,   114,    94,   116,   117,   118,   119,   120,   121,
03399      122,   123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,
03400      111,    -1,   113,   114,   115,   116,   117,   118,   119,   120,
03401      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03402      131,   132,   133,   134,     0,    -1,   137,   138,   139,    -1,
03403      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03404       -1,    17,    -1,    -1,    -1,    -1,    -1,    44,    -1,    25,
03405       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03406       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03407       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03408       77,    78,    79,    80,    -1,    -1,    83,    84,    -1,    -1,
03409       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03410       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03411       -1,    87,    88,    -1,    -1,    -1,    -1,   114,    94,   116,
03412      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03413       -1,    -1,   108,    -1,    -1,   111,    -1,   113,   114,   115,
03414      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03415       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03416       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03417       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03418       -1,    -1,    -1,    -1,    25,    -1,    27,    28,    29,    -1,
03419       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03420       41,    42,    43,    44,    -1,    -1,    68,    69,    70,    71,
03421       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03422       -1,    83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,
03423       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03424       -1,    -1,    83,    84,    85,    -1,    87,    88,    -1,    -1,
03425       -1,    -1,   114,    94,   116,   117,   118,   119,   120,   121,
03426      122,   123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,
03427      111,    -1,   113,   114,   115,   116,   117,   118,   119,   120,
03428      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,    -1,
03429      131,   132,   133,   134,     0,    -1,   137,   138,   139,    -1,
03430      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03431       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03432       26,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03433       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03434       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03435       77,    78,    79,    80,    -1,    -1,    83,    84,    -1,    -1,
03436       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03437       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03438       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,   116,
03439      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03440       -1,    -1,   108,    -1,    -1,   111,    -1,    -1,   114,   115,
03441      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03442       -1,    -1,    -1,    -1,   130,   131,   132,   133,   134,     0,
03443       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03444       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03445       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,    -1,
03446       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03447       41,    42,    43,    44,    -1,    -1,    68,    69,    70,    71,
03448       72,    73,    74,    75,    -1,    77,    78,    -1,    -1,    -1,
03449       -1,    83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,
03450       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03451       -1,    -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,
03452       -1,    -1,    -1,    94,   116,   117,   118,   119,   120,   121,
03453      122,   123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,
03454      111,    -1,    -1,   114,   115,   116,   117,   118,   119,   120,
03455      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03456      131,   132,   133,   134,     0,    -1,   137,   138,   139,    -1,
03457      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03458       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03459       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03460       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03461       -1,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
03462       77,    78,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
03463       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03464       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03465       -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    94,   116,
03466      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03467       -1,    -1,   108,    -1,    -1,   111,    -1,   113,   114,   115,
03468      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03469       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03470       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03471       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03472       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    -1,    -1,
03473       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03474       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03475       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03476       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
03477       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03478       -1,    -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,
03479       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
03480       -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
03481       -1,    -1,    -1,   114,    -1,   116,   117,   118,   119,   120,
03482      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03483      131,   132,   133,   134,     0,   136,   137,   138,   139,    -1,
03484      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03485       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03486       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03487       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03488       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03489       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03490       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03491       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03492       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,
03493       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03494       -1,    -1,   108,    -1,    -1,   111,    -1,    -1,   114,   115,
03495      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03496       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03497       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03498       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03499       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    -1,    -1,
03500       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03501       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03502       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03503       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
03504       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03505       -1,    -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,
03506       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
03507       -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
03508       -1,    -1,    -1,   114,    -1,   116,   117,   118,   119,   120,
03509      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03510      131,   132,   133,   134,     0,   136,   137,   138,   139,    -1,
03511      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03512       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03513       -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03514       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03515       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03516       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03517       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03518       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03519       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,
03520       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03521       -1,    -1,   108,    -1,    -1,    -1,    -1,    -1,   114,    -1,
03522      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03523       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03524      136,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03525       -1,    -1,    -1,    14,    15,    -1,    17,    -1,    -1,    -1,
03526       -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,
03527       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03528       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03529       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03530       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
03531       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03532       -1,    -1,    83,    84,    85,    -1,    87,    -1,    -1,    -1,
03533       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03534       -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
03535       -1,    -1,   113,   114,    -1,   116,   117,   118,   119,   120,
03536      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03537      131,   132,   133,   134,     0,    -1,   137,    -1,   139,    -1,
03538      141,    -1,     8,     9,    10,    -1,    -1,    -1,    14,    15,
03539       -1,    17,    -1,     0,    -1,    -1,    -1,    -1,    -1,    -1,
03540       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03541       17,    37,    38,    -1,    40,    41,    42,    43,    44,    26,
03542       27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03543       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03544       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03545       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03546       -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03547       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    85,    -1,
03548       -1,    -1,   108,    -1,    -1,    -1,    -1,   113,   114,    -1,
03549      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03550       -1,   108,    -1,    -1,    -1,   131,   132,   133,   134,    -1,
03551       -1,   137,    -1,   139,    -1,   141,    -1,    -1,    -1,    -1,
03552       -1,    -1,    -1,   130,   131,    -1,   133,    -1,    -1,   136,
03553      137,    -1,   139,     1,   141,     3,     4,     5,     6,     7,
03554        8,     9,    10,    11,    12,    -1,    -1,    15,    16,    -1,
03555       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03556       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03557       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03558       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03559       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03560       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03561       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03562       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03563       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03564       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03565       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,
03566      128,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03567       -1,   139,     1,   141,     3,     4,     5,     6,     7,    -1,
03568       -1,    10,    11,    12,    -1,    14,    15,    16,    -1,    18,
03569       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03570       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03571       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03572       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03573       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03574       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03575       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03576       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03577       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03578       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03579       -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,
03580       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03581      139,     1,   141,     3,     4,     5,     6,     7,    -1,    -1,
03582       10,    11,    12,    -1,    -1,    15,    16,    17,    18,    19,
03583       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03584       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03585       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03586       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03587       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03588       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03589       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03590       90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,
03591      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
03592       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03593       -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,    -1,
03594       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   139,
03595        1,   141,     3,     4,     5,     6,     7,    -1,    -1,    10,
03596       11,    12,    -1,    -1,    15,    16,    -1,    18,    19,    20,
03597       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03598       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03599       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
03600       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03601       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03602       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03603       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03604       -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,   100,
03605      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03606       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03607       -1,     9,    10,    11,    12,   126,   127,   128,    16,    -1,
03608       18,    19,    20,    21,    22,    23,    24,    -1,   139,    -1,
03609      141,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03610       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03611       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03612       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03613       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03614       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03615       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03616       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03617       -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,
03618        5,     6,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03619      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03620       -1,   139,    -1,   141,    -1,    30,    31,    32,    33,    34,
03621       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03622       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03623       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03624       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03625       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03626       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03627       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03628      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03629       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03630       -1,   126,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
03631       -1,    -1,   137,    -1,   139,     1,   141,     3,     4,     5,
03632        6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03633       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03634       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03635       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03636       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03637       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03638       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03639       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03640       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03641       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03642      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03643       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03644      126,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03645       -1,   137,    -1,   139,     1,   141,     3,     4,     5,     6,
03646        7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,
03647       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03648       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03649       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03650       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03651       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03652       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03653       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03654       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03655       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03656       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03657       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,
03658      127,   128,    -1,    -1,   131,     1,    -1,     3,     4,     5,
03659        6,     7,   139,    -1,   141,    11,    12,    -1,    -1,    -1,
03660       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03661       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03662       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03663       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03664       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03665       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03666       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03667       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03668       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03669      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03670       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03671      126,   127,   128,    -1,    -1,   131,    -1,    -1,    -1,    -1,
03672       -1,    -1,    -1,   139,     1,   141,     3,     4,     5,     6,
03673        7,    -1,    -1,    10,    11,    12,    -1,    -1,    -1,    16,
03674       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03675       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03676       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03677       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03678       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03679       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03680       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03681       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03682       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03683       -1,    -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,
03684        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   126,
03685      127,   128,    16,    -1,    18,    19,    20,    21,    22,    23,
03686       24,    -1,   139,    -1,   141,    -1,    30,    31,    32,    33,
03687       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03688       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03689       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03690       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03691       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03692       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03693       -1,    95,    -1,    -1,    98,    99,   100,   101,   102,   103,
03694      104,   105,   106,    -1,   108,    -1,    -1,    -1,    -1,    -1,
03695       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03696       11,    12,   126,   127,   128,    16,    -1,    18,    19,    20,
03697       21,    22,    23,    24,    -1,   139,    -1,   141,    -1,    30,
03698       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03699       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03700       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03701       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03702       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03703       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03704       -1,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
03705      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03706       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03707       -1,    -1,    -1,    11,    12,   126,   127,   128,    16,    -1,
03708       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03709      141,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03710       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03711       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03712       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03713       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03714       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03715       -1,    89,    90,    -1,    92,    93,    -1,    -1,    -1,    -1,
03716       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03717       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03718        5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03719      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03720       -1,   139,    -1,   141,    -1,    30,    31,    32,    33,    34,
03721       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03722       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03723       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03724       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03725       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03726       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03727       -1,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03728      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03729       -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,    11,
03730       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03731       22,    23,    24,    -1,    -1,    -1,   141,    -1,    30,    31,
03732       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03733       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03734       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03735       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03736       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03737       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03738       92,    93,    -1,    95,    -1,    -1,    98,    99,   100,   101,
03739      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03740       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03741       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03742       19,    20,    21,    22,    23,    24,    -1,   139,    -1,    -1,
03743       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03744       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03745       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03746       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03747       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03748       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03749       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03750       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03751       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03752       -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,
03753       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03754      139,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03755       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03756       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03757       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03758       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03759       52,    53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,
03760       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03761       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03762       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03763       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
03764       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03765       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
03766      122,   123,   124,   125,    -1,   127,   128,    -1,    -1,    -1,
03767       -1,    -1,    -1,   135,   136,     3,     4,     5,     6,     7,
03768        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03769       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
03770       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
03771       38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03772       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03773       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03774       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03775       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03776       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,
03777       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03778       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,
03779      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
03780      128,    -1,    -1,    -1,    -1,    -1,    -1,   135,     3,     4,
03781        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03782       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03783       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03784       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03785       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03786       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03787       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03788       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03789       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03790       95,    96,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,
03791       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03792       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
03793      125,    -1,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
03794      135,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03795       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03796       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03797       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03798       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03799       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
03800       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03801       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03802       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03803       -1,    -1,    -1,    95,    96,    -1,    -1,    99,    -1,    -1,
03804       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03805       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
03806      122,   123,   124,   125,    -1,   127,   128,    -1,    -1,    -1,
03807       -1,    -1,    -1,   135,     3,     4,     5,     6,     7,     8,
03808        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03809       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03810       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03811       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03812       49,    50,    51,    52,    53,    -1,    -1,    56,    -1,    -1,
03813       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,
03814       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03815       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03816       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
03817       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03818       -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,
03819      119,   120,   121,   122,   123,   124,   125,    -1,   127,   128,
03820        3,     4,     5,    -1,     7,    -1,   135,    -1,    11,    12,
03821       -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,    22,
03822       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03823       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03824       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03825       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03826       63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03827       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03828       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03829       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
03830      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,     3,
03831        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03832       -1,    -1,    16,   126,    18,    19,    20,    21,    22,    23,
03833       24,   134,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03834       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03835       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03836       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03837       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03838       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03839       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03840       -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,   103,
03841      104,   105,   106,    -1,    -1,    -1,    -1,    -1,     3,     4,
03842        5,     6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,
03843       -1,    16,   126,    18,    19,    20,    21,    22,    23,    24,
03844      134,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03845       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03846       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03847       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03848       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03850       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03851       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03852      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03853       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03854       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03855       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03856       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03857       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03858       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03859       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03860       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03861       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03862       92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
03863      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03864       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03865       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03866       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03867       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03868       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,    48,
03869       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03870       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03871       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03872       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03873       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03874       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03875       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03876       -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,   128,
03877       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03878       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03879       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03880       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03881       56,    57,    58,    59,    60,    -1,    62,    63,    64,    -1,
03882       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03883       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03884       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03885       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03886      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03887        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03888      126,   127,   128,    16,    -1,    18,    19,    20,    21,    22,
03889       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03890       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03891       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03892       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03893       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03894       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03895       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03896       93,    -1,    95,    96,    -1,    98,    99,   100,   101,   102,
03897      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
03898       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03899       -1,    11,    12,   126,   127,   128,    16,    -1,    18,    19,
03900       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03901       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03902       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03903       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03904       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03905       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03906       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03907       90,    -1,    92,    93,    -1,    -1,    96,    97,    98,    99,
03908      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
03909       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03910        7,    -1,    -1,    -1,    11,    12,   126,   127,   128,    16,
03911       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03912       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03913       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03914       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03915       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03916       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03917       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03918       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    96,
03919       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03920       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03921        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,
03922      127,   128,    16,    -1,    18,    19,    20,    21,    22,    23,
03923       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03924       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03925       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03926       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03927       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03928       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03929       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03930       -1,    -1,    96,    -1,    98,    99,   100,   101,   102,   103,
03931      104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03932       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03933       11,    12,   126,   127,   128,    16,    -1,    18,    19,    20,
03934       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03935       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03936       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03937       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03938       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03939       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03940       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03941       -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,   100,
03942      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03943       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03944       -1,    -1,    -1,    11,    12,   126,   127,   128,    16,    -1,
03945       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03946       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03947       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03948       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03949       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03950       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03951       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03952       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03953       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03954       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03955        5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03956      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03957       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03958       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03959       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03960       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03961       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03962       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03963       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03964       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03965      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03966       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03967       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03968       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03969       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03970       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03971       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03972       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03973       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03974       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03975       92,    93,    -1,    95,    -1,    -1,    98,    99,   100,   101,
03976      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03977       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03978       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03979       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03980       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03981       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03982       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03983       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03984       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03985       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03986       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03987       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03988       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03989       -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,   128,
03990       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03991       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03992       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03993       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03994       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03995       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03996       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03997       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03998       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03999      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04000        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04001      126,   127,   128,    16,    -1,    18,    19,    20,    21,    22,
04002       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04003       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04004       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04005       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
04006       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
04007       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04008       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04009       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
04010      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04011       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04012       -1,    11,    12,   126,   127,   128,    16,    -1,    18,    19,
04013       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04014       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04015       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04016       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04017       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
04018       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04019       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04020       90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,
04021      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04022       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
04023        7,    -1,    -1,    -1,    11,    12,   126,   127,   128,    16,
04024       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
04025       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
04026       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
04027       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
04028       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    -1,
04029       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04030       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
04031       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
04032       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
04033       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
04034       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,   126,
04035       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
04036       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
04037       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
04038       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
04039       -1,    59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,
04040       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04041       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
04042       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
04043       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
04044       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04045       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   126,    18,
04046       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04047       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04048       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04049       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04050       59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,
04051       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04052       -1,    -1,    -1,    -1,    83,    -1,    -1,    86,    -1,    -1,
04053       89,    90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,
04054       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
04055       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04056       -1,    11,    12,    -1,    -1,    -1,    16,   126,    18,    19,
04057       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04058       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04059       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04060       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04061       60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,
04062       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04063       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04064       90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,
04065      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04066       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
04067       11,    12,    -1,    -1,    -1,    16,   126,    18,    19,    20,
04068       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
04069       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
04070       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
04071       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
04072       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
04073       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04074       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
04075       -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,   100,
04076      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
04077       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
04078       12,    -1,    -1,    -1,    16,   126,    18,    19,    20,    21,
04079       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
04080       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
04081       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
04082       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
04083       62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04084       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04085       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
04086       92,    93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,
04087      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
04088        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04089       -1,    -1,    -1,    16,   126,    18,    19,    20,    21,    22,
04090       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04091       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04092       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04093       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
04094       63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04095       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04096       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04097       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
04098      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04099       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
04100       -1,    -1,    -1,   126,    66,    67,    68,    69,    70,    71,
04101       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04102       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04103       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
04104       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04105       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
04106      122,   123,   124,   125,    -1,   127,   128,    52,    53,    -1,
04107       -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,
04108       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04109       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04110       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04111       95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04112       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04113       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
04114      125,    -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,
04115      135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
04116       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
04117       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
04118       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,
04119       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04120       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,
04121      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
04122      128,    52,    53,    -1,    -1,    56,    -1,   135,    -1,    -1,
04123       -1,    -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,
04124       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
04125       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
04126       -1,    -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,
04127       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04128       -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,
04129      121,   122,   123,   124,   125,    -1,   127,   128,    52,    53,
04130       -1,    -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,
04131       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
04132       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
04133       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04134       -1,    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04135       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04136       -1,    -1,   116,   117,   118,   119,   120,   121,   122,   123,
04137      124,   125,    -1,   127,   128,    52,    53,    -1,    -1,    56,
04138       -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,
04139       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
04140       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
04141       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,
04142       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04143       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,
04144      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
04145      127,   128,    52,    53,    -1,    -1,    56,    -1,   135,    -1,
04146       -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,    69,
04147       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
04148       -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,
04149       -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,    -1,
04150       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04151       -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,
04152      120,   121,   122,   123,   124,   125,    -1,   127,   128,    52,
04153       53,    -1,    -1,    56,    -1,   135,    -1,    -1,    -1,    -1,
04154       -1,    -1,    -1,    66,    67,    68,    69,    70,    71,    72,
04155       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
04156       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04157       -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,
04158       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04159       -1,    -1,    -1,   116,   117,   118,   119,   120,   121,   122,
04160      123,   124,   125,    -1,   127,   128,    52,    53,    -1,    -1,
04161       56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04162       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
04163       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
04164       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
04165       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04166       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04167      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
04168       -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,   135,
04169       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,
04170       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
04171       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
04172       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
04173       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04174       -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,
04175      119,   120,   121,   122,   123,   124,   125,    -1,   127,   128,
04176       52,    53,    -1,    -1,    56,    -1,   135,    -1,    -1,    -1,
04177       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
04178       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04179       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04180       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
04181       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04182       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
04183      122,   123,   124,   125,    -1,   127,   128,    52,    53,    -1,
04184       -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,
04185       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04186       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04187       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04188       95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04189       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04190       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
04191      125,    -1,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
04192      135
04193 };
04194 
04195 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04196    symbol of state STATE-NUM.  */
04197 static const yytype_uint16 yystos[] =
04198 {
04199        0,   143,   144,     0,     1,     3,     4,     5,     6,     7,
04200       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04201       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04202       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04203       57,    59,    60,    62,    63,    64,    66,    67,    86,    89,
04204       90,    92,    93,    95,    98,    99,   100,   101,   102,   103,
04205      104,   105,   106,   126,   127,   128,   145,   146,   147,   154,
04206      156,   157,   159,   160,   163,   164,   165,   167,   168,   169,
04207      171,   172,   182,   196,   215,   216,   217,   218,   219,   220,
04208      221,   222,   223,   224,   225,   251,   252,   266,   267,   268,
04209      269,   270,   271,   272,   275,   277,   278,   290,   292,   293,
04210      294,   295,   296,   297,   298,   329,   340,   147,     3,     4,
04211        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
04212       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
04213       25,    26,    30,    31,    32,    33,    34,    35,    36,    37,
04214       38,    39,    45,    46,    47,    48,    49,    50,    51,    52,
04215       53,    56,    66,    67,    68,    69,    70,    71,    72,    73,
04216       74,    77,    78,    81,    82,    83,    84,    95,    96,   116,
04217      117,   118,   119,   120,   121,   122,   123,   124,   125,   127,
04218      128,   135,   175,   176,   177,   178,   180,   181,   290,   292,
04219       39,    58,    86,    89,    95,    96,    97,   127,   164,   172,
04220      182,   184,   189,   192,   194,   215,   294,   295,   297,   298,
04221      327,   328,   189,   189,   136,   190,   191,   136,   186,   190,
04222      136,   141,   334,    54,   177,   334,   148,   130,    21,    22,
04223       30,    31,    32,   163,   182,   215,   182,    56,     1,    47,
04224       89,   150,   151,   152,   154,   166,   167,   340,   198,   199,
04225      185,   194,   327,   340,   184,   326,   327,   340,    46,    86,
04226      126,   134,   171,   196,   215,   294,   295,   298,   243,   244,
04227       54,    55,    57,   175,   282,   291,   281,   282,   283,   140,
04228      273,   140,   279,   140,   276,   140,   280,    59,    60,   159,
04229      182,   182,   139,   141,   333,   338,   339,    40,    41,    42,
04230       43,    44,    37,    38,    26,   130,   186,   190,   257,    28,
04231      249,   113,   134,    89,    95,   168,   113,    68,    69,    70,
04232       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
04233       83,    84,   114,   116,   117,   118,   119,   120,   121,   122,
04234      123,   124,   125,    85,   132,   133,   197,   157,   158,   158,
04235      202,   204,   158,   333,   339,    86,   165,   172,   215,   231,
04236      294,   295,   298,    52,    56,    83,    86,   173,   174,   215,
04237      294,   295,   298,   174,    33,    34,    35,    36,    49,    50,
04238       51,    52,    56,   136,   175,   296,   324,    85,   133,   332,
04239      257,   269,    87,    87,   134,   184,    56,   184,   184,   184,
04240      113,    88,   134,   193,   340,    85,   132,   133,    87,    87,
04241      134,   193,   189,   334,   335,   189,   188,   189,   194,   327,
04242      340,   157,   335,   157,    54,    63,    64,   155,   136,   183,
04243      130,   150,    85,   133,    87,   154,   153,   166,   137,   333,
04244      339,   335,   335,   157,   138,   134,   141,   337,   134,   337,
04245      131,   337,   334,    56,    59,    60,   168,   170,   134,    85,
04246      132,   133,   245,    61,   107,   109,   110,   284,   110,   284,
04247      110,    65,   284,   110,   110,   274,   284,   110,    61,   110,
04248      110,   110,   274,   110,    61,   110,    68,    68,   139,   147,
04249      158,   158,   158,   158,   154,   157,   157,   259,   258,    94,
04250      161,   250,    95,   159,   184,   194,   195,   166,   134,   171,
04251      134,   156,   159,   172,   182,   184,   195,   182,   182,   182,
04252      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
04253      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
04254      182,   182,   182,    52,    53,    56,   180,   256,   330,   331,
04255      188,    52,    53,    56,   180,   255,   330,   149,   150,    13,
04256      227,   338,   227,   158,   158,   333,    17,   260,    56,    85,
04257      132,   133,    25,   157,    52,    56,   173,     1,   117,   299,
04258      338,    85,   132,   133,   211,   325,   212,   332,    52,    56,
04259      330,   159,   182,   159,   182,   179,   182,   184,    95,   184,
04260      192,   327,    52,    56,   188,    52,    56,   328,   335,   137,
04261      335,   134,   134,   335,   177,   201,   182,   145,   131,   330,
04262      330,   182,   130,   335,   152,   200,   327,   134,   170,    52,
04263       56,   188,    52,    56,    52,    54,    55,    56,    57,    58,
04264       68,    89,    95,    96,    97,   120,   123,   136,   247,   302,
04265      304,   305,   306,   307,   308,   309,   312,   313,   314,   315,
04266      318,   319,   320,   321,   322,   286,   285,   140,   284,   140,
04267      140,   140,   182,   182,    76,   118,   238,   239,   340,   238,
04268      162,   238,   184,   134,   335,   170,   134,   113,    44,   334,
04269       87,    87,   186,   190,   254,   334,   336,    87,    87,   186,
04270      190,   253,    10,   226,     8,   262,   340,   150,    13,   150,
04271       27,   228,   338,   228,   260,   194,   226,    52,    56,   188,
04272       52,    56,   206,   209,   338,   300,   208,    52,    56,   173,
04273      188,   149,   157,   136,   301,   304,   213,   186,   187,   190,
04274      340,    44,   177,   184,   193,    87,    87,   336,    87,    87,
04275      327,   157,   131,   145,   335,   337,   168,   336,   113,   184,
04276       52,    89,    95,   232,   233,   234,   306,   304,   246,   134,
04277      303,   134,   323,   340,    52,   134,   323,   134,   303,    52,
04278      134,   303,    52,   287,    54,    55,    57,   289,   298,    52,
04279       58,   235,   237,   240,   308,   310,   311,   314,   316,   317,
04280      320,   322,   334,   150,   150,   238,   150,    95,   184,   170,
04281      182,   115,   159,   182,   159,   182,   161,   186,   138,    87,
04282      159,   182,   159,   182,   161,   187,   184,   195,   263,   340,
04283       15,   230,   340,    14,   229,   230,   230,   203,   205,   226,
04284      134,   227,   336,   158,   338,   158,   149,   336,   226,   335,
04285      304,   149,   338,   175,   257,   249,   182,    87,   134,   335,
04286      131,   184,   234,   134,   306,   134,   335,   240,    29,   111,
04287      248,   302,   307,   318,   320,   309,   314,   322,   308,   315,
04288      320,   308,   288,   113,    86,   215,   240,   118,   134,   236,
04289      134,   323,   323,   134,   236,   134,   236,   139,    10,   131,
04290      150,    10,   184,   182,   159,   182,    88,   264,   340,   150,
04291        9,   265,   340,   158,   226,   226,   150,   150,   184,   150,
04292      228,   210,   338,   226,   335,   226,   214,   335,   233,   134,
04293       95,   232,   137,   150,   150,   134,   303,   134,   303,   323,
04294      134,   303,   134,   303,   303,   150,   215,    56,    85,   118,
04295      235,   317,   320,   310,   314,   308,   316,   320,   308,    52,
04296      241,   242,   305,   131,    86,   172,   215,   294,   295,   298,
04297      227,   150,   227,   226,   226,   230,   260,   261,   207,   149,
04298      301,   134,   233,   134,   306,    10,   131,   308,   320,   308,
04299      308,   108,    52,    56,   134,   236,   134,   236,   323,   134,
04300      236,   134,   236,   236,   134,   334,    56,    85,   132,   133,
04301      150,   150,   150,   226,   149,   233,   134,   303,   134,   303,
04302      303,   303,   308,   320,   308,   308,   242,    52,    56,   188,
04303       52,    56,   262,   229,   226,   226,   233,   308,   236,   134,
04304      236,   236,   236,   336,   303,   308,   236
04305 };
04306 
04307 #define yyerrok         (yyerrstatus = 0)
04308 #define yyclearin       (yychar = YYEMPTY)
04309 #define YYEMPTY         (-2)
04310 #define YYEOF           0
04311 
04312 #define YYACCEPT        goto yyacceptlab
04313 #define YYABORT         goto yyabortlab
04314 #define YYERROR         goto yyerrorlab
04315 
04316 
04317 /* Like YYERROR except do call yyerror.  This remains here temporarily
04318    to ease the transition to the new meaning of YYERROR, for GCC.
04319    Once GCC version 2 has supplanted version 1, this can go.  However,
04320    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04321    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04322    discussed.  */
04323 
04324 #define YYFAIL          goto yyerrlab
04325 #if defined YYFAIL
04326   /* This is here to suppress warnings from the GCC cpp's
04327      -Wunused-macros.  Normally we don't worry about that warning, but
04328      some users do, and we want to make it easy for users to remove
04329      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04330 #endif
04331 
04332 #define YYRECOVERING()  (!!yyerrstatus)
04333 
04334 #define YYBACKUP(Token, Value)                                  \
04335 do                                                              \
04336   if (yychar == YYEMPTY && yylen == 1)                          \
04337     {                                                           \
04338       yychar = (Token);                                         \
04339       yylval = (Value);                                         \
04340       YYPOPSTACK (1);                                           \
04341       goto yybackup;                                            \
04342     }                                                           \
04343   else                                                          \
04344     {                                                           \
04345       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04346       YYERROR;                                                  \
04347     }                                                           \
04348 while (YYID (0))
04349 
04350 
04351 #define YYTERROR        1
04352 #define YYERRCODE       256
04353 
04354 
04355 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04356    If N is 0, then set CURRENT to the empty location which ends
04357    the previous symbol: RHS[0] (always defined).  */
04358 
04359 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04360 #ifndef YYLLOC_DEFAULT
04361 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04362     do                                                                  \
04363       if (YYID (N))                                                    \
04364         {                                                               \
04365           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04366           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04367           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04368           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04369         }                                                               \
04370       else                                                              \
04371         {                                                               \
04372           (Current).first_line   = (Current).last_line   =              \
04373             YYRHSLOC (Rhs, 0).last_line;                                \
04374           (Current).first_column = (Current).last_column =              \
04375             YYRHSLOC (Rhs, 0).last_column;                              \
04376         }                                                               \
04377     while (YYID (0))
04378 #endif
04379 
04380 
04381 /* This macro is provided for backward compatibility. */
04382 
04383 #ifndef YY_LOCATION_PRINT
04384 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04385 #endif
04386 
04387 
04388 /* YYLEX -- calling `yylex' with the right arguments.  */
04389 
04390 #ifdef YYLEX_PARAM
04391 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04392 #else
04393 # define YYLEX yylex (&yylval, parser)
04394 #endif
04395 
04396 /* Enable debugging if requested.  */
04397 #if YYDEBUG
04398 
04399 # ifndef YYFPRINTF
04400 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04401 #  define YYFPRINTF fprintf
04402 # endif
04403 
04404 # define YYDPRINTF(Args)                        \
04405 do {                                            \
04406   if (yydebug)                                  \
04407     YYFPRINTF Args;                             \
04408 } while (YYID (0))
04409 
04410 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04411 do {                                                                      \
04412   if (yydebug)                                                            \
04413     {                                                                     \
04414       YYFPRINTF (stderr, "%s ", Title);                                   \
04415       yy_symbol_print (stderr,                                            \
04416                   Type, Value, parser); \
04417       YYFPRINTF (stderr, "\n");                                           \
04418     }                                                                     \
04419 } while (YYID (0))
04420 
04421 
04422 /*--------------------------------.
04423 | Print this symbol on YYOUTPUT.  |
04424 `--------------------------------*/
04425 
04426 /*ARGSUSED*/
04427 #if (defined __STDC__ || defined __C99__FUNC__ \
04428      || defined __cplusplus || defined _MSC_VER)
04429 static void
04430 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04431 #else
04432 static void
04433 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04434     FILE *yyoutput;
04435     int yytype;
04436     YYSTYPE const * const yyvaluep;
04437     struct parser_params *parser;
04438 #endif
04439 {
04440   if (!yyvaluep)
04441     return;
04442   YYUSE (parser);
04443 # ifdef YYPRINT
04444   if (yytype < YYNTOKENS)
04445     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04446 # else
04447   YYUSE (yyoutput);
04448 # endif
04449   switch (yytype)
04450     {
04451       default:
04452         break;
04453     }
04454 }
04455 
04456 
04457 /*--------------------------------.
04458 | Print this symbol on YYOUTPUT.  |
04459 `--------------------------------*/
04460 
04461 #if (defined __STDC__ || defined __C99__FUNC__ \
04462      || defined __cplusplus || defined _MSC_VER)
04463 static void
04464 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04465 #else
04466 static void
04467 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04468     FILE *yyoutput;
04469     int yytype;
04470     YYSTYPE const * const yyvaluep;
04471     struct parser_params *parser;
04472 #endif
04473 {
04474   if (yytype < YYNTOKENS)
04475     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04476   else
04477     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04478 
04479   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04480   YYFPRINTF (yyoutput, ")");
04481 }
04482 
04483 /*------------------------------------------------------------------.
04484 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04485 | TOP (included).                                                   |
04486 `------------------------------------------------------------------*/
04487 
04488 #if (defined __STDC__ || defined __C99__FUNC__ \
04489      || defined __cplusplus || defined _MSC_VER)
04490 static void
04491 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04492 #else
04493 static void
04494 yy_stack_print (yybottom, yytop)
04495     yytype_int16 *yybottom;
04496     yytype_int16 *yytop;
04497 #endif
04498 {
04499   YYFPRINTF (stderr, "Stack now");
04500   for (; yybottom <= yytop; yybottom++)
04501     {
04502       int yybot = *yybottom;
04503       YYFPRINTF (stderr, " %d", yybot);
04504     }
04505   YYFPRINTF (stderr, "\n");
04506 }
04507 
04508 # define YY_STACK_PRINT(Bottom, Top)                            \
04509 do {                                                            \
04510   if (yydebug)                                                  \
04511     yy_stack_print ((Bottom), (Top));                           \
04512 } while (YYID (0))
04513 
04514 
04515 /*------------------------------------------------.
04516 | Report that the YYRULE is going to be reduced.  |
04517 `------------------------------------------------*/
04518 
04519 #if (defined __STDC__ || defined __C99__FUNC__ \
04520      || defined __cplusplus || defined _MSC_VER)
04521 static void
04522 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04523 #else
04524 static void
04525 yy_reduce_print (yyvsp, yyrule, parser)
04526     YYSTYPE *yyvsp;
04527     int yyrule;
04528     struct parser_params *parser;
04529 #endif
04530 {
04531   int yynrhs = yyr2[yyrule];
04532   int yyi;
04533   unsigned long int yylno = yyrline[yyrule];
04534   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04535              yyrule - 1, yylno);
04536   /* The symbols being reduced.  */
04537   for (yyi = 0; yyi < yynrhs; yyi++)
04538     {
04539       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04540       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04541                        &(yyvsp[(yyi + 1) - (yynrhs)])
04542                                        , parser);
04543       YYFPRINTF (stderr, "\n");
04544     }
04545 }
04546 
04547 # define YY_REDUCE_PRINT(Rule)          \
04548 do {                                    \
04549   if (yydebug)                          \
04550     yy_reduce_print (yyvsp, Rule, parser); \
04551 } while (YYID (0))
04552 
04553 /* Nonzero means print parse trace.  It is left uninitialized so that
04554    multiple parsers can coexist.  */
04555 #ifndef yydebug
04556 int yydebug;
04557 #endif
04558 #else /* !YYDEBUG */
04559 # define YYDPRINTF(Args)
04560 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04561 # define YY_STACK_PRINT(Bottom, Top)
04562 # define YY_REDUCE_PRINT(Rule)
04563 #endif /* !YYDEBUG */
04564 
04565 
04566 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04567 #ifndef YYINITDEPTH
04568 # define YYINITDEPTH 200
04569 #endif
04570 
04571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04572    if the built-in stack extension method is used).
04573 
04574    Do not make this value too large; the results are undefined if
04575    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04576    evaluated with infinite-precision integer arithmetic.  */
04577 
04578 #ifndef YYMAXDEPTH
04579 # define YYMAXDEPTH 10000
04580 #endif
04581 
04582 
04583 #if YYERROR_VERBOSE
04584 
04585 # ifndef yystrlen
04586 #  if defined __GLIBC__ && defined _STRING_H
04587 #   define yystrlen strlen
04588 #  else
04589 /* Return the length of YYSTR.  */
04590 #if (defined __STDC__ || defined __C99__FUNC__ \
04591      || defined __cplusplus || defined _MSC_VER)
04592 static YYSIZE_T
04593 yystrlen (const char *yystr)
04594 #else
04595 static YYSIZE_T
04596 yystrlen (yystr)
04597     const char *yystr;
04598 #endif
04599 {
04600   YYSIZE_T yylen;
04601   for (yylen = 0; yystr[yylen]; yylen++)
04602     continue;
04603   return yylen;
04604 }
04605 #  endif
04606 # endif
04607 
04608 # ifndef yystpcpy
04609 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04610 #   define yystpcpy stpcpy
04611 #  else
04612 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04613    YYDEST.  */
04614 #if (defined __STDC__ || defined __C99__FUNC__ \
04615      || defined __cplusplus || defined _MSC_VER)
04616 static char *
04617 yystpcpy (char *yydest, const char *yysrc)
04618 #else
04619 static char *
04620 yystpcpy (yydest, yysrc)
04621     char *yydest;
04622     const char *yysrc;
04623 #endif
04624 {
04625   char *yyd = yydest;
04626   const char *yys = yysrc;
04627 
04628   while ((*yyd++ = *yys++) != '\0')
04629     continue;
04630 
04631   return yyd - 1;
04632 }
04633 #  endif
04634 # endif
04635 
04636 # ifndef yytnamerr
04637 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04638    quotes and backslashes, so that it's suitable for yyerror.  The
04639    heuristic is that double-quoting is unnecessary unless the string
04640    contains an apostrophe, a comma, or backslash (other than
04641    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04642    null, do not copy; instead, return the length of what the result
04643    would have been.  */
04644 static YYSIZE_T
04645 yytnamerr (char *yyres, const char *yystr)
04646 {
04647   if (*yystr == '"')
04648     {
04649       YYSIZE_T yyn = 0;
04650       char const *yyp = yystr;
04651 
04652       for (;;)
04653         switch (*++yyp)
04654           {
04655           case '\'':
04656           case ',':
04657             goto do_not_strip_quotes;
04658 
04659           case '\\':
04660             if (*++yyp != '\\')
04661               goto do_not_strip_quotes;
04662             /* Fall through.  */
04663           default:
04664             if (yyres)
04665               yyres[yyn] = *yyp;
04666             yyn++;
04667             break;
04668 
04669           case '"':
04670             if (yyres)
04671               yyres[yyn] = '\0';
04672             return yyn;
04673           }
04674     do_not_strip_quotes: ;
04675     }
04676 
04677   if (! yyres)
04678     return yystrlen (yystr);
04679 
04680   return yystpcpy (yyres, yystr) - yyres;
04681 }
04682 # endif
04683 
04684 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
04685    about the unexpected token YYTOKEN for the state stack whose top is
04686    YYSSP.
04687 
04688    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
04689    not large enough to hold the message.  In that case, also set
04690    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
04691    required number of bytes is too large to store.  */
04692 static int
04693 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
04694                 yytype_int16 *yyssp, int yytoken)
04695 {
04696   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
04697   YYSIZE_T yysize = yysize0;
04698   YYSIZE_T yysize1;
04699   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04700   /* Internationalized format string. */
04701   const char *yyformat = 0;
04702   /* Arguments of yyformat. */
04703   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04704   /* Number of reported tokens (one for the "unexpected", one per
04705      "expected"). */
04706   int yycount = 0;
04707 
04708   /* There are many possibilities here to consider:
04709      - Assume YYFAIL is not used.  It's too flawed to consider.  See
04710        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
04711        for details.  YYERROR is fine as it does not invoke this
04712        function.
04713      - If this state is a consistent state with a default action, then
04714        the only way this function was invoked is if the default action
04715        is an error action.  In that case, don't check for expected
04716        tokens because there are none.
04717      - The only way there can be no lookahead present (in yychar) is if
04718        this state is a consistent state with a default action.  Thus,
04719        detecting the absence of a lookahead is sufficient to determine
04720        that there is no unexpected or expected token to report.  In that
04721        case, just report a simple "syntax error".
04722      - Don't assume there isn't a lookahead just because this state is a
04723        consistent state with a default action.  There might have been a
04724        previous inconsistent state, consistent state with a non-default
04725        action, or user semantic action that manipulated yychar.
04726      - Of course, the expected token list depends on states to have
04727        correct lookahead information, and it depends on the parser not
04728        to perform extra reductions after fetching a lookahead from the
04729        scanner and before detecting a syntax error.  Thus, state merging
04730        (from LALR or IELR) and default reductions corrupt the expected
04731        token list.  However, the list is correct for canonical LR with
04732        one exception: it will still contain any token that will not be
04733        accepted due to an error action in a later state.
04734   */
04735   if (yytoken != YYEMPTY)
04736     {
04737       int yyn = yypact[*yyssp];
04738       yyarg[yycount++] = yytname[yytoken];
04739       if (!yypact_value_is_default (yyn))
04740         {
04741           /* Start YYX at -YYN if negative to avoid negative indexes in
04742              YYCHECK.  In other words, skip the first -YYN actions for
04743              this state because they are default actions.  */
04744           int yyxbegin = yyn < 0 ? -yyn : 0;
04745           /* Stay within bounds of both yycheck and yytname.  */
04746           int yychecklim = YYLAST - yyn + 1;
04747           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04748           int yyx;
04749 
04750           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04751             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
04752                 && !yytable_value_is_error (yytable[yyx + yyn]))
04753               {
04754                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04755                   {
04756                     yycount = 1;
04757                     yysize = yysize0;
04758                     break;
04759                   }
04760                 yyarg[yycount++] = yytname[yyx];
04761                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04762                 if (! (yysize <= yysize1
04763                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04764                   return 2;
04765                 yysize = yysize1;
04766               }
04767         }
04768     }
04769 
04770   switch (yycount)
04771     {
04772 # define YYCASE_(N, S)                      \
04773       case N:                               \
04774         yyformat = S;                       \
04775       break
04776       YYCASE_(0, YY_("syntax error"));
04777       YYCASE_(1, YY_("syntax error, unexpected %s"));
04778       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
04779       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
04780       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
04781       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
04782 # undef YYCASE_
04783     }
04784 
04785   yysize1 = yysize + yystrlen (yyformat);
04786   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04787     return 2;
04788   yysize = yysize1;
04789 
04790   if (*yymsg_alloc < yysize)
04791     {
04792       *yymsg_alloc = 2 * yysize;
04793       if (! (yysize <= *yymsg_alloc
04794              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
04795         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
04796       return 1;
04797     }
04798 
04799   /* Avoid sprintf, as that infringes on the user's name space.
04800      Don't have undefined behavior even if the translation
04801      produced a string with the wrong number of "%s"s.  */
04802   {
04803     char *yyp = *yymsg;
04804     int yyi = 0;
04805     while ((*yyp = *yyformat) != '\0')
04806       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
04807         {
04808           yyp += yytnamerr (yyp, yyarg[yyi++]);
04809           yyformat += 2;
04810         }
04811       else
04812         {
04813           yyp++;
04814           yyformat++;
04815         }
04816   }
04817   return 0;
04818 }
04819 #endif /* YYERROR_VERBOSE */
04820 
04821 /*-----------------------------------------------.
04822 | Release the memory associated to this symbol.  |
04823 `-----------------------------------------------*/
04824 
04825 /*ARGSUSED*/
04826 #if (defined __STDC__ || defined __C99__FUNC__ \
04827      || defined __cplusplus || defined _MSC_VER)
04828 static void
04829 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04830 #else
04831 static void
04832 yydestruct (yymsg, yytype, yyvaluep, parser)
04833     const char *yymsg;
04834     int yytype;
04835     YYSTYPE *yyvaluep;
04836     struct parser_params *parser;
04837 #endif
04838 {
04839   YYUSE (yyvaluep);
04840   YYUSE (parser);
04841 
04842   if (!yymsg)
04843     yymsg = "Deleting";
04844   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04845 
04846   switch (yytype)
04847     {
04848 
04849       default:
04850         break;
04851     }
04852 }
04853 
04854 
04855 /* Prevent warnings from -Wmissing-prototypes.  */
04856 #ifdef YYPARSE_PARAM
04857 #if defined __STDC__ || defined __cplusplus
04858 int yyparse (void *YYPARSE_PARAM);
04859 #else
04860 int yyparse ();
04861 #endif
04862 #else /* ! YYPARSE_PARAM */
04863 #if defined __STDC__ || defined __cplusplus
04864 int yyparse (struct parser_params *parser);
04865 #else
04866 int yyparse ();
04867 #endif
04868 #endif /* ! YYPARSE_PARAM */
04869 
04870 
04871 /*----------.
04872 | yyparse.  |
04873 `----------*/
04874 
04875 #ifdef YYPARSE_PARAM
04876 #if (defined __STDC__ || defined __C99__FUNC__ \
04877      || defined __cplusplus || defined _MSC_VER)
04878 int
04879 yyparse (void *YYPARSE_PARAM)
04880 #else
04881 int
04882 yyparse (YYPARSE_PARAM)
04883     void *YYPARSE_PARAM;
04884 #endif
04885 #else /* ! YYPARSE_PARAM */
04886 #if (defined __STDC__ || defined __C99__FUNC__ \
04887      || defined __cplusplus || defined _MSC_VER)
04888 int
04889 yyparse (struct parser_params *parser)
04890 #else
04891 int
04892 yyparse (parser)
04893     struct parser_params *parser;
04894 #endif
04895 #endif
04896 {
04897 /* The lookahead symbol.  */
04898 int yychar;
04899 
04900 /* The semantic value of the lookahead symbol.  */
04901 YYSTYPE yylval;
04902 
04903     /* Number of syntax errors so far.  */
04904     int yynerrs;
04905 
04906     int yystate;
04907     /* Number of tokens to shift before error messages enabled.  */
04908     int yyerrstatus;
04909 
04910     /* The stacks and their tools:
04911        `yyss': related to states.
04912        `yyvs': related to semantic values.
04913 
04914        Refer to the stacks thru separate pointers, to allow yyoverflow
04915        to reallocate them elsewhere.  */
04916 
04917     /* The state stack.  */
04918     yytype_int16 yyssa[YYINITDEPTH];
04919     yytype_int16 *yyss;
04920     yytype_int16 *yyssp;
04921 
04922     /* The semantic value stack.  */
04923     YYSTYPE yyvsa[YYINITDEPTH];
04924     YYSTYPE *yyvs;
04925     YYSTYPE *yyvsp;
04926 
04927     YYSIZE_T yystacksize;
04928 
04929   int yyn;
04930   int yyresult;
04931   /* Lookahead token as an internal (translated) token number.  */
04932   int yytoken;
04933   /* The variables used to return semantic value and location from the
04934      action routines.  */
04935   YYSTYPE yyval;
04936 
04937 #if YYERROR_VERBOSE
04938   /* Buffer for error messages, and its allocated size.  */
04939   char yymsgbuf[128];
04940   char *yymsg = yymsgbuf;
04941   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
04942 #endif
04943 
04944 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
04945 
04946   /* The number of symbols on the RHS of the reduced rule.
04947      Keep to zero when no symbol should be popped.  */
04948   int yylen = 0;
04949 
04950   yytoken = 0;
04951   yyss = yyssa;
04952   yyvs = yyvsa;
04953   yystacksize = YYINITDEPTH;
04954 
04955   YYDPRINTF ((stderr, "Starting parse\n"));
04956 
04957   yystate = 0;
04958   yyerrstatus = 0;
04959   yynerrs = 0;
04960   yychar = YYEMPTY; /* Cause a token to be read.  */
04961 
04962   /* Initialize stack pointers.
04963      Waste one element of value and location stack
04964      so that they stay on the same level as the state stack.
04965      The wasted elements are never initialized.  */
04966   yyssp = yyss;
04967   yyvsp = yyvs;
04968 
04969   goto yysetstate;
04970 
04971 /*------------------------------------------------------------.
04972 | yynewstate -- Push a new state, which is found in yystate.  |
04973 `------------------------------------------------------------*/
04974  yynewstate:
04975   /* In all cases, when you get here, the value and location stacks
04976      have just been pushed.  So pushing a state here evens the stacks.  */
04977   yyssp++;
04978 
04979  yysetstate:
04980   *yyssp = yystate;
04981 
04982   if (yyss + yystacksize - 1 <= yyssp)
04983     {
04984       /* Get the current used size of the three stacks, in elements.  */
04985       YYSIZE_T yysize = yyssp - yyss + 1;
04986 
04987 #ifdef yyoverflow
04988       {
04989         /* Give user a chance to reallocate the stack.  Use copies of
04990            these so that the &'s don't force the real ones into
04991            memory.  */
04992         YYSTYPE *yyvs1 = yyvs;
04993         yytype_int16 *yyss1 = yyss;
04994 
04995         /* Each stack pointer address is followed by the size of the
04996            data in use in that stack, in bytes.  This used to be a
04997            conditional around just the two extra args, but that might
04998            be undefined if yyoverflow is a macro.  */
04999         yyoverflow (YY_("memory exhausted"),
05000                     &yyss1, yysize * sizeof (*yyssp),
05001                     &yyvs1, yysize * sizeof (*yyvsp),
05002                     &yystacksize);
05003 
05004         yyss = yyss1;
05005         yyvs = yyvs1;
05006       }
05007 #else /* no yyoverflow */
05008 # ifndef YYSTACK_RELOCATE
05009       goto yyexhaustedlab;
05010 # else
05011       /* Extend the stack our own way.  */
05012       if (YYMAXDEPTH <= yystacksize)
05013         goto yyexhaustedlab;
05014       yystacksize *= 2;
05015       if (YYMAXDEPTH < yystacksize)
05016         yystacksize = YYMAXDEPTH;
05017 
05018       {
05019         yytype_int16 *yyss1 = yyss;
05020         union yyalloc *yyptr =
05021           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
05022         if (! yyptr)
05023           goto yyexhaustedlab;
05024         YYSTACK_RELOCATE (yyss_alloc, yyss);
05025         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
05026 #  undef YYSTACK_RELOCATE
05027         if (yyss1 != yyssa)
05028           YYSTACK_FREE (yyss1);
05029       }
05030 # endif
05031 #endif /* no yyoverflow */
05032 
05033       yyssp = yyss + yysize - 1;
05034       yyvsp = yyvs + yysize - 1;
05035 
05036       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
05037                   (unsigned long int) yystacksize));
05038 
05039       if (yyss + yystacksize - 1 <= yyssp)
05040         YYABORT;
05041     }
05042 
05043   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
05044 
05045   if (yystate == YYFINAL)
05046     YYACCEPT;
05047 
05048   goto yybackup;
05049 
05050 /*-----------.
05051 | yybackup.  |
05052 `-----------*/
05053 yybackup:
05054 
05055   /* Do appropriate processing given the current state.  Read a
05056      lookahead token if we need one and don't already have one.  */
05057 
05058   /* First try to decide what to do without reference to lookahead token.  */
05059   yyn = yypact[yystate];
05060   if (yypact_value_is_default (yyn))
05061     goto yydefault;
05062 
05063   /* Not known => get a lookahead token if don't already have one.  */
05064 
05065   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
05066   if (yychar == YYEMPTY)
05067     {
05068       YYDPRINTF ((stderr, "Reading a token: "));
05069       yychar = YYLEX;
05070     }
05071 
05072   if (yychar <= YYEOF)
05073     {
05074       yychar = yytoken = YYEOF;
05075       YYDPRINTF ((stderr, "Now at end of input.\n"));
05076     }
05077   else
05078     {
05079       yytoken = YYTRANSLATE (yychar);
05080       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
05081     }
05082 
05083   /* If the proper action on seeing token YYTOKEN is to reduce or to
05084      detect an error, take that action.  */
05085   yyn += yytoken;
05086   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
05087     goto yydefault;
05088   yyn = yytable[yyn];
05089   if (yyn <= 0)
05090     {
05091       if (yytable_value_is_error (yyn))
05092         goto yyerrlab;
05093       yyn = -yyn;
05094       goto yyreduce;
05095     }
05096 
05097   /* Count tokens shifted since error; after three, turn off error
05098      status.  */
05099   if (yyerrstatus)
05100     yyerrstatus--;
05101 
05102   /* Shift the lookahead token.  */
05103   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
05104 
05105   /* Discard the shifted token.  */
05106   yychar = YYEMPTY;
05107 
05108   yystate = yyn;
05109   *++yyvsp = yylval;
05110 
05111   goto yynewstate;
05112 
05113 
05114 /*-----------------------------------------------------------.
05115 | yydefault -- do the default action for the current state.  |
05116 `-----------------------------------------------------------*/
05117 yydefault:
05118   yyn = yydefact[yystate];
05119   if (yyn == 0)
05120     goto yyerrlab;
05121   goto yyreduce;
05122 
05123 
05124 /*-----------------------------.
05125 | yyreduce -- Do a reduction.  |
05126 `-----------------------------*/
05127 yyreduce:
05128   /* yyn is the number of a rule to reduce with.  */
05129   yylen = yyr2[yyn];
05130 
05131   /* If YYLEN is nonzero, implement the default value of the action:
05132      `$$ = $1'.
05133 
05134      Otherwise, the following line sets YYVAL to garbage.
05135      This behavior is undocumented and Bison
05136      users should not rely upon it.  Assigning to YYVAL
05137      unconditionally makes the parser a bit smaller, and it avoids a
05138      GCC warning that YYVAL may be used uninitialized.  */
05139   yyval = yyvsp[1-yylen];
05140 
05141 
05142   YY_REDUCE_PRINT (yyn);
05143   switch (yyn)
05144     {
05145         case 2:
05146 
05147 /* Line 1806 of yacc.c  */
05148 #line 855 "parse.y"
05149     {
05150                         lex_state = EXPR_BEG;
05151                     /*%%%*/
05152                         local_push(compile_for_eval || rb_parse_in_main());
05153                     /*%
05154                         local_push(0);
05155                     %*/
05156                     }
05157     break;
05158 
05159   case 3:
05160 
05161 /* Line 1806 of yacc.c  */
05162 #line 864 "parse.y"
05163     {
05164                     /*%%%*/
05165                         if ((yyvsp[(2) - (2)].node) && !compile_for_eval) {
05166                             /* last expression should not be void */
05167                             if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node));
05168                             else {
05169                                 NODE *node = (yyvsp[(2) - (2)].node);
05170                                 while (node->nd_next) {
05171                                     node = node->nd_next;
05172                                 }
05173                                 void_expr(node->nd_head);
05174                             }
05175                         }
05176                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node)));
05177                     /*%
05178                         $$ = $2;
05179                         parser->result = dispatch1(program, $$);
05180                     %*/
05181                         local_pop();
05182                     }
05183     break;
05184 
05185   case 4:
05186 
05187 /* Line 1806 of yacc.c  */
05188 #line 887 "parse.y"
05189     {
05190                     /*%%%*/
05191                         void_stmts((yyvsp[(1) - (2)].node));
05192                         fixup_nodes(&deferred_nodes);
05193                     /*%
05194                     %*/
05195                         (yyval.node) = (yyvsp[(1) - (2)].node);
05196                     }
05197     break;
05198 
05199   case 5:
05200 
05201 /* Line 1806 of yacc.c  */
05202 #line 898 "parse.y"
05203     {
05204                     /*%%%*/
05205                         (yyval.node) = NEW_BEGIN(0);
05206                     /*%
05207                         $$ = dispatch2(stmts_add, dispatch0(stmts_new),
05208                                                   dispatch0(void_stmt));
05209                     %*/
05210                     }
05211     break;
05212 
05213   case 6:
05214 
05215 /* Line 1806 of yacc.c  */
05216 #line 907 "parse.y"
05217     {
05218                     /*%%%*/
05219                         (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
05220                     /*%
05221                         $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
05222                     %*/
05223                     }
05224     break;
05225 
05226   case 7:
05227 
05228 /* Line 1806 of yacc.c  */
05229 #line 915 "parse.y"
05230     {
05231                     /*%%%*/
05232                         (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
05233                     /*%
05234                         $$ = dispatch2(stmts_add, $1, $3);
05235                     %*/
05236                     }
05237     break;
05238 
05239   case 8:
05240 
05241 /* Line 1806 of yacc.c  */
05242 #line 923 "parse.y"
05243     {
05244                         (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
05245                     }
05246     break;
05247 
05248   case 10:
05249 
05250 /* Line 1806 of yacc.c  */
05251 #line 930 "parse.y"
05252     {
05253                     /*%%%*/
05254                         /* local_push(0); */
05255                     /*%
05256                     %*/
05257                     }
05258     break;
05259 
05260   case 11:
05261 
05262 /* Line 1806 of yacc.c  */
05263 #line 937 "parse.y"
05264     {
05265                     /*%%%*/
05266                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05267                                                             (yyvsp[(4) - (5)].node));
05268                         /* NEW_PREEXE($4)); */
05269                         /* local_pop(); */
05270                         (yyval.node) = NEW_BEGIN(0);
05271                     /*%
05272                         $$ = dispatch1(BEGIN, $4);
05273                     %*/
05274                     }
05275     break;
05276 
05277   case 12:
05278 
05279 /* Line 1806 of yacc.c  */
05280 #line 954 "parse.y"
05281     {
05282                     /*%%%*/
05283                         (yyval.node) = (yyvsp[(1) - (4)].node);
05284                         if ((yyvsp[(2) - (4)].node)) {
05285                             (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node));
05286                         }
05287                         else if ((yyvsp[(3) - (4)].node)) {
05288                             rb_warn0("else without rescue is useless");
05289                             (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node));
05290                         }
05291                         if ((yyvsp[(4) - (4)].node)) {
05292                             if ((yyval.node)) {
05293                                 (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node));
05294                             }
05295                             else {
05296                                 (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL());
05297                             }
05298                         }
05299                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
05300                     /*%
05301                         $$ = dispatch4(bodystmt,
05302                                        escape_Qundef($1),
05303                                        escape_Qundef($2),
05304                                        escape_Qundef($3),
05305                                        escape_Qundef($4));
05306                     %*/
05307                     }
05308     break;
05309 
05310   case 13:
05311 
05312 /* Line 1806 of yacc.c  */
05313 #line 984 "parse.y"
05314     {
05315                     /*%%%*/
05316                         void_stmts((yyvsp[(1) - (2)].node));
05317                         fixup_nodes(&deferred_nodes);
05318                     /*%
05319                     %*/
05320                         (yyval.node) = (yyvsp[(1) - (2)].node);
05321                     }
05322     break;
05323 
05324   case 14:
05325 
05326 /* Line 1806 of yacc.c  */
05327 #line 995 "parse.y"
05328     {
05329                     /*%%%*/
05330                         (yyval.node) = NEW_BEGIN(0);
05331                     /*%
05332                         $$ = dispatch2(stmts_add, dispatch0(stmts_new),
05333                                                   dispatch0(void_stmt));
05334                     %*/
05335                     }
05336     break;
05337 
05338   case 15:
05339 
05340 /* Line 1806 of yacc.c  */
05341 #line 1004 "parse.y"
05342     {
05343                     /*%%%*/
05344                         (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
05345                     /*%
05346                         $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
05347                     %*/
05348                     }
05349     break;
05350 
05351   case 16:
05352 
05353 /* Line 1806 of yacc.c  */
05354 #line 1012 "parse.y"
05355     {
05356                     /*%%%*/
05357                         (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
05358                     /*%
05359                         $$ = dispatch2(stmts_add, $1, $3);
05360                     %*/
05361                     }
05362     break;
05363 
05364   case 17:
05365 
05366 /* Line 1806 of yacc.c  */
05367 #line 1020 "parse.y"
05368     {
05369                         (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
05370                     }
05371     break;
05372 
05373   case 18:
05374 
05375 /* Line 1806 of yacc.c  */
05376 #line 1026 "parse.y"
05377     {
05378                         (yyval.node) = (yyvsp[(1) - (1)].node);
05379                     }
05380     break;
05381 
05382   case 19:
05383 
05384 /* Line 1806 of yacc.c  */
05385 #line 1030 "parse.y"
05386     {
05387                         yyerror("BEGIN is permitted only at toplevel");
05388                     /*%%%*/
05389                         /* local_push(0); */
05390                     /*%
05391                     %*/
05392                     }
05393     break;
05394 
05395   case 20:
05396 
05397 /* Line 1806 of yacc.c  */
05398 #line 1038 "parse.y"
05399     {
05400                     /*%%%*/
05401                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05402                                                             (yyvsp[(4) - (5)].node));
05403                         /* NEW_PREEXE($4)); */
05404                         /* local_pop(); */
05405                         (yyval.node) = NEW_BEGIN(0);
05406                     /*%
05407                         $$ = dispatch1(BEGIN, $4);
05408                     %*/
05409                     }
05410     break;
05411 
05412   case 21:
05413 
05414 /* Line 1806 of yacc.c  */
05415 #line 1050 "parse.y"
05416     {lex_state = EXPR_FNAME;}
05417     break;
05418 
05419   case 22:
05420 
05421 /* Line 1806 of yacc.c  */
05422 #line 1051 "parse.y"
05423     {
05424                     /*%%%*/
05425                         (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
05426                     /*%
05427                         $$ = dispatch2(alias, $2, $4);
05428                     %*/
05429                     }
05430     break;
05431 
05432   case 23:
05433 
05434 /* Line 1806 of yacc.c  */
05435 #line 1059 "parse.y"
05436     {
05437                     /*%%%*/
05438                         (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
05439                     /*%
05440                         $$ = dispatch2(var_alias, $2, $3);
05441                     %*/
05442                     }
05443     break;
05444 
05445   case 24:
05446 
05447 /* Line 1806 of yacc.c  */
05448 #line 1067 "parse.y"
05449     {
05450                     /*%%%*/
05451                         char buf[2];
05452                         buf[0] = '$';
05453                         buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth;
05454                         (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2));
05455                     /*%
05456                         $$ = dispatch2(var_alias, $2, $3);
05457                     %*/
05458                     }
05459     break;
05460 
05461   case 25:
05462 
05463 /* Line 1806 of yacc.c  */
05464 #line 1078 "parse.y"
05465     {
05466                     /*%%%*/
05467                         yyerror("can't make alias for the number variables");
05468                         (yyval.node) = NEW_BEGIN(0);
05469                     /*%
05470                         $$ = dispatch2(var_alias, $2, $3);
05471                         $$ = dispatch1(alias_error, $$);
05472                     %*/
05473                     }
05474     break;
05475 
05476   case 26:
05477 
05478 /* Line 1806 of yacc.c  */
05479 #line 1088 "parse.y"
05480     {
05481                     /*%%%*/
05482                         (yyval.node) = (yyvsp[(2) - (2)].node);
05483                     /*%
05484                         $$ = dispatch1(undef, $2);
05485                     %*/
05486                     }
05487     break;
05488 
05489   case 27:
05490 
05491 /* Line 1806 of yacc.c  */
05492 #line 1096 "parse.y"
05493     {
05494                     /*%%%*/
05495                         (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
05496                         fixpos((yyval.node), (yyvsp[(3) - (3)].node));
05497                     /*%
05498                         $$ = dispatch2(if_mod, $3, $1);
05499                     %*/
05500                     }
05501     break;
05502 
05503   case 28:
05504 
05505 /* Line 1806 of yacc.c  */
05506 #line 1105 "parse.y"
05507     {
05508                     /*%%%*/
05509                         (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
05510                         fixpos((yyval.node), (yyvsp[(3) - (3)].node));
05511                     /*%
05512                         $$ = dispatch2(unless_mod, $3, $1);
05513                     %*/
05514                     }
05515     break;
05516 
05517   case 29:
05518 
05519 /* Line 1806 of yacc.c  */
05520 #line 1114 "parse.y"
05521     {
05522                     /*%%%*/
05523                         if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
05524                             (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
05525                         }
05526                         else {
05527                             (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
05528                         }
05529                     /*%
05530                         $$ = dispatch2(while_mod, $3, $1);
05531                     %*/
05532                     }
05533     break;
05534 
05535   case 30:
05536 
05537 /* Line 1806 of yacc.c  */
05538 #line 1127 "parse.y"
05539     {
05540                     /*%%%*/
05541                         if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
05542                             (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
05543                         }
05544                         else {
05545                             (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
05546                         }
05547                     /*%
05548                         $$ = dispatch2(until_mod, $3, $1);
05549                     %*/
05550                     }
05551     break;
05552 
05553   case 31:
05554 
05555 /* Line 1806 of yacc.c  */
05556 #line 1140 "parse.y"
05557     {
05558                     /*%%%*/
05559                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0);
05560                         (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0);
05561                     /*%
05562                         $$ = dispatch2(rescue_mod, $1, $3);
05563                     %*/
05564                     }
05565     break;
05566 
05567   case 32:
05568 
05569 /* Line 1806 of yacc.c  */
05570 #line 1149 "parse.y"
05571     {
05572                         if (in_def || in_single) {
05573                             rb_warn0("END in method; use at_exit");
05574                         }
05575                     /*%%%*/
05576                         (yyval.node) = NEW_POSTEXE(NEW_NODE(
05577                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */));
05578                     /*%
05579                         $$ = dispatch1(END, $3);
05580                     %*/
05581                     }
05582     break;
05583 
05584   case 34:
05585 
05586 /* Line 1806 of yacc.c  */
05587 #line 1162 "parse.y"
05588     {
05589                     /*%%%*/
05590                         value_expr((yyvsp[(3) - (3)].node));
05591                         (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
05592                         (yyval.node) = (yyvsp[(1) - (3)].node);
05593                     /*%
05594                         $$ = dispatch2(massign, $1, $3);
05595                     %*/
05596                     }
05597     break;
05598 
05599   case 35:
05600 
05601 /* Line 1806 of yacc.c  */
05602 #line 1172 "parse.y"
05603     {
05604                         value_expr((yyvsp[(3) - (3)].node));
05605                         (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
05606                     }
05607     break;
05608 
05609   case 36:
05610 
05611 /* Line 1806 of yacc.c  */
05612 #line 1177 "parse.y"
05613     {
05614                     /*%%%*/
05615                         NODE *args;
05616 
05617                         value_expr((yyvsp[(6) - (6)].node));
05618                         if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
05619                         args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
05620                         if ((yyvsp[(5) - (6)].id) == tOROP) {
05621                             (yyvsp[(5) - (6)].id) = 0;
05622                         }
05623                         else if ((yyvsp[(5) - (6)].id) == tANDOP) {
05624                             (yyvsp[(5) - (6)].id) = 1;
05625                         }
05626                         (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
05627                         fixpos((yyval.node), (yyvsp[(1) - (6)].node));
05628                     /*%
05629                         $$ = dispatch2(aref_field, $1, escape_Qundef($3));
05630                         $$ = dispatch3(opassign, $$, $5, $6);
05631                     %*/
05632                     }
05633     break;
05634 
05635   case 37:
05636 
05637 /* Line 1806 of yacc.c  */
05638 #line 1198 "parse.y"
05639     {
05640                         value_expr((yyvsp[(5) - (5)].node));
05641                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05642                     }
05643     break;
05644 
05645   case 38:
05646 
05647 /* Line 1806 of yacc.c  */
05648 #line 1203 "parse.y"
05649     {
05650                         value_expr((yyvsp[(5) - (5)].node));
05651                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05652                     }
05653     break;
05654 
05655   case 39:
05656 
05657 /* Line 1806 of yacc.c  */
05658 #line 1208 "parse.y"
05659     {
05660                     /*%%%*/
05661                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
05662                         (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05663                     /*%
05664                         $$ = dispatch2(const_path_field, $1, $3);
05665                         $$ = dispatch3(opassign, $$, $4, $5);
05666                     %*/
05667                     }
05668     break;
05669 
05670   case 40:
05671 
05672 /* Line 1806 of yacc.c  */
05673 #line 1218 "parse.y"
05674     {
05675                         value_expr((yyvsp[(5) - (5)].node));
05676                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05677                     }
05678     break;
05679 
05680   case 41:
05681 
05682 /* Line 1806 of yacc.c  */
05683 #line 1223 "parse.y"
05684     {
05685                     /*%%%*/
05686                         rb_backref_error((yyvsp[(1) - (3)].node));
05687                         (yyval.node) = NEW_BEGIN(0);
05688                     /*%
05689                         $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
05690                         $$ = dispatch1(assign_error, $$);
05691                     %*/
05692                     }
05693     break;
05694 
05695   case 42:
05696 
05697 /* Line 1806 of yacc.c  */
05698 #line 1233 "parse.y"
05699     {
05700                     /*%%%*/
05701                         value_expr((yyvsp[(3) - (3)].node));
05702                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05703                     /*%
05704                         $$ = dispatch2(assign, $1, $3);
05705                     %*/
05706                     }
05707     break;
05708 
05709   case 43:
05710 
05711 /* Line 1806 of yacc.c  */
05712 #line 1242 "parse.y"
05713     {
05714                     /*%%%*/
05715                         (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
05716                         (yyval.node) = (yyvsp[(1) - (3)].node);
05717                     /*%
05718                         $$ = dispatch2(massign, $1, $3);
05719                     %*/
05720                     }
05721     break;
05722 
05723   case 44:
05724 
05725 /* Line 1806 of yacc.c  */
05726 #line 1251 "parse.y"
05727     {
05728                     /*%%%*/
05729                         (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
05730                         (yyval.node) = (yyvsp[(1) - (3)].node);
05731                     /*%
05732                         $$ = dispatch2(massign, $1, $3);
05733                     %*/
05734                     }
05735     break;
05736 
05737   case 46:
05738 
05739 /* Line 1806 of yacc.c  */
05740 #line 1263 "parse.y"
05741     {
05742                     /*%%%*/
05743                         value_expr((yyvsp[(3) - (3)].node));
05744                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05745                     /*%
05746                         $$ = dispatch2(assign, $1, $3);
05747                     %*/
05748                     }
05749     break;
05750 
05751   case 47:
05752 
05753 /* Line 1806 of yacc.c  */
05754 #line 1272 "parse.y"
05755     {
05756                     /*%%%*/
05757                         value_expr((yyvsp[(3) - (3)].node));
05758                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05759                     /*%
05760                         $$ = dispatch2(assign, $1, $3);
05761                     %*/
05762                     }
05763     break;
05764 
05765   case 49:
05766 
05767 /* Line 1806 of yacc.c  */
05768 #line 1285 "parse.y"
05769     {
05770                     /*%%%*/
05771                         (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05772                     /*%
05773                         $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
05774                     %*/
05775                     }
05776     break;
05777 
05778   case 50:
05779 
05780 /* Line 1806 of yacc.c  */
05781 #line 1293 "parse.y"
05782     {
05783                     /*%%%*/
05784                         (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05785                     /*%
05786                         $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
05787                     %*/
05788                     }
05789     break;
05790 
05791   case 51:
05792 
05793 /* Line 1806 of yacc.c  */
05794 #line 1301 "parse.y"
05795     {
05796                     /*%%%*/
05797                         (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!');
05798                     /*%
05799                         $$ = dispatch2(unary, ripper_intern("not"), $3);
05800                     %*/
05801                     }
05802     break;
05803 
05804   case 52:
05805 
05806 /* Line 1806 of yacc.c  */
05807 #line 1309 "parse.y"
05808     {
05809                     /*%%%*/
05810                         (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
05811                     /*%
05812                         $$ = dispatch2(unary, ripper_id2sym('!'), $2);
05813                     %*/
05814                     }
05815     break;
05816 
05817   case 54:
05818 
05819 /* Line 1806 of yacc.c  */
05820 #line 1320 "parse.y"
05821     {
05822                     /*%%%*/
05823                         value_expr((yyvsp[(1) - (1)].node));
05824                         (yyval.node) = (yyvsp[(1) - (1)].node);
05825                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
05826                     /*%
05827                         $$ = $1;
05828                     %*/
05829                     }
05830     break;
05831 
05832   case 58:
05833 
05834 /* Line 1806 of yacc.c  */
05835 #line 1337 "parse.y"
05836     {
05837                     /*%%%*/
05838                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
05839                     /*%
05840                         $$ = dispatch3(call, $1, $2, $3);
05841                         $$ = method_arg($$, $4);
05842                     %*/
05843                     }
05844     break;
05845 
05846   case 59:
05847 
05848 /* Line 1806 of yacc.c  */
05849 #line 1348 "parse.y"
05850     {
05851                         (yyvsp[(1) - (1)].vars) = dyna_push();
05852                     /*%%%*/
05853                         (yyval.num) = ruby_sourceline;
05854                     /*%
05855                     %*/
05856                     }
05857     break;
05858 
05859   case 60:
05860 
05861 /* Line 1806 of yacc.c  */
05862 #line 1358 "parse.y"
05863     {
05864                     /*%%%*/
05865                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
05866                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
05867                     /*%
05868                         $$ = dispatch2(brace_block, escape_Qundef($3), $4);
05869                     %*/
05870                         dyna_pop((yyvsp[(1) - (5)].vars));
05871                     }
05872     break;
05873 
05874   case 61:
05875 
05876 /* Line 1806 of yacc.c  */
05877 #line 1370 "parse.y"
05878     {
05879                     /*%%%*/
05880                         (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
05881                         nd_set_line((yyval.node), tokline);
05882                     /*%
05883                     %*/
05884                     }
05885     break;
05886 
05887   case 62:
05888 
05889 /* Line 1806 of yacc.c  */
05890 #line 1380 "parse.y"
05891     {
05892                     /*%%%*/
05893                         (yyval.node) = (yyvsp[(1) - (2)].node);
05894                         (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
05895                     /*%
05896                         $$ = dispatch2(command, $1, $2);
05897                     %*/
05898                     }
05899     break;
05900 
05901   case 63:
05902 
05903 /* Line 1806 of yacc.c  */
05904 #line 1389 "parse.y"
05905     {
05906                     /*%%%*/
05907                         block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node));
05908                         (yyvsp[(1) - (3)].node)->nd_args = (yyvsp[(2) - (3)].node);
05909                         (yyvsp[(3) - (3)].node)->nd_iter = (yyvsp[(1) - (3)].node);
05910                         (yyval.node) = (yyvsp[(3) - (3)].node);
05911                         fixpos((yyval.node), (yyvsp[(1) - (3)].node));
05912                     /*%
05913                         $$ = dispatch2(command, $1, $2);
05914                         $$ = method_add_block($$, $3);
05915                     %*/
05916                     }
05917     break;
05918 
05919   case 64:
05920 
05921 /* Line 1806 of yacc.c  */
05922 #line 1402 "parse.y"
05923     {
05924                     /*%%%*/
05925                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
05926                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
05927                     /*%
05928                         $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
05929                     %*/
05930                     }
05931     break;
05932 
05933   case 65:
05934 
05935 /* Line 1806 of yacc.c  */
05936 #line 1411 "parse.y"
05937     {
05938                     /*%%%*/
05939                         block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
05940                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
05941                         (yyval.node) = (yyvsp[(5) - (5)].node);
05942                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
05943                     /*%
05944                         $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
05945                         $$ = method_add_block($$, $5);
05946                     %*/
05947                    }
05948     break;
05949 
05950   case 66:
05951 
05952 /* Line 1806 of yacc.c  */
05953 #line 1423 "parse.y"
05954     {
05955                     /*%%%*/
05956                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
05957                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
05958                     /*%
05959                         $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
05960                     %*/
05961                     }
05962     break;
05963 
05964   case 67:
05965 
05966 /* Line 1806 of yacc.c  */
05967 #line 1432 "parse.y"
05968     {
05969                     /*%%%*/
05970                         block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
05971                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
05972                         (yyval.node) = (yyvsp[(5) - (5)].node);
05973                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
05974                     /*%
05975                         $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
05976                         $$ = method_add_block($$, $5);
05977                     %*/
05978                    }
05979     break;
05980 
05981   case 68:
05982 
05983 /* Line 1806 of yacc.c  */
05984 #line 1444 "parse.y"
05985     {
05986                     /*%%%*/
05987                         (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
05988                         fixpos((yyval.node), (yyvsp[(2) - (2)].node));
05989                     /*%
05990                         $$ = dispatch1(super, $2);
05991                     %*/
05992                     }
05993     break;
05994 
05995   case 69:
05996 
05997 /* Line 1806 of yacc.c  */
05998 #line 1453 "parse.y"
05999     {
06000                     /*%%%*/
06001                         (yyval.node) = new_yield((yyvsp[(2) - (2)].node));
06002                         fixpos((yyval.node), (yyvsp[(2) - (2)].node));
06003                     /*%
06004                         $$ = dispatch1(yield, $2);
06005                     %*/
06006                     }
06007     break;
06008 
06009   case 70:
06010 
06011 /* Line 1806 of yacc.c  */
06012 #line 1462 "parse.y"
06013     {
06014                     /*%%%*/
06015                         (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node)));
06016                     /*%
06017                         $$ = dispatch1(return, $2);
06018                     %*/
06019                     }
06020     break;
06021 
06022   case 71:
06023 
06024 /* Line 1806 of yacc.c  */
06025 #line 1470 "parse.y"
06026     {
06027                     /*%%%*/
06028                         (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node)));
06029                     /*%
06030                         $$ = dispatch1(break, $2);
06031                     %*/
06032                     }
06033     break;
06034 
06035   case 72:
06036 
06037 /* Line 1806 of yacc.c  */
06038 #line 1478 "parse.y"
06039     {
06040                     /*%%%*/
06041                         (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node)));
06042                     /*%
06043                         $$ = dispatch1(next, $2);
06044                     %*/
06045                     }
06046     break;
06047 
06048   case 74:
06049 
06050 /* Line 1806 of yacc.c  */
06051 #line 1489 "parse.y"
06052     {
06053                     /*%%%*/
06054                         (yyval.node) = (yyvsp[(2) - (3)].node);
06055                     /*%
06056                         $$ = dispatch1(mlhs_paren, $2);
06057                     %*/
06058                     }
06059     break;
06060 
06061   case 76:
06062 
06063 /* Line 1806 of yacc.c  */
06064 #line 1500 "parse.y"
06065     {
06066                     /*%%%*/
06067                         (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0);
06068                     /*%
06069                         $$ = dispatch1(mlhs_paren, $2);
06070                     %*/
06071                     }
06072     break;
06073 
06074   case 77:
06075 
06076 /* Line 1806 of yacc.c  */
06077 #line 1510 "parse.y"
06078     {
06079                     /*%%%*/
06080                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
06081                     /*%
06082                         $$ = $1;
06083                     %*/
06084                     }
06085     break;
06086 
06087   case 78:
06088 
06089 /* Line 1806 of yacc.c  */
06090 #line 1518 "parse.y"
06091     {
06092                     /*%%%*/
06093                         (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0);
06094                     /*%
06095                         $$ = mlhs_add($1, $2);
06096                     %*/
06097                     }
06098     break;
06099 
06100   case 79:
06101 
06102 /* Line 1806 of yacc.c  */
06103 #line 1526 "parse.y"
06104     {
06105                     /*%%%*/
06106                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
06107                     /*%
06108                         $$ = mlhs_add_star($1, $3);
06109                     %*/
06110                     }
06111     break;
06112 
06113   case 80:
06114 
06115 /* Line 1806 of yacc.c  */
06116 #line 1534 "parse.y"
06117     {
06118                     /*%%%*/
06119                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node)));
06120                     /*%
06121                         $1 = mlhs_add_star($1, $3);
06122                         $$ = mlhs_add($1, $5);
06123                     %*/
06124                     }
06125     break;
06126 
06127   case 81:
06128 
06129 /* Line 1806 of yacc.c  */
06130 #line 1543 "parse.y"
06131     {
06132                     /*%%%*/
06133                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1);
06134                     /*%
06135                         $$ = mlhs_add_star($1, Qnil);
06136                     %*/
06137                     }
06138     break;
06139 
06140   case 82:
06141 
06142 /* Line 1806 of yacc.c  */
06143 #line 1551 "parse.y"
06144     {
06145                     /*%%%*/
06146                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node)));
06147                     /*%
06148                         $1 = mlhs_add_star($1, Qnil);
06149                         $$ = mlhs_add($1, $4);
06150                     %*/
06151                     }
06152     break;
06153 
06154   case 83:
06155 
06156 /* Line 1806 of yacc.c  */
06157 #line 1560 "parse.y"
06158     {
06159                     /*%%%*/
06160                         (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node));
06161                     /*%
06162                         $$ = mlhs_add_star(mlhs_new(), $2);
06163                     %*/
06164                     }
06165     break;
06166 
06167   case 84:
06168 
06169 /* Line 1806 of yacc.c  */
06170 #line 1568 "parse.y"
06171     {
06172                     /*%%%*/
06173                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node)));
06174                     /*%
06175                         $2 = mlhs_add_star(mlhs_new(), $2);
06176                         $$ = mlhs_add($2, $4);
06177                     %*/
06178                     }
06179     break;
06180 
06181   case 85:
06182 
06183 /* Line 1806 of yacc.c  */
06184 #line 1577 "parse.y"
06185     {
06186                     /*%%%*/
06187                         (yyval.node) = NEW_MASGN(0, -1);
06188                     /*%
06189                         $$ = mlhs_add_star(mlhs_new(), Qnil);
06190                     %*/
06191                     }
06192     break;
06193 
06194   case 86:
06195 
06196 /* Line 1806 of yacc.c  */
06197 #line 1585 "parse.y"
06198     {
06199                     /*%%%*/
06200                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
06201                     /*%
06202                         $$ = mlhs_add_star(mlhs_new(), Qnil);
06203                         $$ = mlhs_add($$, $3);
06204                     %*/
06205                     }
06206     break;
06207 
06208   case 88:
06209 
06210 /* Line 1806 of yacc.c  */
06211 #line 1597 "parse.y"
06212     {
06213                     /*%%%*/
06214                         (yyval.node) = (yyvsp[(2) - (3)].node);
06215                     /*%
06216                         $$ = dispatch1(mlhs_paren, $2);
06217                     %*/
06218                     }
06219     break;
06220 
06221   case 89:
06222 
06223 /* Line 1806 of yacc.c  */
06224 #line 1607 "parse.y"
06225     {
06226                     /*%%%*/
06227                         (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node));
06228                     /*%
06229                         $$ = mlhs_add(mlhs_new(), $1);
06230                     %*/
06231                     }
06232     break;
06233 
06234   case 90:
06235 
06236 /* Line 1806 of yacc.c  */
06237 #line 1615 "parse.y"
06238     {
06239                     /*%%%*/
06240                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
06241                     /*%
06242                         $$ = mlhs_add($1, $2);
06243                     %*/
06244                     }
06245     break;
06246 
06247   case 91:
06248 
06249 /* Line 1806 of yacc.c  */
06250 #line 1625 "parse.y"
06251     {
06252                     /*%%%*/
06253                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
06254                     /*%
06255                         $$ = mlhs_add(mlhs_new(), $1);
06256                     %*/
06257                     }
06258     break;
06259 
06260   case 92:
06261 
06262 /* Line 1806 of yacc.c  */
06263 #line 1633 "parse.y"
06264     {
06265                     /*%%%*/
06266                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
06267                     /*%
06268                         $$ = mlhs_add($1, $3);
06269                     %*/
06270                     }
06271     break;
06272 
06273   case 93:
06274 
06275 /* Line 1806 of yacc.c  */
06276 #line 1643 "parse.y"
06277     {
06278                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06279                     }
06280     break;
06281 
06282   case 94:
06283 
06284 /* Line 1806 of yacc.c  */
06285 #line 1647 "parse.y"
06286     {
06287                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06288                     }
06289     break;
06290 
06291   case 95:
06292 
06293 /* Line 1806 of yacc.c  */
06294 #line 1651 "parse.y"
06295     {
06296                     /*%%%*/
06297                         (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
06298                     /*%
06299                         $$ = dispatch2(aref_field, $1, escape_Qundef($3));
06300                     %*/
06301                     }
06302     break;
06303 
06304   case 96:
06305 
06306 /* Line 1806 of yacc.c  */
06307 #line 1659 "parse.y"
06308     {
06309                     /*%%%*/
06310                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06311                     /*%
06312                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06313                     %*/
06314                     }
06315     break;
06316 
06317   case 97:
06318 
06319 /* Line 1806 of yacc.c  */
06320 #line 1667 "parse.y"
06321     {
06322                     /*%%%*/
06323                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06324                     /*%
06325                         $$ = dispatch2(const_path_field, $1, $3);
06326                     %*/
06327                     }
06328     break;
06329 
06330   case 98:
06331 
06332 /* Line 1806 of yacc.c  */
06333 #line 1675 "parse.y"
06334     {
06335                     /*%%%*/
06336                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06337                     /*%
06338                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06339                     %*/
06340                     }
06341     break;
06342 
06343   case 99:
06344 
06345 /* Line 1806 of yacc.c  */
06346 #line 1683 "parse.y"
06347     {
06348                     /*%%%*/
06349                         if (in_def || in_single)
06350                             yyerror("dynamic constant assignment");
06351                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
06352                     /*%
06353                         if (in_def || in_single)
06354                             yyerror("dynamic constant assignment");
06355                         $$ = dispatch2(const_path_field, $1, $3);
06356                     %*/
06357                     }
06358     break;
06359 
06360   case 100:
06361 
06362 /* Line 1806 of yacc.c  */
06363 #line 1695 "parse.y"
06364     {
06365                     /*%%%*/
06366                         if (in_def || in_single)
06367                             yyerror("dynamic constant assignment");
06368                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
06369                     /*%
06370                         $$ = dispatch1(top_const_field, $2);
06371                     %*/
06372                     }
06373     break;
06374 
06375   case 101:
06376 
06377 /* Line 1806 of yacc.c  */
06378 #line 1705 "parse.y"
06379     {
06380                     /*%%%*/
06381                         rb_backref_error((yyvsp[(1) - (1)].node));
06382                         (yyval.node) = NEW_BEGIN(0);
06383                     /*%
06384                         $$ = dispatch1(var_field, $1);
06385                         $$ = dispatch1(assign_error, $$);
06386                     %*/
06387                     }
06388     break;
06389 
06390   case 102:
06391 
06392 /* Line 1806 of yacc.c  */
06393 #line 1717 "parse.y"
06394     {
06395                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06396                     /*%%%*/
06397                         if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
06398                     /*%
06399                         $$ = dispatch1(var_field, $$);
06400                     %*/
06401                     }
06402     break;
06403 
06404   case 103:
06405 
06406 /* Line 1806 of yacc.c  */
06407 #line 1726 "parse.y"
06408     {
06409                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06410                     /*%%%*/
06411                         if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
06412                     /*%
06413                         $$ = dispatch1(var_field, $$);
06414                     %*/
06415                     }
06416     break;
06417 
06418   case 104:
06419 
06420 /* Line 1806 of yacc.c  */
06421 #line 1735 "parse.y"
06422     {
06423                     /*%%%*/
06424                         (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
06425                     /*%
06426                         $$ = dispatch2(aref_field, $1, escape_Qundef($3));
06427                     %*/
06428                     }
06429     break;
06430 
06431   case 105:
06432 
06433 /* Line 1806 of yacc.c  */
06434 #line 1743 "parse.y"
06435     {
06436                     /*%%%*/
06437                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06438                     /*%
06439                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06440                     %*/
06441                     }
06442     break;
06443 
06444   case 106:
06445 
06446 /* Line 1806 of yacc.c  */
06447 #line 1751 "parse.y"
06448     {
06449                     /*%%%*/
06450                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06451                     /*%
06452                         $$ = dispatch3(field, $1, ripper_intern("::"), $3);
06453                     %*/
06454                     }
06455     break;
06456 
06457   case 107:
06458 
06459 /* Line 1806 of yacc.c  */
06460 #line 1759 "parse.y"
06461     {
06462                     /*%%%*/
06463                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06464                     /*%
06465                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06466                     %*/
06467                     }
06468     break;
06469 
06470   case 108:
06471 
06472 /* Line 1806 of yacc.c  */
06473 #line 1767 "parse.y"
06474     {
06475                     /*%%%*/
06476                         if (in_def || in_single)
06477                             yyerror("dynamic constant assignment");
06478                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
06479                     /*%
06480                         $$ = dispatch2(const_path_field, $1, $3);
06481                         if (in_def || in_single) {
06482                             $$ = dispatch1(assign_error, $$);
06483                         }
06484                     %*/
06485                     }
06486     break;
06487 
06488   case 109:
06489 
06490 /* Line 1806 of yacc.c  */
06491 #line 1780 "parse.y"
06492     {
06493                     /*%%%*/
06494                         if (in_def || in_single)
06495                             yyerror("dynamic constant assignment");
06496                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
06497                     /*%
06498                         $$ = dispatch1(top_const_field, $2);
06499                         if (in_def || in_single) {
06500                             $$ = dispatch1(assign_error, $$);
06501                         }
06502                     %*/
06503                     }
06504     break;
06505 
06506   case 110:
06507 
06508 /* Line 1806 of yacc.c  */
06509 #line 1793 "parse.y"
06510     {
06511                     /*%%%*/
06512                         rb_backref_error((yyvsp[(1) - (1)].node));
06513                         (yyval.node) = NEW_BEGIN(0);
06514                     /*%
06515                         $$ = dispatch1(assign_error, $1);
06516                     %*/
06517                     }
06518     break;
06519 
06520   case 111:
06521 
06522 /* Line 1806 of yacc.c  */
06523 #line 1804 "parse.y"
06524     {
06525                     /*%%%*/
06526                         yyerror("class/module name must be CONSTANT");
06527                     /*%
06528                         $$ = dispatch1(class_name_error, $1);
06529                     %*/
06530                     }
06531     break;
06532 
06533   case 113:
06534 
06535 /* Line 1806 of yacc.c  */
06536 #line 1815 "parse.y"
06537     {
06538                     /*%%%*/
06539                         (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
06540                     /*%
06541                         $$ = dispatch1(top_const_ref, $2);
06542                     %*/
06543                     }
06544     break;
06545 
06546   case 114:
06547 
06548 /* Line 1806 of yacc.c  */
06549 #line 1823 "parse.y"
06550     {
06551                     /*%%%*/
06552                         (yyval.node) = NEW_COLON2(0, (yyval.node));
06553                     /*%
06554                         $$ = dispatch1(const_ref, $1);
06555                     %*/
06556                     }
06557     break;
06558 
06559   case 115:
06560 
06561 /* Line 1806 of yacc.c  */
06562 #line 1831 "parse.y"
06563     {
06564                     /*%%%*/
06565                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06566                     /*%
06567                         $$ = dispatch2(const_path_ref, $1, $3);
06568                     %*/
06569                     }
06570     break;
06571 
06572   case 119:
06573 
06574 /* Line 1806 of yacc.c  */
06575 #line 1844 "parse.y"
06576     {
06577                         lex_state = EXPR_ENDFN;
06578                         (yyval.id) = (yyvsp[(1) - (1)].id);
06579                     }
06580     break;
06581 
06582   case 120:
06583 
06584 /* Line 1806 of yacc.c  */
06585 #line 1849 "parse.y"
06586     {
06587                         lex_state = EXPR_ENDFN;
06588                     /*%%%*/
06589                         (yyval.id) = (yyvsp[(1) - (1)].id);
06590                     /*%
06591                         $$ = $1;
06592                     %*/
06593                     }
06594     break;
06595 
06596   case 123:
06597 
06598 /* Line 1806 of yacc.c  */
06599 #line 1864 "parse.y"
06600     {
06601                     /*%%%*/
06602                         (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
06603                     /*%
06604                         $$ = dispatch1(symbol_literal, $1);
06605                     %*/
06606                     }
06607     break;
06608 
06609   case 125:
06610 
06611 /* Line 1806 of yacc.c  */
06612 #line 1875 "parse.y"
06613     {
06614                     /*%%%*/
06615                         (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node));
06616                     /*%
06617                         $$ = rb_ary_new3(1, $1);
06618                     %*/
06619                     }
06620     break;
06621 
06622   case 126:
06623 
06624 /* Line 1806 of yacc.c  */
06625 #line 1882 "parse.y"
06626     {lex_state = EXPR_FNAME;}
06627     break;
06628 
06629   case 127:
06630 
06631 /* Line 1806 of yacc.c  */
06632 #line 1883 "parse.y"
06633     {
06634                     /*%%%*/
06635                         (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node)));
06636                     /*%
06637                         rb_ary_push($1, $4);
06638                     %*/
06639                     }
06640     break;
06641 
06642   case 128:
06643 
06644 /* Line 1806 of yacc.c  */
06645 #line 1892 "parse.y"
06646     { ifndef_ripper((yyval.id) = '|'); }
06647     break;
06648 
06649   case 129:
06650 
06651 /* Line 1806 of yacc.c  */
06652 #line 1893 "parse.y"
06653     { ifndef_ripper((yyval.id) = '^'); }
06654     break;
06655 
06656   case 130:
06657 
06658 /* Line 1806 of yacc.c  */
06659 #line 1894 "parse.y"
06660     { ifndef_ripper((yyval.id) = '&'); }
06661     break;
06662 
06663   case 131:
06664 
06665 /* Line 1806 of yacc.c  */
06666 #line 1895 "parse.y"
06667     { ifndef_ripper((yyval.id) = tCMP); }
06668     break;
06669 
06670   case 132:
06671 
06672 /* Line 1806 of yacc.c  */
06673 #line 1896 "parse.y"
06674     { ifndef_ripper((yyval.id) = tEQ); }
06675     break;
06676 
06677   case 133:
06678 
06679 /* Line 1806 of yacc.c  */
06680 #line 1897 "parse.y"
06681     { ifndef_ripper((yyval.id) = tEQQ); }
06682     break;
06683 
06684   case 134:
06685 
06686 /* Line 1806 of yacc.c  */
06687 #line 1898 "parse.y"
06688     { ifndef_ripper((yyval.id) = tMATCH); }
06689     break;
06690 
06691   case 135:
06692 
06693 /* Line 1806 of yacc.c  */
06694 #line 1899 "parse.y"
06695     { ifndef_ripper((yyval.id) = tNMATCH); }
06696     break;
06697 
06698   case 136:
06699 
06700 /* Line 1806 of yacc.c  */
06701 #line 1900 "parse.y"
06702     { ifndef_ripper((yyval.id) = '>'); }
06703     break;
06704 
06705   case 137:
06706 
06707 /* Line 1806 of yacc.c  */
06708 #line 1901 "parse.y"
06709     { ifndef_ripper((yyval.id) = tGEQ); }
06710     break;
06711 
06712   case 138:
06713 
06714 /* Line 1806 of yacc.c  */
06715 #line 1902 "parse.y"
06716     { ifndef_ripper((yyval.id) = '<'); }
06717     break;
06718 
06719   case 139:
06720 
06721 /* Line 1806 of yacc.c  */
06722 #line 1903 "parse.y"
06723     { ifndef_ripper((yyval.id) = tLEQ); }
06724     break;
06725 
06726   case 140:
06727 
06728 /* Line 1806 of yacc.c  */
06729 #line 1904 "parse.y"
06730     { ifndef_ripper((yyval.id) = tNEQ); }
06731     break;
06732 
06733   case 141:
06734 
06735 /* Line 1806 of yacc.c  */
06736 #line 1905 "parse.y"
06737     { ifndef_ripper((yyval.id) = tLSHFT); }
06738     break;
06739 
06740   case 142:
06741 
06742 /* Line 1806 of yacc.c  */
06743 #line 1906 "parse.y"
06744     { ifndef_ripper((yyval.id) = tRSHFT); }
06745     break;
06746 
06747   case 143:
06748 
06749 /* Line 1806 of yacc.c  */
06750 #line 1907 "parse.y"
06751     { ifndef_ripper((yyval.id) = '+'); }
06752     break;
06753 
06754   case 144:
06755 
06756 /* Line 1806 of yacc.c  */
06757 #line 1908 "parse.y"
06758     { ifndef_ripper((yyval.id) = '-'); }
06759     break;
06760 
06761   case 145:
06762 
06763 /* Line 1806 of yacc.c  */
06764 #line 1909 "parse.y"
06765     { ifndef_ripper((yyval.id) = '*'); }
06766     break;
06767 
06768   case 146:
06769 
06770 /* Line 1806 of yacc.c  */
06771 #line 1910 "parse.y"
06772     { ifndef_ripper((yyval.id) = '*'); }
06773     break;
06774 
06775   case 147:
06776 
06777 /* Line 1806 of yacc.c  */
06778 #line 1911 "parse.y"
06779     { ifndef_ripper((yyval.id) = '/'); }
06780     break;
06781 
06782   case 148:
06783 
06784 /* Line 1806 of yacc.c  */
06785 #line 1912 "parse.y"
06786     { ifndef_ripper((yyval.id) = '%'); }
06787     break;
06788 
06789   case 149:
06790 
06791 /* Line 1806 of yacc.c  */
06792 #line 1913 "parse.y"
06793     { ifndef_ripper((yyval.id) = tPOW); }
06794     break;
06795 
06796   case 150:
06797 
06798 /* Line 1806 of yacc.c  */
06799 #line 1914 "parse.y"
06800     { ifndef_ripper((yyval.id) = tDSTAR); }
06801     break;
06802 
06803   case 151:
06804 
06805 /* Line 1806 of yacc.c  */
06806 #line 1915 "parse.y"
06807     { ifndef_ripper((yyval.id) = '!'); }
06808     break;
06809 
06810   case 152:
06811 
06812 /* Line 1806 of yacc.c  */
06813 #line 1916 "parse.y"
06814     { ifndef_ripper((yyval.id) = '~'); }
06815     break;
06816 
06817   case 153:
06818 
06819 /* Line 1806 of yacc.c  */
06820 #line 1917 "parse.y"
06821     { ifndef_ripper((yyval.id) = tUPLUS); }
06822     break;
06823 
06824   case 154:
06825 
06826 /* Line 1806 of yacc.c  */
06827 #line 1918 "parse.y"
06828     { ifndef_ripper((yyval.id) = tUMINUS); }
06829     break;
06830 
06831   case 155:
06832 
06833 /* Line 1806 of yacc.c  */
06834 #line 1919 "parse.y"
06835     { ifndef_ripper((yyval.id) = tAREF); }
06836     break;
06837 
06838   case 156:
06839 
06840 /* Line 1806 of yacc.c  */
06841 #line 1920 "parse.y"
06842     { ifndef_ripper((yyval.id) = tASET); }
06843     break;
06844 
06845   case 157:
06846 
06847 /* Line 1806 of yacc.c  */
06848 #line 1921 "parse.y"
06849     { ifndef_ripper((yyval.id) = '`'); }
06850     break;
06851 
06852   case 199:
06853 
06854 /* Line 1806 of yacc.c  */
06855 #line 1939 "parse.y"
06856     {
06857                     /*%%%*/
06858                         value_expr((yyvsp[(3) - (3)].node));
06859                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
06860                     /*%
06861                         $$ = dispatch2(assign, $1, $3);
06862                     %*/
06863                     }
06864     break;
06865 
06866   case 200:
06867 
06868 /* Line 1806 of yacc.c  */
06869 #line 1948 "parse.y"
06870     {
06871                     /*%%%*/
06872                         value_expr((yyvsp[(3) - (5)].node));
06873                         (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
06874                         (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node));
06875                     /*%
06876                         $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
06877                     %*/
06878                     }
06879     break;
06880 
06881   case 201:
06882 
06883 /* Line 1806 of yacc.c  */
06884 #line 1958 "parse.y"
06885     {
06886                         value_expr((yyvsp[(3) - (3)].node));
06887                         (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
06888                     }
06889     break;
06890 
06891   case 202:
06892 
06893 /* Line 1806 of yacc.c  */
06894 #line 1963 "parse.y"
06895     {
06896                     /*%%%*/
06897                         value_expr((yyvsp[(3) - (5)].node));
06898                         (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
06899                     /*%
06900                         $3 = dispatch2(rescue_mod, $3, $5);
06901                     %*/
06902                         (yyval.node) = new_op_assign((yyvsp[(1) - (5)].node), (yyvsp[(2) - (5)].id), (yyvsp[(3) - (5)].node));
06903                     }
06904     break;
06905 
06906   case 203:
06907 
06908 /* Line 1806 of yacc.c  */
06909 #line 1973 "parse.y"
06910     {
06911                     /*%%%*/
06912                         NODE *args;
06913 
06914                         value_expr((yyvsp[(6) - (6)].node));
06915                         if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
06916                         if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) {
06917                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
06918                         }
06919                         else {
06920                             args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
06921                         }
06922                         if ((yyvsp[(5) - (6)].id) == tOROP) {
06923                             (yyvsp[(5) - (6)].id) = 0;
06924                         }
06925                         else if ((yyvsp[(5) - (6)].id) == tANDOP) {
06926                             (yyvsp[(5) - (6)].id) = 1;
06927                         }
06928                         (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
06929                         fixpos((yyval.node), (yyvsp[(1) - (6)].node));
06930                     /*%
06931                         $1 = dispatch2(aref_field, $1, escape_Qundef($3));
06932                         $$ = dispatch3(opassign, $1, $5, $6);
06933                     %*/
06934                     }
06935     break;
06936 
06937   case 204:
06938 
06939 /* Line 1806 of yacc.c  */
06940 #line 1999 "parse.y"
06941     {
06942                         value_expr((yyvsp[(5) - (5)].node));
06943                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
06944                     }
06945     break;
06946 
06947   case 205:
06948 
06949 /* Line 1806 of yacc.c  */
06950 #line 2004 "parse.y"
06951     {
06952                         value_expr((yyvsp[(5) - (5)].node));
06953                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
06954                     }
06955     break;
06956 
06957   case 206:
06958 
06959 /* Line 1806 of yacc.c  */
06960 #line 2009 "parse.y"
06961     {
06962                         value_expr((yyvsp[(5) - (5)].node));
06963                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
06964                     }
06965     break;
06966 
06967   case 207:
06968 
06969 /* Line 1806 of yacc.c  */
06970 #line 2014 "parse.y"
06971     {
06972                     /*%%%*/
06973                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
06974                         (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
06975                     /*%
06976                         $$ = dispatch2(const_path_field, $1, $3);
06977                         $$ = dispatch3(opassign, $$, $4, $5);
06978                     %*/
06979                     }
06980     break;
06981 
06982   case 208:
06983 
06984 /* Line 1806 of yacc.c  */
06985 #line 2024 "parse.y"
06986     {
06987                     /*%%%*/
06988                         (yyval.node) = NEW_COLON3((yyvsp[(2) - (4)].id));
06989                         (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
06990                     /*%
06991                         $$ = dispatch1(top_const_field, $2);
06992                         $$ = dispatch3(opassign, $$, $3, $4);
06993                     %*/
06994                     }
06995     break;
06996 
06997   case 209:
06998 
06999 /* Line 1806 of yacc.c  */
07000 #line 2034 "parse.y"
07001     {
07002                     /*%%%*/
07003                         rb_backref_error((yyvsp[(1) - (3)].node));
07004                         (yyval.node) = NEW_BEGIN(0);
07005                     /*%
07006                         $$ = dispatch1(var_field, $1);
07007                         $$ = dispatch3(opassign, $$, $2, $3);
07008                         $$ = dispatch1(assign_error, $$);
07009                     %*/
07010                     }
07011     break;
07012 
07013   case 210:
07014 
07015 /* Line 1806 of yacc.c  */
07016 #line 2045 "parse.y"
07017     {
07018                     /*%%%*/
07019                         value_expr((yyvsp[(1) - (3)].node));
07020                         value_expr((yyvsp[(3) - (3)].node));
07021                         (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07022                         if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
07023                             nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
07024                             deferred_nodes = list_append(deferred_nodes, (yyval.node));
07025                         }
07026                     /*%
07027                         $$ = dispatch2(dot2, $1, $3);
07028                     %*/
07029                     }
07030     break;
07031 
07032   case 211:
07033 
07034 /* Line 1806 of yacc.c  */
07035 #line 2059 "parse.y"
07036     {
07037                     /*%%%*/
07038                         value_expr((yyvsp[(1) - (3)].node));
07039                         value_expr((yyvsp[(3) - (3)].node));
07040                         (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07041                         if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
07042                             nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
07043                             deferred_nodes = list_append(deferred_nodes, (yyval.node));
07044                         }
07045                     /*%
07046                         $$ = dispatch2(dot3, $1, $3);
07047                     %*/
07048                     }
07049     break;
07050 
07051   case 212:
07052 
07053 /* Line 1806 of yacc.c  */
07054 #line 2073 "parse.y"
07055     {
07056                     /*%%%*/
07057                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '+', (yyvsp[(3) - (3)].node));
07058                     /*%
07059                         $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
07060                     %*/
07061                     }
07062     break;
07063 
07064   case 213:
07065 
07066 /* Line 1806 of yacc.c  */
07067 #line 2081 "parse.y"
07068     {
07069                     /*%%%*/
07070                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '-', (yyvsp[(3) - (3)].node));
07071                     /*%
07072                         $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
07073                     %*/
07074                     }
07075     break;
07076 
07077   case 214:
07078 
07079 /* Line 1806 of yacc.c  */
07080 #line 2089 "parse.y"
07081     {
07082                     /*%%%*/
07083                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '*', (yyvsp[(3) - (3)].node));
07084                     /*%
07085                         $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
07086                     %*/
07087                     }
07088     break;
07089 
07090   case 215:
07091 
07092 /* Line 1806 of yacc.c  */
07093 #line 2097 "parse.y"
07094     {
07095                     /*%%%*/
07096                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '/', (yyvsp[(3) - (3)].node));
07097                     /*%
07098                         $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
07099                     %*/
07100                     }
07101     break;
07102 
07103   case 216:
07104 
07105 /* Line 1806 of yacc.c  */
07106 #line 2105 "parse.y"
07107     {
07108                     /*%%%*/
07109                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node));
07110                     /*%
07111                         $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
07112                     %*/
07113                     }
07114     break;
07115 
07116   case 217:
07117 
07118 /* Line 1806 of yacc.c  */
07119 #line 2113 "parse.y"
07120     {
07121                     /*%%%*/
07122                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node));
07123                     /*%
07124                         $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
07125                     %*/
07126                     }
07127     break;
07128 
07129   case 218:
07130 
07131 /* Line 1806 of yacc.c  */
07132 #line 2121 "parse.y"
07133     {
07134                     /*%%%*/
07135                         (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
07136                     /*%
07137                         $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
07138                         $$ = dispatch2(unary, ripper_intern("-@"), $$);
07139                     %*/
07140                     }
07141     break;
07142 
07143   case 219:
07144 
07145 /* Line 1806 of yacc.c  */
07146 #line 2130 "parse.y"
07147     {
07148                     /*%%%*/
07149                         (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
07150                     /*%
07151                         $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
07152                         $$ = dispatch2(unary, ripper_intern("-@"), $$);
07153                     %*/
07154                     }
07155     break;
07156 
07157   case 220:
07158 
07159 /* Line 1806 of yacc.c  */
07160 #line 2139 "parse.y"
07161     {
07162                     /*%%%*/
07163                         (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS);
07164                     /*%
07165                         $$ = dispatch2(unary, ripper_intern("+@"), $2);
07166                     %*/
07167                     }
07168     break;
07169 
07170   case 221:
07171 
07172 /* Line 1806 of yacc.c  */
07173 #line 2147 "parse.y"
07174     {
07175                     /*%%%*/
07176                         (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS);
07177                     /*%
07178                         $$ = dispatch2(unary, ripper_intern("-@"), $2);
07179                     %*/
07180                     }
07181     break;
07182 
07183   case 222:
07184 
07185 /* Line 1806 of yacc.c  */
07186 #line 2155 "parse.y"
07187     {
07188                     /*%%%*/
07189                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '|', (yyvsp[(3) - (3)].node));
07190                     /*%
07191                         $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
07192                     %*/
07193                     }
07194     break;
07195 
07196   case 223:
07197 
07198 /* Line 1806 of yacc.c  */
07199 #line 2163 "parse.y"
07200     {
07201                     /*%%%*/
07202                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '^', (yyvsp[(3) - (3)].node));
07203                     /*%
07204                         $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
07205                     %*/
07206                     }
07207     break;
07208 
07209   case 224:
07210 
07211 /* Line 1806 of yacc.c  */
07212 #line 2171 "parse.y"
07213     {
07214                     /*%%%*/
07215                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node));
07216                     /*%
07217                         $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
07218                     %*/
07219                     }
07220     break;
07221 
07222   case 225:
07223 
07224 /* Line 1806 of yacc.c  */
07225 #line 2179 "parse.y"
07226     {
07227                     /*%%%*/
07228                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node));
07229                     /*%
07230                         $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
07231                     %*/
07232                     }
07233     break;
07234 
07235   case 226:
07236 
07237 /* Line 1806 of yacc.c  */
07238 #line 2187 "parse.y"
07239     {
07240                     /*%%%*/
07241                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node));
07242                     /*%
07243                         $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
07244                     %*/
07245                     }
07246     break;
07247 
07248   case 227:
07249 
07250 /* Line 1806 of yacc.c  */
07251 #line 2195 "parse.y"
07252     {
07253                     /*%%%*/
07254                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node));
07255                     /*%
07256                         $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
07257                     %*/
07258                     }
07259     break;
07260 
07261   case 228:
07262 
07263 /* Line 1806 of yacc.c  */
07264 #line 2203 "parse.y"
07265     {
07266                     /*%%%*/
07267                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node));
07268                     /*%
07269                         $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
07270                     %*/
07271                     }
07272     break;
07273 
07274   case 229:
07275 
07276 /* Line 1806 of yacc.c  */
07277 #line 2211 "parse.y"
07278     {
07279                     /*%%%*/
07280                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node));
07281                     /*%
07282                         $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
07283                     %*/
07284                     }
07285     break;
07286 
07287   case 230:
07288 
07289 /* Line 1806 of yacc.c  */
07290 #line 2219 "parse.y"
07291     {
07292                     /*%%%*/
07293                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node));
07294                     /*%
07295                         $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
07296                     %*/
07297                     }
07298     break;
07299 
07300   case 231:
07301 
07302 /* Line 1806 of yacc.c  */
07303 #line 2227 "parse.y"
07304     {
07305                     /*%%%*/
07306                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node));
07307                     /*%
07308                         $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
07309                     %*/
07310                     }
07311     break;
07312 
07313   case 232:
07314 
07315 /* Line 1806 of yacc.c  */
07316 #line 2235 "parse.y"
07317     {
07318                     /*%%%*/
07319                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node));
07320                     /*%
07321                         $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
07322                     %*/
07323                     }
07324     break;
07325 
07326   case 233:
07327 
07328 /* Line 1806 of yacc.c  */
07329 #line 2243 "parse.y"
07330     {
07331                     /*%%%*/
07332                         (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07333                         if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].node)->nd_lit, T_REGEXP)) {
07334                             (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node));
07335                         }
07336                     /*%
07337                         $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
07338                     %*/
07339                     }
07340     break;
07341 
07342   case 234:
07343 
07344 /* Line 1806 of yacc.c  */
07345 #line 2254 "parse.y"
07346     {
07347                     /*%%%*/
07348                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node));
07349                     /*%
07350                         $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
07351                     %*/
07352                     }
07353     break;
07354 
07355   case 235:
07356 
07357 /* Line 1806 of yacc.c  */
07358 #line 2262 "parse.y"
07359     {
07360                     /*%%%*/
07361                         (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
07362                     /*%
07363                         $$ = dispatch2(unary, ID2SYM('!'), $2);
07364                     %*/
07365                     }
07366     break;
07367 
07368   case 236:
07369 
07370 /* Line 1806 of yacc.c  */
07371 #line 2270 "parse.y"
07372     {
07373                     /*%%%*/
07374                         (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~');
07375                     /*%
07376                         $$ = dispatch2(unary, ID2SYM('~'), $2);
07377                     %*/
07378                     }
07379     break;
07380 
07381   case 237:
07382 
07383 /* Line 1806 of yacc.c  */
07384 #line 2278 "parse.y"
07385     {
07386                     /*%%%*/
07387                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node));
07388                     /*%
07389                         $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
07390                     %*/
07391                     }
07392     break;
07393 
07394   case 238:
07395 
07396 /* Line 1806 of yacc.c  */
07397 #line 2286 "parse.y"
07398     {
07399                     /*%%%*/
07400                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node));
07401                     /*%
07402                         $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
07403                     %*/
07404                     }
07405     break;
07406 
07407   case 239:
07408 
07409 /* Line 1806 of yacc.c  */
07410 #line 2294 "parse.y"
07411     {
07412                     /*%%%*/
07413                         (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07414                     /*%
07415                         $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
07416                     %*/
07417                     }
07418     break;
07419 
07420   case 240:
07421 
07422 /* Line 1806 of yacc.c  */
07423 #line 2302 "parse.y"
07424     {
07425                     /*%%%*/
07426                         (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07427                     /*%
07428                         $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
07429                     %*/
07430                     }
07431     break;
07432 
07433   case 241:
07434 
07435 /* Line 1806 of yacc.c  */
07436 #line 2309 "parse.y"
07437     {in_defined = 1;}
07438     break;
07439 
07440   case 242:
07441 
07442 /* Line 1806 of yacc.c  */
07443 #line 2310 "parse.y"
07444     {
07445                     /*%%%*/
07446                         in_defined = 0;
07447                         (yyval.node) = NEW_DEFINED((yyvsp[(4) - (4)].node));
07448                     /*%
07449                         in_defined = 0;
07450                         $$ = dispatch1(defined, $4);
07451                     %*/
07452                     }
07453     break;
07454 
07455   case 243:
07456 
07457 /* Line 1806 of yacc.c  */
07458 #line 2320 "parse.y"
07459     {
07460                     /*%%%*/
07461                         value_expr((yyvsp[(1) - (6)].node));
07462                         (yyval.node) = NEW_IF(cond((yyvsp[(1) - (6)].node)), (yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
07463                         fixpos((yyval.node), (yyvsp[(1) - (6)].node));
07464                     /*%
07465                         $$ = dispatch3(ifop, $1, $3, $6);
07466                     %*/
07467                     }
07468     break;
07469 
07470   case 244:
07471 
07472 /* Line 1806 of yacc.c  */
07473 #line 2330 "parse.y"
07474     {
07475                         (yyval.node) = (yyvsp[(1) - (1)].node);
07476                     }
07477     break;
07478 
07479   case 245:
07480 
07481 /* Line 1806 of yacc.c  */
07482 #line 2336 "parse.y"
07483     {
07484                     /*%%%*/
07485                         value_expr((yyvsp[(1) - (1)].node));
07486                         (yyval.node) = (yyvsp[(1) - (1)].node);
07487                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
07488                     /*%
07489                         $$ = $1;
07490                     %*/
07491                     }
07492     break;
07493 
07494   case 247:
07495 
07496 /* Line 1806 of yacc.c  */
07497 #line 2349 "parse.y"
07498     {
07499                         (yyval.node) = (yyvsp[(1) - (2)].node);
07500                     }
07501     break;
07502 
07503   case 248:
07504 
07505 /* Line 1806 of yacc.c  */
07506 #line 2353 "parse.y"
07507     {
07508                     /*%%%*/
07509                         (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
07510                     /*%
07511                         $$ = arg_add_assocs($1, $3);
07512                     %*/
07513                     }
07514     break;
07515 
07516   case 249:
07517 
07518 /* Line 1806 of yacc.c  */
07519 #line 2361 "parse.y"
07520     {
07521                     /*%%%*/
07522                         (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
07523                     /*%
07524                         $$ = arg_add_assocs(arg_new(), $1);
07525                     %*/
07526                     }
07527     break;
07528 
07529   case 250:
07530 
07531 /* Line 1806 of yacc.c  */
07532 #line 2371 "parse.y"
07533     {
07534                     /*%%%*/
07535                         (yyval.node) = (yyvsp[(2) - (3)].node);
07536                     /*%
07537                         $$ = dispatch1(arg_paren, escape_Qundef($2));
07538                     %*/
07539                     }
07540     break;
07541 
07542   case 255:
07543 
07544 /* Line 1806 of yacc.c  */
07545 #line 2387 "parse.y"
07546     {
07547                       (yyval.node) = (yyvsp[(1) - (2)].node);
07548                     }
07549     break;
07550 
07551   case 256:
07552 
07553 /* Line 1806 of yacc.c  */
07554 #line 2391 "parse.y"
07555     {
07556                     /*%%%*/
07557                         (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
07558                     /*%
07559                         $$ = arg_add_assocs($1, $3);
07560                     %*/
07561                     }
07562     break;
07563 
07564   case 257:
07565 
07566 /* Line 1806 of yacc.c  */
07567 #line 2399 "parse.y"
07568     {
07569                     /*%%%*/
07570                         (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
07571                     /*%
07572                         $$ = arg_add_assocs(arg_new(), $1);
07573                     %*/
07574                     }
07575     break;
07576 
07577   case 258:
07578 
07579 /* Line 1806 of yacc.c  */
07580 #line 2409 "parse.y"
07581     {
07582                     /*%%%*/
07583                         value_expr((yyvsp[(1) - (1)].node));
07584                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
07585                     /*%
07586                         $$ = arg_add(arg_new(), $1);
07587                     %*/
07588                     }
07589     break;
07590 
07591   case 259:
07592 
07593 /* Line 1806 of yacc.c  */
07594 #line 2418 "parse.y"
07595     {
07596                     /*%%%*/
07597                         (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
07598                     /*%
07599                         $$ = arg_add_optblock($1, $2);
07600                     %*/
07601                     }
07602     break;
07603 
07604   case 260:
07605 
07606 /* Line 1806 of yacc.c  */
07607 #line 2426 "parse.y"
07608     {
07609                     /*%%%*/
07610                         (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
07611                         (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node));
07612                     /*%
07613                         $$ = arg_add_assocs(arg_new(), $1);
07614                         $$ = arg_add_optblock($$, $2);
07615                     %*/
07616                     }
07617     break;
07618 
07619   case 261:
07620 
07621 /* Line 1806 of yacc.c  */
07622 #line 2436 "parse.y"
07623     {
07624                     /*%%%*/
07625                         (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
07626                         (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node));
07627                     /*%
07628                         $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
07629                     %*/
07630                     }
07631     break;
07632 
07633   case 263:
07634 
07635 /* Line 1806 of yacc.c  */
07636 #line 2453 "parse.y"
07637     {
07638                         (yyval.val) = cmdarg_stack;
07639                         CMDARG_PUSH(1);
07640                     }
07641     break;
07642 
07643   case 264:
07644 
07645 /* Line 1806 of yacc.c  */
07646 #line 2458 "parse.y"
07647     {
07648                         /* CMDARG_POP() */
07649                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07650                         (yyval.node) = (yyvsp[(2) - (2)].node);
07651                     }
07652     break;
07653 
07654   case 265:
07655 
07656 /* Line 1806 of yacc.c  */
07657 #line 2466 "parse.y"
07658     {
07659                     /*%%%*/
07660                         (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node));
07661                     /*%
07662                         $$ = $2;
07663                     %*/
07664                     }
07665     break;
07666 
07667   case 266:
07668 
07669 /* Line 1806 of yacc.c  */
07670 #line 2476 "parse.y"
07671     {
07672                         (yyval.node) = (yyvsp[(2) - (2)].node);
07673                     }
07674     break;
07675 
07676   case 267:
07677 
07678 /* Line 1806 of yacc.c  */
07679 #line 2480 "parse.y"
07680     {
07681                         (yyval.node) = 0;
07682                     }
07683     break;
07684 
07685   case 268:
07686 
07687 /* Line 1806 of yacc.c  */
07688 #line 2486 "parse.y"
07689     {
07690                     /*%%%*/
07691                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
07692                     /*%
07693                         $$ = arg_add(arg_new(), $1);
07694                     %*/
07695                     }
07696     break;
07697 
07698   case 269:
07699 
07700 /* Line 1806 of yacc.c  */
07701 #line 2494 "parse.y"
07702     {
07703                     /*%%%*/
07704                         (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
07705                     /*%
07706                         $$ = arg_add_star(arg_new(), $2);
07707                     %*/
07708                     }
07709     break;
07710 
07711   case 270:
07712 
07713 /* Line 1806 of yacc.c  */
07714 #line 2502 "parse.y"
07715     {
07716                     /*%%%*/
07717                         NODE *n1;
07718                         if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
07719                             (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
07720                         }
07721                         else {
07722                             (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07723                         }
07724                     /*%
07725                         $$ = arg_add($1, $3);
07726                     %*/
07727                     }
07728     break;
07729 
07730   case 271:
07731 
07732 /* Line 1806 of yacc.c  */
07733 #line 2516 "parse.y"
07734     {
07735                     /*%%%*/
07736                         NODE *n1;
07737                         if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
07738                             (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
07739                         }
07740                         else {
07741                             (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
07742                         }
07743                     /*%
07744                         $$ = arg_add_star($1, $4);
07745                     %*/
07746                     }
07747     break;
07748 
07749   case 272:
07750 
07751 /* Line 1806 of yacc.c  */
07752 #line 2532 "parse.y"
07753     {
07754                     /*%%%*/
07755                         NODE *n1;
07756                         if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
07757                             (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
07758                         }
07759                         else {
07760                             (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07761                         }
07762                     /*%
07763                         $$ = mrhs_add(args2mrhs($1), $3);
07764                     %*/
07765                     }
07766     break;
07767 
07768   case 273:
07769 
07770 /* Line 1806 of yacc.c  */
07771 #line 2546 "parse.y"
07772     {
07773                     /*%%%*/
07774                         NODE *n1;
07775                         if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY &&
07776                             (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
07777                             (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
07778                         }
07779                         else {
07780                             (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
07781                         }
07782                     /*%
07783                         $$ = mrhs_add_star(args2mrhs($1), $4);
07784                     %*/
07785                     }
07786     break;
07787 
07788   case 274:
07789 
07790 /* Line 1806 of yacc.c  */
07791 #line 2561 "parse.y"
07792     {
07793                     /*%%%*/
07794                         (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
07795                     /*%
07796                         $$ = mrhs_add_star(mrhs_new(), $2);
07797                     %*/
07798                     }
07799     break;
07800 
07801   case 285:
07802 
07803 /* Line 1806 of yacc.c  */
07804 #line 2581 "parse.y"
07805     {
07806                     /*%%%*/
07807                         (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
07808                     /*%
07809                         $$ = method_arg(dispatch1(fcall, $1), arg_new());
07810                     %*/
07811                     }
07812     break;
07813 
07814   case 286:
07815 
07816 /* Line 1806 of yacc.c  */
07817 #line 2589 "parse.y"
07818     {
07819                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07820                         cmdarg_stack = 0;
07821                     /*%%%*/
07822                         (yyval.num) = ruby_sourceline;
07823                     /*%
07824                     %*/
07825                     }
07826     break;
07827 
07828   case 287:
07829 
07830 /* Line 1806 of yacc.c  */
07831 #line 2599 "parse.y"
07832     {
07833                         cmdarg_stack = (yyvsp[(1) - (4)].val);
07834                     /*%%%*/
07835                         if ((yyvsp[(3) - (4)].node) == NULL) {
07836                             (yyval.node) = NEW_NIL();
07837                         }
07838                         else {
07839                             if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE ||
07840                                 nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE)
07841                                 nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num));
07842                             (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node));
07843                         }
07844                         nd_set_line((yyval.node), (yyvsp[(2) - (4)].num));
07845                     /*%
07846                         $$ = dispatch1(begin, $3);
07847                     %*/
07848                     }
07849     break;
07850 
07851   case 288:
07852 
07853 /* Line 1806 of yacc.c  */
07854 #line 2616 "parse.y"
07855     {lex_state = EXPR_ENDARG;}
07856     break;
07857 
07858   case 289:
07859 
07860 /* Line 1806 of yacc.c  */
07861 #line 2617 "parse.y"
07862     {
07863                     /*%%%*/
07864                         (yyval.node) = 0;
07865                     /*%
07866                         $$ = dispatch1(paren, 0);
07867                     %*/
07868                     }
07869     break;
07870 
07871   case 290:
07872 
07873 /* Line 1806 of yacc.c  */
07874 #line 2625 "parse.y"
07875     {
07876                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07877                         cmdarg_stack = 0;
07878                     }
07879     break;
07880 
07881   case 291:
07882 
07883 /* Line 1806 of yacc.c  */
07884 #line 2629 "parse.y"
07885     {lex_state = EXPR_ENDARG;}
07886     break;
07887 
07888   case 292:
07889 
07890 /* Line 1806 of yacc.c  */
07891 #line 2630 "parse.y"
07892     {
07893                         cmdarg_stack = (yyvsp[(1) - (5)].val);
07894                     /*%%%*/
07895                         (yyval.node) = (yyvsp[(3) - (5)].node);
07896                     /*%
07897                         $$ = dispatch1(paren, $3);
07898                     %*/
07899                     }
07900     break;
07901 
07902   case 293:
07903 
07904 /* Line 1806 of yacc.c  */
07905 #line 2639 "parse.y"
07906     {
07907                     /*%%%*/
07908                         (yyval.node) = (yyvsp[(2) - (3)].node);
07909                     /*%
07910                         $$ = dispatch1(paren, $2);
07911                     %*/
07912                     }
07913     break;
07914 
07915   case 294:
07916 
07917 /* Line 1806 of yacc.c  */
07918 #line 2647 "parse.y"
07919     {
07920                     /*%%%*/
07921                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
07922                     /*%
07923                         $$ = dispatch2(const_path_ref, $1, $3);
07924                     %*/
07925                     }
07926     break;
07927 
07928   case 295:
07929 
07930 /* Line 1806 of yacc.c  */
07931 #line 2655 "parse.y"
07932     {
07933                     /*%%%*/
07934                         (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
07935                     /*%
07936                         $$ = dispatch1(top_const_ref, $2);
07937                     %*/
07938                     }
07939     break;
07940 
07941   case 296:
07942 
07943 /* Line 1806 of yacc.c  */
07944 #line 2663 "parse.y"
07945     {
07946                     /*%%%*/
07947                         if ((yyvsp[(2) - (3)].node) == 0) {
07948                             (yyval.node) = NEW_ZARRAY(); /* zero length array*/
07949                         }
07950                         else {
07951                             (yyval.node) = (yyvsp[(2) - (3)].node);
07952                         }
07953                     /*%
07954                         $$ = dispatch1(array, escape_Qundef($2));
07955                     %*/
07956                     }
07957     break;
07958 
07959   case 297:
07960 
07961 /* Line 1806 of yacc.c  */
07962 #line 2676 "parse.y"
07963     {
07964                     /*%%%*/
07965                         (yyval.node) = NEW_HASH((yyvsp[(2) - (3)].node));
07966                     /*%
07967                         $$ = dispatch1(hash, escape_Qundef($2));
07968                     %*/
07969                     }
07970     break;
07971 
07972   case 298:
07973 
07974 /* Line 1806 of yacc.c  */
07975 #line 2684 "parse.y"
07976     {
07977                     /*%%%*/
07978                         (yyval.node) = NEW_RETURN(0);
07979                     /*%
07980                         $$ = dispatch0(return0);
07981                     %*/
07982                     }
07983     break;
07984 
07985   case 299:
07986 
07987 /* Line 1806 of yacc.c  */
07988 #line 2692 "parse.y"
07989     {
07990                     /*%%%*/
07991                         (yyval.node) = new_yield((yyvsp[(3) - (4)].node));
07992                     /*%
07993                         $$ = dispatch1(yield, dispatch1(paren, $3));
07994                     %*/
07995                     }
07996     break;
07997 
07998   case 300:
07999 
08000 /* Line 1806 of yacc.c  */
08001 #line 2700 "parse.y"
08002     {
08003                     /*%%%*/
08004                         (yyval.node) = NEW_YIELD(0);
08005                     /*%
08006                         $$ = dispatch1(yield, dispatch1(paren, arg_new()));
08007                     %*/
08008                     }
08009     break;
08010 
08011   case 301:
08012 
08013 /* Line 1806 of yacc.c  */
08014 #line 2708 "parse.y"
08015     {
08016                     /*%%%*/
08017                         (yyval.node) = NEW_YIELD(0);
08018                     /*%
08019                         $$ = dispatch0(yield0);
08020                     %*/
08021                     }
08022     break;
08023 
08024   case 302:
08025 
08026 /* Line 1806 of yacc.c  */
08027 #line 2715 "parse.y"
08028     {in_defined = 1;}
08029     break;
08030 
08031   case 303:
08032 
08033 /* Line 1806 of yacc.c  */
08034 #line 2716 "parse.y"
08035     {
08036                     /*%%%*/
08037                         in_defined = 0;
08038                         (yyval.node) = NEW_DEFINED((yyvsp[(5) - (6)].node));
08039                     /*%
08040                         in_defined = 0;
08041                         $$ = dispatch1(defined, $5);
08042                     %*/
08043                     }
08044     break;
08045 
08046   case 304:
08047 
08048 /* Line 1806 of yacc.c  */
08049 #line 2726 "parse.y"
08050     {
08051                     /*%%%*/
08052                         (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!');
08053                     /*%
08054                         $$ = dispatch2(unary, ripper_intern("not"), $3);
08055                     %*/
08056                     }
08057     break;
08058 
08059   case 305:
08060 
08061 /* Line 1806 of yacc.c  */
08062 #line 2734 "parse.y"
08063     {
08064                     /*%%%*/
08065                         (yyval.node) = call_uni_op(cond(NEW_NIL()), '!');
08066                     /*%
08067                         $$ = dispatch2(unary, ripper_intern("not"), Qnil);
08068                     %*/
08069                     }
08070     break;
08071 
08072   case 306:
08073 
08074 /* Line 1806 of yacc.c  */
08075 #line 2742 "parse.y"
08076     {
08077                     /*%%%*/
08078                         (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
08079                         (yyval.node) = (yyvsp[(2) - (2)].node);
08080                     /*%
08081                         $$ = method_arg(dispatch1(fcall, $1), arg_new());
08082                         $$ = method_add_block($$, $2);
08083                     %*/
08084                     }
08085     break;
08086 
08087   case 308:
08088 
08089 /* Line 1806 of yacc.c  */
08090 #line 2753 "parse.y"
08091     {
08092                     /*%%%*/
08093                         block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
08094                         (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
08095                         (yyval.node) = (yyvsp[(2) - (2)].node);
08096                     /*%
08097                         $$ = method_add_block($1, $2);
08098                     %*/
08099                     }
08100     break;
08101 
08102   case 309:
08103 
08104 /* Line 1806 of yacc.c  */
08105 #line 2763 "parse.y"
08106     {
08107                         (yyval.node) = (yyvsp[(2) - (2)].node);
08108                     }
08109     break;
08110 
08111   case 310:
08112 
08113 /* Line 1806 of yacc.c  */
08114 #line 2770 "parse.y"
08115     {
08116                     /*%%%*/
08117                         (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
08118                         fixpos((yyval.node), (yyvsp[(2) - (6)].node));
08119                     /*%
08120                         $$ = dispatch3(if, $2, $4, escape_Qundef($5));
08121                     %*/
08122                     }
08123     break;
08124 
08125   case 311:
08126 
08127 /* Line 1806 of yacc.c  */
08128 #line 2782 "parse.y"
08129     {
08130                     /*%%%*/
08131                         (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
08132                         fixpos((yyval.node), (yyvsp[(2) - (6)].node));
08133                     /*%
08134                         $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
08135                     %*/
08136                     }
08137     break;
08138 
08139   case 312:
08140 
08141 /* Line 1806 of yacc.c  */
08142 #line 2790 "parse.y"
08143     {COND_PUSH(1);}
08144     break;
08145 
08146   case 313:
08147 
08148 /* Line 1806 of yacc.c  */
08149 #line 2790 "parse.y"
08150     {COND_POP();}
08151     break;
08152 
08153   case 314:
08154 
08155 /* Line 1806 of yacc.c  */
08156 #line 2793 "parse.y"
08157     {
08158                     /*%%%*/
08159                         (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
08160                         fixpos((yyval.node), (yyvsp[(3) - (7)].node));
08161                     /*%
08162                         $$ = dispatch2(while, $3, $6);
08163                     %*/
08164                     }
08165     break;
08166 
08167   case 315:
08168 
08169 /* Line 1806 of yacc.c  */
08170 #line 2801 "parse.y"
08171     {COND_PUSH(1);}
08172     break;
08173 
08174   case 316:
08175 
08176 /* Line 1806 of yacc.c  */
08177 #line 2801 "parse.y"
08178     {COND_POP();}
08179     break;
08180 
08181   case 317:
08182 
08183 /* Line 1806 of yacc.c  */
08184 #line 2804 "parse.y"
08185     {
08186                     /*%%%*/
08187                         (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
08188                         fixpos((yyval.node), (yyvsp[(3) - (7)].node));
08189                     /*%
08190                         $$ = dispatch2(until, $3, $6);
08191                     %*/
08192                     }
08193     break;
08194 
08195   case 318:
08196 
08197 /* Line 1806 of yacc.c  */
08198 #line 2815 "parse.y"
08199     {
08200                     /*%%%*/
08201                         (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
08202                         fixpos((yyval.node), (yyvsp[(2) - (5)].node));
08203                     /*%
08204                         $$ = dispatch2(case, $2, $4);
08205                     %*/
08206                     }
08207     break;
08208 
08209   case 319:
08210 
08211 /* Line 1806 of yacc.c  */
08212 #line 2824 "parse.y"
08213     {
08214                     /*%%%*/
08215                         (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node));
08216                     /*%
08217                         $$ = dispatch2(case, Qnil, $3);
08218                     %*/
08219                     }
08220     break;
08221 
08222   case 320:
08223 
08224 /* Line 1806 of yacc.c  */
08225 #line 2832 "parse.y"
08226     {COND_PUSH(1);}
08227     break;
08228 
08229   case 321:
08230 
08231 /* Line 1806 of yacc.c  */
08232 #line 2834 "parse.y"
08233     {COND_POP();}
08234     break;
08235 
08236   case 322:
08237 
08238 /* Line 1806 of yacc.c  */
08239 #line 2837 "parse.y"
08240     {
08241                     /*%%%*/
08242                         /*
08243                          *  for a, b, c in e
08244                          *  #=>
08245                          *  e.each{|*x| a, b, c = x
08246                          *
08247                          *  for a in e
08248                          *  #=>
08249                          *  e.each{|x| a, = x}
08250                          */
08251                         ID id = internal_id();
08252                         ID *tbl = ALLOC_N(ID, 2);
08253                         NODE *m = NEW_ARGS_AUX(0, 0);
08254                         NODE *args, *scope;
08255 
08256                         if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) {
08257                             /* if args.length == 1 && args[0].kind_of?(Array)
08258                              *   args = args[0]
08259                              * end
08260                              */
08261                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
08262                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
08263                             m->nd_next = block_append(
08264                                 NEW_IF(
08265                                     NEW_NODE(NODE_AND,
08266                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
08267                                                       idEq, one),
08268                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
08269                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
08270                                              0),
08271                                     NEW_DASGN_CURR(id,
08272                                                    NEW_CALL(NEW_DVAR(id), idAREF, zero)),
08273                                     0),
08274                                 node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id)));
08275 
08276                             args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08277                         }
08278                         else {
08279                             if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN ||
08280                                 nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN ||
08281                                 nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) {
08282                                 (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id);
08283                                 m->nd_plen = 1;
08284                                 m->nd_next = (yyvsp[(2) - (9)].node);
08285                                 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
08286                             }
08287                             else {
08288                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id));
08289                                 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08290                             }
08291                         }
08292                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args);
08293                         tbl[0] = 1; tbl[1] = id;
08294                         (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope);
08295                         fixpos((yyval.node), (yyvsp[(2) - (9)].node));
08296                     /*%
08297                         $$ = dispatch3(for, $2, $5, $8);
08298                     %*/
08299                     }
08300     break;
08301 
08302   case 323:
08303 
08304 /* Line 1806 of yacc.c  */
08305 #line 2898 "parse.y"
08306     {
08307                         if (in_def || in_single)
08308                             yyerror("class definition in method body");
08309                         local_push(0);
08310                     /*%%%*/
08311                         (yyval.num) = ruby_sourceline;
08312                     /*%
08313                     %*/
08314                     }
08315     break;
08316 
08317   case 324:
08318 
08319 /* Line 1806 of yacc.c  */
08320 #line 2909 "parse.y"
08321     {
08322                     /*%%%*/
08323                         (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node));
08324                         nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
08325                     /*%
08326                         $$ = dispatch3(class, $2, $3, $5);
08327                     %*/
08328                         local_pop();
08329                     }
08330     break;
08331 
08332   case 325:
08333 
08334 /* Line 1806 of yacc.c  */
08335 #line 2919 "parse.y"
08336     {
08337                         (yyval.num) = in_def;
08338                         in_def = 0;
08339                     }
08340     break;
08341 
08342   case 326:
08343 
08344 /* Line 1806 of yacc.c  */
08345 #line 2924 "parse.y"
08346     {
08347                         (yyval.num) = in_single;
08348                         in_single = 0;
08349                         local_push(0);
08350                     }
08351     break;
08352 
08353   case 327:
08354 
08355 /* Line 1806 of yacc.c  */
08356 #line 2931 "parse.y"
08357     {
08358                     /*%%%*/
08359                         (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node));
08360                         fixpos((yyval.node), (yyvsp[(3) - (8)].node));
08361                     /*%
08362                         $$ = dispatch2(sclass, $3, $7);
08363                     %*/
08364                         local_pop();
08365                         in_def = (yyvsp[(4) - (8)].num);
08366                         in_single = (yyvsp[(6) - (8)].num);
08367                     }
08368     break;
08369 
08370   case 328:
08371 
08372 /* Line 1806 of yacc.c  */
08373 #line 2943 "parse.y"
08374     {
08375                         if (in_def || in_single)
08376                             yyerror("module definition in method body");
08377                         local_push(0);
08378                     /*%%%*/
08379                         (yyval.num) = ruby_sourceline;
08380                     /*%
08381                     %*/
08382                     }
08383     break;
08384 
08385   case 329:
08386 
08387 /* Line 1806 of yacc.c  */
08388 #line 2954 "parse.y"
08389     {
08390                     /*%%%*/
08391                         (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
08392                         nd_set_line((yyval.node), (yyvsp[(3) - (5)].num));
08393                     /*%
08394                         $$ = dispatch2(module, $2, $4);
08395                     %*/
08396                         local_pop();
08397                     }
08398     break;
08399 
08400   case 330:
08401 
08402 /* Line 1806 of yacc.c  */
08403 #line 2964 "parse.y"
08404     {
08405                         (yyval.id) = cur_mid;
08406                         cur_mid = (yyvsp[(2) - (2)].id);
08407                         in_def++;
08408                         local_push(0);
08409                     }
08410     break;
08411 
08412   case 331:
08413 
08414 /* Line 1806 of yacc.c  */
08415 #line 2973 "parse.y"
08416     {
08417                     /*%%%*/
08418                         NODE *body = remove_begin((yyvsp[(5) - (6)].node));
08419                         reduce_nodes(&body);
08420                         (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE);
08421                         nd_set_line((yyval.node), (yyvsp[(1) - (6)].num));
08422                     /*%
08423                         $$ = dispatch3(def, $2, $4, $5);
08424                     %*/
08425                         local_pop();
08426                         in_def--;
08427                         cur_mid = (yyvsp[(3) - (6)].id);
08428                     }
08429     break;
08430 
08431   case 332:
08432 
08433 /* Line 1806 of yacc.c  */
08434 #line 2986 "parse.y"
08435     {lex_state = EXPR_FNAME;}
08436     break;
08437 
08438   case 333:
08439 
08440 /* Line 1806 of yacc.c  */
08441 #line 2987 "parse.y"
08442     {
08443                         in_single++;
08444                         lex_state = EXPR_ENDFN; /* force for args */
08445                         local_push(0);
08446                     }
08447     break;
08448 
08449   case 334:
08450 
08451 /* Line 1806 of yacc.c  */
08452 #line 2995 "parse.y"
08453     {
08454                     /*%%%*/
08455                         NODE *body = remove_begin((yyvsp[(8) - (9)].node));
08456                         reduce_nodes(&body);
08457                         (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body);
08458                         nd_set_line((yyval.node), (yyvsp[(1) - (9)].num));
08459                     /*%
08460                         $$ = dispatch5(defs, $2, $3, $5, $7, $8);
08461                     %*/
08462                         local_pop();
08463                         in_single--;
08464                     }
08465     break;
08466 
08467   case 335:
08468 
08469 /* Line 1806 of yacc.c  */
08470 #line 3008 "parse.y"
08471     {
08472                     /*%%%*/
08473                         (yyval.node) = NEW_BREAK(0);
08474                     /*%
08475                         $$ = dispatch1(break, arg_new());
08476                     %*/
08477                     }
08478     break;
08479 
08480   case 336:
08481 
08482 /* Line 1806 of yacc.c  */
08483 #line 3016 "parse.y"
08484     {
08485                     /*%%%*/
08486                         (yyval.node) = NEW_NEXT(0);
08487                     /*%
08488                         $$ = dispatch1(next, arg_new());
08489                     %*/
08490                     }
08491     break;
08492 
08493   case 337:
08494 
08495 /* Line 1806 of yacc.c  */
08496 #line 3024 "parse.y"
08497     {
08498                     /*%%%*/
08499                         (yyval.node) = NEW_REDO();
08500                     /*%
08501                         $$ = dispatch0(redo);
08502                     %*/
08503                     }
08504     break;
08505 
08506   case 338:
08507 
08508 /* Line 1806 of yacc.c  */
08509 #line 3032 "parse.y"
08510     {
08511                     /*%%%*/
08512                         (yyval.node) = NEW_RETRY();
08513                     /*%
08514                         $$ = dispatch0(retry);
08515                     %*/
08516                     }
08517     break;
08518 
08519   case 339:
08520 
08521 /* Line 1806 of yacc.c  */
08522 #line 3042 "parse.y"
08523     {
08524                     /*%%%*/
08525                         value_expr((yyvsp[(1) - (1)].node));
08526                         (yyval.node) = (yyvsp[(1) - (1)].node);
08527                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
08528                     /*%
08529                         $$ = $1;
08530                     %*/
08531                     }
08532     break;
08533 
08534   case 340:
08535 
08536 /* Line 1806 of yacc.c  */
08537 #line 3054 "parse.y"
08538     {
08539                         token_info_push("begin");
08540                     }
08541     break;
08542 
08543   case 341:
08544 
08545 /* Line 1806 of yacc.c  */
08546 #line 3060 "parse.y"
08547     {
08548                         token_info_push("if");
08549                     }
08550     break;
08551 
08552   case 342:
08553 
08554 /* Line 1806 of yacc.c  */
08555 #line 3066 "parse.y"
08556     {
08557                         token_info_push("unless");
08558                     }
08559     break;
08560 
08561   case 343:
08562 
08563 /* Line 1806 of yacc.c  */
08564 #line 3072 "parse.y"
08565     {
08566                         token_info_push("while");
08567                     }
08568     break;
08569 
08570   case 344:
08571 
08572 /* Line 1806 of yacc.c  */
08573 #line 3078 "parse.y"
08574     {
08575                         token_info_push("until");
08576                     }
08577     break;
08578 
08579   case 345:
08580 
08581 /* Line 1806 of yacc.c  */
08582 #line 3084 "parse.y"
08583     {
08584                         token_info_push("case");
08585                     }
08586     break;
08587 
08588   case 346:
08589 
08590 /* Line 1806 of yacc.c  */
08591 #line 3090 "parse.y"
08592     {
08593                         token_info_push("for");
08594                     }
08595     break;
08596 
08597   case 347:
08598 
08599 /* Line 1806 of yacc.c  */
08600 #line 3096 "parse.y"
08601     {
08602                         token_info_push("class");
08603                     }
08604     break;
08605 
08606   case 348:
08607 
08608 /* Line 1806 of yacc.c  */
08609 #line 3102 "parse.y"
08610     {
08611                         token_info_push("module");
08612                     }
08613     break;
08614 
08615   case 349:
08616 
08617 /* Line 1806 of yacc.c  */
08618 #line 3108 "parse.y"
08619     {
08620                         token_info_push("def");
08621                     /*%%%*/
08622                         (yyval.num) = ruby_sourceline;
08623                     /*%
08624                     %*/
08625                     }
08626     break;
08627 
08628   case 350:
08629 
08630 /* Line 1806 of yacc.c  */
08631 #line 3118 "parse.y"
08632     {
08633                         token_info_pop("end");
08634                     }
08635     break;
08636 
08637   case 357:
08638 
08639 /* Line 1806 of yacc.c  */
08640 #line 3148 "parse.y"
08641     {
08642                     /*%%%*/
08643                         (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
08644                         fixpos((yyval.node), (yyvsp[(2) - (5)].node));
08645                     /*%
08646                         $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
08647                     %*/
08648                     }
08649     break;
08650 
08651   case 359:
08652 
08653 /* Line 1806 of yacc.c  */
08654 #line 3160 "parse.y"
08655     {
08656                     /*%%%*/
08657                         (yyval.node) = (yyvsp[(2) - (2)].node);
08658                     /*%
08659                         $$ = dispatch1(else, $2);
08660                     %*/
08661                     }
08662     break;
08663 
08664   case 362:
08665 
08666 /* Line 1806 of yacc.c  */
08667 #line 3174 "parse.y"
08668     {
08669                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
08670                     /*%%%*/
08671                     /*%
08672                         $$ = dispatch1(mlhs_paren, $$);
08673                     %*/
08674                     }
08675     break;
08676 
08677   case 363:
08678 
08679 /* Line 1806 of yacc.c  */
08680 #line 3182 "parse.y"
08681     {
08682                     /*%%%*/
08683                         (yyval.node) = (yyvsp[(2) - (3)].node);
08684                     /*%
08685                         $$ = dispatch1(mlhs_paren, $2);
08686                     %*/
08687                     }
08688     break;
08689 
08690   case 364:
08691 
08692 /* Line 1806 of yacc.c  */
08693 #line 3192 "parse.y"
08694     {
08695                     /*%%%*/
08696                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
08697                     /*%
08698                         $$ = mlhs_add(mlhs_new(), $1);
08699                     %*/
08700                     }
08701     break;
08702 
08703   case 365:
08704 
08705 /* Line 1806 of yacc.c  */
08706 #line 3200 "parse.y"
08707     {
08708                     /*%%%*/
08709                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
08710                     /*%
08711                         $$ = mlhs_add($1, $3);
08712                     %*/
08713                     }
08714     break;
08715 
08716   case 366:
08717 
08718 /* Line 1806 of yacc.c  */
08719 #line 3210 "parse.y"
08720     {
08721                     /*%%%*/
08722                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
08723                     /*%
08724                         $$ = $1;
08725                     %*/
08726                     }
08727     break;
08728 
08729   case 367:
08730 
08731 /* Line 1806 of yacc.c  */
08732 #line 3218 "parse.y"
08733     {
08734                         (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0);
08735                     /*%%%*/
08736                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node));
08737                     /*%
08738                         $$ = mlhs_add_star($1, $$);
08739                     %*/
08740                     }
08741     break;
08742 
08743   case 368:
08744 
08745 /* Line 1806 of yacc.c  */
08746 #line 3227 "parse.y"
08747     {
08748                         (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0);
08749                     /*%%%*/
08750                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node)));
08751                     /*%
08752                         $$ = mlhs_add_star($1, $$);
08753                     %*/
08754                     }
08755     break;
08756 
08757   case 369:
08758 
08759 /* Line 1806 of yacc.c  */
08760 #line 3236 "parse.y"
08761     {
08762                     /*%%%*/
08763                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1);
08764                     /*%
08765                         $$ = mlhs_add_star($1, Qnil);
08766                     %*/
08767                     }
08768     break;
08769 
08770   case 370:
08771 
08772 /* Line 1806 of yacc.c  */
08773 #line 3244 "parse.y"
08774     {
08775                     /*%%%*/
08776                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node)));
08777                     /*%
08778                         $$ = mlhs_add_star($1, $5);
08779                     %*/
08780                     }
08781     break;
08782 
08783   case 371:
08784 
08785 /* Line 1806 of yacc.c  */
08786 #line 3252 "parse.y"
08787     {
08788                         (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0);
08789                     /*%%%*/
08790                         (yyval.node) = NEW_MASGN(0, (yyval.node));
08791                     /*%
08792                         $$ = mlhs_add_star(mlhs_new(), $$);
08793                     %*/
08794                     }
08795     break;
08796 
08797   case 372:
08798 
08799 /* Line 1806 of yacc.c  */
08800 #line 3261 "parse.y"
08801     {
08802                         (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0);
08803                     /*%%%*/
08804                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node)));
08805                     /*%
08806                       #if 0
08807                       TODO: Check me
08808                       #endif
08809                         $$ = mlhs_add_star($$, $4);
08810                     %*/
08811                     }
08812     break;
08813 
08814   case 373:
08815 
08816 /* Line 1806 of yacc.c  */
08817 #line 3273 "parse.y"
08818     {
08819                     /*%%%*/
08820                         (yyval.node) = NEW_MASGN(0, -1);
08821                     /*%
08822                         $$ = mlhs_add_star(mlhs_new(), Qnil);
08823                     %*/
08824                     }
08825     break;
08826 
08827   case 374:
08828 
08829 /* Line 1806 of yacc.c  */
08830 #line 3281 "parse.y"
08831     {
08832                     /*%%%*/
08833                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
08834                     /*%
08835                         $$ = mlhs_add_star(mlhs_new(), Qnil);
08836                     %*/
08837                     }
08838     break;
08839 
08840   case 375:
08841 
08842 /* Line 1806 of yacc.c  */
08843 #line 3292 "parse.y"
08844     {
08845                         (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
08846                     }
08847     break;
08848 
08849   case 376:
08850 
08851 /* Line 1806 of yacc.c  */
08852 #line 3296 "parse.y"
08853     {
08854                         (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
08855                     }
08856     break;
08857 
08858   case 377:
08859 
08860 /* Line 1806 of yacc.c  */
08861 #line 3300 "parse.y"
08862     {
08863                         (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
08864                     }
08865     break;
08866 
08867   case 378:
08868 
08869 /* Line 1806 of yacc.c  */
08870 #line 3304 "parse.y"
08871     {
08872                         (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
08873                     }
08874     break;
08875 
08876   case 379:
08877 
08878 /* Line 1806 of yacc.c  */
08879 #line 3310 "parse.y"
08880     {
08881                         (yyval.node) = (yyvsp[(2) - (2)].node);
08882                     }
08883     break;
08884 
08885   case 380:
08886 
08887 /* Line 1806 of yacc.c  */
08888 #line 3314 "parse.y"
08889     {
08890                         (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
08891                     }
08892     break;
08893 
08894   case 381:
08895 
08896 /* Line 1806 of yacc.c  */
08897 #line 3320 "parse.y"
08898     {
08899                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
08900                     }
08901     break;
08902 
08903   case 382:
08904 
08905 /* Line 1806 of yacc.c  */
08906 #line 3324 "parse.y"
08907     {
08908                         (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
08909                     }
08910     break;
08911 
08912   case 383:
08913 
08914 /* Line 1806 of yacc.c  */
08915 #line 3328 "parse.y"
08916     {
08917                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
08918                     }
08919     break;
08920 
08921   case 384:
08922 
08923 /* Line 1806 of yacc.c  */
08924 #line 3332 "parse.y"
08925     {
08926                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
08927                     }
08928     break;
08929 
08930   case 385:
08931 
08932 /* Line 1806 of yacc.c  */
08933 #line 3336 "parse.y"
08934     {
08935                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
08936                     }
08937     break;
08938 
08939   case 386:
08940 
08941 /* Line 1806 of yacc.c  */
08942 #line 3340 "parse.y"
08943     {
08944                         (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
08945                     /*%%%*/
08946                     /*%
08947                         dispatch1(excessed_comma, $$);
08948                     %*/
08949                     }
08950     break;
08951 
08952   case 387:
08953 
08954 /* Line 1806 of yacc.c  */
08955 #line 3348 "parse.y"
08956     {
08957                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
08958                     }
08959     break;
08960 
08961   case 388:
08962 
08963 /* Line 1806 of yacc.c  */
08964 #line 3352 "parse.y"
08965     {
08966                         (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
08967                     }
08968     break;
08969 
08970   case 389:
08971 
08972 /* Line 1806 of yacc.c  */
08973 #line 3356 "parse.y"
08974     {
08975                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
08976                     }
08977     break;
08978 
08979   case 390:
08980 
08981 /* Line 1806 of yacc.c  */
08982 #line 3360 "parse.y"
08983     {
08984                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
08985                     }
08986     break;
08987 
08988   case 391:
08989 
08990 /* Line 1806 of yacc.c  */
08991 #line 3364 "parse.y"
08992     {
08993                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
08994                     }
08995     break;
08996 
08997   case 392:
08998 
08999 /* Line 1806 of yacc.c  */
09000 #line 3368 "parse.y"
09001     {
09002                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
09003                     }
09004     break;
09005 
09006   case 393:
09007 
09008 /* Line 1806 of yacc.c  */
09009 #line 3372 "parse.y"
09010     {
09011                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
09012                     }
09013     break;
09014 
09015   case 394:
09016 
09017 /* Line 1806 of yacc.c  */
09018 #line 3376 "parse.y"
09019     {
09020                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
09021                     }
09022     break;
09023 
09024   case 395:
09025 
09026 /* Line 1806 of yacc.c  */
09027 #line 3380 "parse.y"
09028     {
09029                         (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
09030                     }
09031     break;
09032 
09033   case 397:
09034 
09035 /* Line 1806 of yacc.c  */
09036 #line 3387 "parse.y"
09037     {
09038                         command_start = TRUE;
09039                     }
09040     break;
09041 
09042   case 398:
09043 
09044 /* Line 1806 of yacc.c  */
09045 #line 3393 "parse.y"
09046     {
09047                     /*%%%*/
09048                         (yyval.node) = 0;
09049                     /*%
09050                         $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09051                                           escape_Qundef($2));
09052                     %*/
09053                     }
09054     break;
09055 
09056   case 399:
09057 
09058 /* Line 1806 of yacc.c  */
09059 #line 3402 "parse.y"
09060     {
09061                     /*%%%*/
09062                         (yyval.node) = 0;
09063                     /*%
09064                         $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09065                                           Qnil);
09066                     %*/
09067                     }
09068     break;
09069 
09070   case 400:
09071 
09072 /* Line 1806 of yacc.c  */
09073 #line 3411 "parse.y"
09074     {
09075                     /*%%%*/
09076                         (yyval.node) = (yyvsp[(2) - (4)].node);
09077                     /*%
09078                         $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
09079                     %*/
09080                     }
09081     break;
09082 
09083   case 401:
09084 
09085 /* Line 1806 of yacc.c  */
09086 #line 3422 "parse.y"
09087     {
09088                       (yyval.node) = 0;
09089                     }
09090     break;
09091 
09092   case 402:
09093 
09094 /* Line 1806 of yacc.c  */
09095 #line 3426 "parse.y"
09096     {
09097                     /*%%%*/
09098                         (yyval.node) = 0;
09099                     /*%
09100                         $$ = $3;
09101                     %*/
09102                     }
09103     break;
09104 
09105   case 405:
09106 
09107 /* Line 1806 of yacc.c  */
09108 #line 3452 "parse.y"
09109     {
09110                         new_bv(get_id((yyvsp[(1) - (1)].id)));
09111                     /*%%%*/
09112                     /*%
09113                         $$ = get_value($1);
09114                     %*/
09115                     }
09116     break;
09117 
09118   case 406:
09119 
09120 /* Line 1806 of yacc.c  */
09121 #line 3460 "parse.y"
09122     {
09123                         (yyval.node) = 0;
09124                     }
09125     break;
09126 
09127   case 407:
09128 
09129 /* Line 1806 of yacc.c  */
09130 #line 3465 "parse.y"
09131     {
09132                         (yyval.vars) = dyna_push();
09133                     }
09134     break;
09135 
09136   case 408:
09137 
09138 /* Line 1806 of yacc.c  */
09139 #line 3468 "parse.y"
09140     {
09141                         (yyval.num) = lpar_beg;
09142                         lpar_beg = ++paren_nest;
09143                     }
09144     break;
09145 
09146   case 409:
09147 
09148 /* Line 1806 of yacc.c  */
09149 #line 3473 "parse.y"
09150     {
09151                         (yyval.num) = ruby_sourceline;
09152                     }
09153     break;
09154 
09155   case 410:
09156 
09157 /* Line 1806 of yacc.c  */
09158 #line 3477 "parse.y"
09159     {
09160                         lpar_beg = (yyvsp[(2) - (5)].num);
09161                     /*%%%*/
09162                         (yyval.node) = NEW_LAMBDA((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
09163                         nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
09164                     /*%
09165                         $$ = dispatch2(lambda, $3, $5);
09166                     %*/
09167                         dyna_pop((yyvsp[(1) - (5)].vars));
09168                     }
09169     break;
09170 
09171   case 411:
09172 
09173 /* Line 1806 of yacc.c  */
09174 #line 3490 "parse.y"
09175     {
09176                     /*%%%*/
09177                         (yyval.node) = (yyvsp[(2) - (4)].node);
09178                     /*%
09179                         $$ = dispatch1(paren, $2);
09180                     %*/
09181                     }
09182     break;
09183 
09184   case 412:
09185 
09186 /* Line 1806 of yacc.c  */
09187 #line 3498 "parse.y"
09188     {
09189                     /*%%%*/
09190                         (yyval.node) = (yyvsp[(1) - (1)].node);
09191                     /*%
09192                         $$ = $1;
09193                     %*/
09194                     }
09195     break;
09196 
09197   case 413:
09198 
09199 /* Line 1806 of yacc.c  */
09200 #line 3508 "parse.y"
09201     {
09202                         (yyval.node) = (yyvsp[(2) - (3)].node);
09203                     }
09204     break;
09205 
09206   case 414:
09207 
09208 /* Line 1806 of yacc.c  */
09209 #line 3512 "parse.y"
09210     {
09211                         (yyval.node) = (yyvsp[(2) - (3)].node);
09212                     }
09213     break;
09214 
09215   case 415:
09216 
09217 /* Line 1806 of yacc.c  */
09218 #line 3518 "parse.y"
09219     {
09220                         (yyvsp[(1) - (1)].vars) = dyna_push();
09221                     /*%%%*/
09222                         (yyval.num) = ruby_sourceline;
09223                     /*% %*/
09224                     }
09225     break;
09226 
09227   case 416:
09228 
09229 /* Line 1806 of yacc.c  */
09230 #line 3527 "parse.y"
09231     {
09232                     /*%%%*/
09233                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
09234                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
09235                     /*%
09236                         $$ = dispatch2(do_block, escape_Qundef($3), $4);
09237                     %*/
09238                         dyna_pop((yyvsp[(1) - (5)].vars));
09239                     }
09240     break;
09241 
09242   case 417:
09243 
09244 /* Line 1806 of yacc.c  */
09245 #line 3539 "parse.y"
09246     {
09247                     /*%%%*/
09248                         if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) {
09249                             compile_error(PARSER_ARG "block given to yield");
09250                         }
09251                         else {
09252                             block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
09253                         }
09254                         (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
09255                         (yyval.node) = (yyvsp[(2) - (2)].node);
09256                         fixpos((yyval.node), (yyvsp[(1) - (2)].node));
09257                     /*%
09258                         $$ = method_add_block($1, $2);
09259                     %*/
09260                     }
09261     break;
09262 
09263   case 418:
09264 
09265 /* Line 1806 of yacc.c  */
09266 #line 3555 "parse.y"
09267     {
09268                     /*%%%*/
09269                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
09270                     /*%
09271                         $$ = dispatch3(call, $1, $2, $3);
09272                         $$ = method_optarg($$, $4);
09273                     %*/
09274                     }
09275     break;
09276 
09277   case 419:
09278 
09279 /* Line 1806 of yacc.c  */
09280 #line 3564 "parse.y"
09281     {
09282                     /*%%%*/
09283                         block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
09284                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
09285                         (yyval.node) = (yyvsp[(5) - (5)].node);
09286                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
09287                     /*%
09288                         $$ = dispatch4(command_call, $1, $2, $3, $4);
09289                         $$ = method_add_block($$, $5);
09290                     %*/
09291                     }
09292     break;
09293 
09294   case 420:
09295 
09296 /* Line 1806 of yacc.c  */
09297 #line 3576 "parse.y"
09298     {
09299                     /*%%%*/
09300                         block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
09301                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
09302                         (yyval.node) = (yyvsp[(5) - (5)].node);
09303                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
09304                     /*%
09305                         $$ = dispatch4(command_call, $1, $2, $3, $4);
09306                         $$ = method_add_block($$, $5);
09307                     %*/
09308                     }
09309     break;
09310 
09311   case 421:
09312 
09313 /* Line 1806 of yacc.c  */
09314 #line 3590 "parse.y"
09315     {
09316                     /*%%%*/
09317                         (yyval.node) = (yyvsp[(1) - (2)].node);
09318                         (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
09319                     /*%
09320                         $$ = method_arg(dispatch1(fcall, $1), $2);
09321                     %*/
09322                     }
09323     break;
09324 
09325   case 422:
09326 
09327 /* Line 1806 of yacc.c  */
09328 #line 3599 "parse.y"
09329     {
09330                     /*%%%*/
09331                         (yyval.num) = ruby_sourceline;
09332                     /*% %*/
09333                     }
09334     break;
09335 
09336   case 423:
09337 
09338 /* Line 1806 of yacc.c  */
09339 #line 3605 "parse.y"
09340     {
09341                     /*%%%*/
09342                         (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
09343                         nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
09344                     /*%
09345                         $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
09346                         $$ = method_optarg($$, $5);
09347                     %*/
09348                     }
09349     break;
09350 
09351   case 424:
09352 
09353 /* Line 1806 of yacc.c  */
09354 #line 3615 "parse.y"
09355     {
09356                     /*%%%*/
09357                         (yyval.num) = ruby_sourceline;
09358                     /*% %*/
09359                     }
09360     break;
09361 
09362   case 425:
09363 
09364 /* Line 1806 of yacc.c  */
09365 #line 3621 "parse.y"
09366     {
09367                     /*%%%*/
09368                         (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
09369                         nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
09370                     /*%
09371                         $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
09372                         $$ = method_optarg($$, $5);
09373                     %*/
09374                     }
09375     break;
09376 
09377   case 426:
09378 
09379 /* Line 1806 of yacc.c  */
09380 #line 3631 "parse.y"
09381     {
09382                     /*%%%*/
09383                         (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0);
09384                     /*%
09385                         $$ = dispatch3(call, $1, ripper_intern("::"), $3);
09386                     %*/
09387                     }
09388     break;
09389 
09390   case 427:
09391 
09392 /* Line 1806 of yacc.c  */
09393 #line 3639 "parse.y"
09394     {
09395                     /*%%%*/
09396                         (yyval.num) = ruby_sourceline;
09397                     /*% %*/
09398                     }
09399     break;
09400 
09401   case 428:
09402 
09403 /* Line 1806 of yacc.c  */
09404 #line 3645 "parse.y"
09405     {
09406                     /*%%%*/
09407                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
09408                         nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
09409                     /*%
09410                         $$ = dispatch3(call, $1, ripper_id2sym('.'),
09411                                        ripper_intern("call"));
09412                         $$ = method_optarg($$, $4);
09413                     %*/
09414                     }
09415     break;
09416 
09417   case 429:
09418 
09419 /* Line 1806 of yacc.c  */
09420 #line 3656 "parse.y"
09421     {
09422                     /*%%%*/
09423                         (yyval.num) = ruby_sourceline;
09424                     /*% %*/
09425                     }
09426     break;
09427 
09428   case 430:
09429 
09430 /* Line 1806 of yacc.c  */
09431 #line 3662 "parse.y"
09432     {
09433                     /*%%%*/
09434                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
09435                         nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
09436                     /*%
09437                         $$ = dispatch3(call, $1, ripper_intern("::"),
09438                                        ripper_intern("call"));
09439                         $$ = method_optarg($$, $4);
09440                     %*/
09441                     }
09442     break;
09443 
09444   case 431:
09445 
09446 /* Line 1806 of yacc.c  */
09447 #line 3673 "parse.y"
09448     {
09449                     /*%%%*/
09450                         (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
09451                     /*%
09452                         $$ = dispatch1(super, $2);
09453                     %*/
09454                     }
09455     break;
09456 
09457   case 432:
09458 
09459 /* Line 1806 of yacc.c  */
09460 #line 3681 "parse.y"
09461     {
09462                     /*%%%*/
09463                         (yyval.node) = NEW_ZSUPER();
09464                     /*%
09465                         $$ = dispatch0(zsuper);
09466                     %*/
09467                     }
09468     break;
09469 
09470   case 433:
09471 
09472 /* Line 1806 of yacc.c  */
09473 #line 3689 "parse.y"
09474     {
09475                     /*%%%*/
09476                         if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF)
09477                             (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node));
09478                         else
09479                             (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node));
09480                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
09481                     /*%
09482                         $$ = dispatch2(aref, $1, escape_Qundef($3));
09483                     %*/
09484                     }
09485     break;
09486 
09487   case 434:
09488 
09489 /* Line 1806 of yacc.c  */
09490 #line 3703 "parse.y"
09491     {
09492                         (yyvsp[(1) - (1)].vars) = dyna_push();
09493                     /*%%%*/
09494                         (yyval.num) = ruby_sourceline;
09495                     /*%
09496                     %*/
09497                     }
09498     break;
09499 
09500   case 435:
09501 
09502 /* Line 1806 of yacc.c  */
09503 #line 3712 "parse.y"
09504     {
09505                     /*%%%*/
09506                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
09507                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
09508                     /*%
09509                         $$ = dispatch2(brace_block, escape_Qundef($3), $4);
09510                     %*/
09511                         dyna_pop((yyvsp[(1) - (5)].vars));
09512                     }
09513     break;
09514 
09515   case 436:
09516 
09517 /* Line 1806 of yacc.c  */
09518 #line 3722 "parse.y"
09519     {
09520                         (yyvsp[(1) - (1)].vars) = dyna_push();
09521                     /*%%%*/
09522                         (yyval.num) = ruby_sourceline;
09523                     /*%
09524                     %*/
09525                     }
09526     break;
09527 
09528   case 437:
09529 
09530 /* Line 1806 of yacc.c  */
09531 #line 3731 "parse.y"
09532     {
09533                     /*%%%*/
09534                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
09535                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
09536                     /*%
09537                         $$ = dispatch2(do_block, escape_Qundef($3), $4);
09538                     %*/
09539                         dyna_pop((yyvsp[(1) - (5)].vars));
09540                     }
09541     break;
09542 
09543   case 438:
09544 
09545 /* Line 1806 of yacc.c  */
09546 #line 3745 "parse.y"
09547     {
09548                     /*%%%*/
09549                         (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
09550                     /*%
09551                         $$ = dispatch3(when, $2, $4, escape_Qundef($5));
09552                     %*/
09553                     }
09554     break;
09555 
09556   case 441:
09557 
09558 /* Line 1806 of yacc.c  */
09559 #line 3761 "parse.y"
09560     {
09561                     /*%%%*/
09562                         if ((yyvsp[(3) - (6)].node)) {
09563                             (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO());
09564                             (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node));
09565                         }
09566                         (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
09567                         fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node));
09568                     /*%
09569                         $$ = dispatch4(rescue,
09570                                        escape_Qundef($2),
09571                                        escape_Qundef($3),
09572                                        escape_Qundef($5),
09573                                        escape_Qundef($6));
09574                     %*/
09575                     }
09576     break;
09577 
09578   case 443:
09579 
09580 /* Line 1806 of yacc.c  */
09581 #line 3781 "parse.y"
09582     {
09583                     /*%%%*/
09584                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
09585                     /*%
09586                         $$ = rb_ary_new3(1, $1);
09587                     %*/
09588                     }
09589     break;
09590 
09591   case 444:
09592 
09593 /* Line 1806 of yacc.c  */
09594 #line 3789 "parse.y"
09595     {
09596                     /*%%%*/
09597                         if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node);
09598                     /*%
09599                         $$ = $1;
09600                     %*/
09601                     }
09602     break;
09603 
09604   case 446:
09605 
09606 /* Line 1806 of yacc.c  */
09607 #line 3800 "parse.y"
09608     {
09609                         (yyval.node) = (yyvsp[(2) - (2)].node);
09610                     }
09611     break;
09612 
09613   case 448:
09614 
09615 /* Line 1806 of yacc.c  */
09616 #line 3807 "parse.y"
09617     {
09618                     /*%%%*/
09619                         (yyval.node) = (yyvsp[(2) - (2)].node);
09620                     /*%
09621                         $$ = dispatch1(ensure, $2);
09622                     %*/
09623                     }
09624     break;
09625 
09626   case 451:
09627 
09628 /* Line 1806 of yacc.c  */
09629 #line 3819 "parse.y"
09630     {
09631                     /*%%%*/
09632                         (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
09633                     /*%
09634                         $$ = dispatch1(symbol_literal, $1);
09635                     %*/
09636                     }
09637     break;
09638 
09639   case 453:
09640 
09641 /* Line 1806 of yacc.c  */
09642 #line 3830 "parse.y"
09643     {
09644                     /*%%%*/
09645                         NODE *node = (yyvsp[(1) - (1)].node);
09646                         if (!node) {
09647                             node = NEW_STR(STR_NEW0());
09648                         }
09649                         else {
09650                             node = evstr2dstr(node);
09651                         }
09652                         (yyval.node) = node;
09653                     /*%
09654                         $$ = $1;
09655                     %*/
09656                     }
09657     break;
09658 
09659   case 456:
09660 
09661 /* Line 1806 of yacc.c  */
09662 #line 3849 "parse.y"
09663     {
09664                     /*%%%*/
09665                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
09666                     /*%
09667                         $$ = dispatch2(string_concat, $1, $2);
09668                     %*/
09669                     }
09670     break;
09671 
09672   case 457:
09673 
09674 /* Line 1806 of yacc.c  */
09675 #line 3859 "parse.y"
09676     {
09677                     /*%%%*/
09678                         (yyval.node) = (yyvsp[(2) - (3)].node);
09679                     /*%
09680                         $$ = dispatch1(string_literal, $2);
09681                     %*/
09682                     }
09683     break;
09684 
09685   case 458:
09686 
09687 /* Line 1806 of yacc.c  */
09688 #line 3869 "parse.y"
09689     {
09690                     /*%%%*/
09691                         NODE *node = (yyvsp[(2) - (3)].node);
09692                         if (!node) {
09693                             node = NEW_XSTR(STR_NEW0());
09694                         }
09695                         else {
09696                             switch (nd_type(node)) {
09697                               case NODE_STR:
09698                                 nd_set_type(node, NODE_XSTR);
09699                                 break;
09700                               case NODE_DSTR:
09701                                 nd_set_type(node, NODE_DXSTR);
09702                                 break;
09703                               default:
09704                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09705                                 break;
09706                             }
09707                         }
09708                         (yyval.node) = node;
09709                     /*%
09710                         $$ = dispatch1(xstring_literal, $2);
09711                     %*/
09712                     }
09713     break;
09714 
09715   case 459:
09716 
09717 /* Line 1806 of yacc.c  */
09718 #line 3896 "parse.y"
09719     {
09720                     /*%%%*/
09721                         int options = (yyvsp[(3) - (3)].num);
09722                         NODE *node = (yyvsp[(2) - (3)].node);
09723                         NODE *list, *prev;
09724                         if (!node) {
09725                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09726                         }
09727                         else switch (nd_type(node)) {
09728                           case NODE_STR:
09729                             {
09730                                 VALUE src = node->nd_lit;
09731                                 nd_set_type(node, NODE_LIT);
09732                                 node->nd_lit = reg_compile(src, options);
09733                             }
09734                             break;
09735                           default:
09736                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09737                           case NODE_DSTR:
09738                             if (options & RE_OPTION_ONCE) {
09739                                 nd_set_type(node, NODE_DREGX_ONCE);
09740                             }
09741                             else {
09742                                 nd_set_type(node, NODE_DREGX);
09743                             }
09744                             node->nd_cflag = options & RE_OPTION_MASK;
09745                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09746                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09747                                 if (nd_type(list->nd_head) == NODE_STR) {
09748                                     VALUE tail = list->nd_head->nd_lit;
09749                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09750                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09751                                         if (!literal_concat0(parser, lit, tail)) {
09752                                             node = 0;
09753                                             break;
09754                                         }
09755                                         rb_str_resize(tail, 0);
09756                                         prev->nd_next = list->nd_next;
09757                                         rb_gc_force_recycle((VALUE)list->nd_head);
09758                                         rb_gc_force_recycle((VALUE)list);
09759                                         list = prev;
09760                                     }
09761                                     else {
09762                                         prev = list;
09763                                     }
09764                                 }
09765                                 else {
09766                                     prev = 0;
09767                                 }
09768                             }
09769                             if (!node->nd_next) {
09770                                 VALUE src = node->nd_lit;
09771                                 nd_set_type(node, NODE_LIT);
09772                                 node->nd_lit = reg_compile(src, options);
09773                             }
09774                             break;
09775                         }
09776                         (yyval.node) = node;
09777                     /*%
09778                         $$ = dispatch2(regexp_literal, $2, $3);
09779                     %*/
09780                     }
09781     break;
09782 
09783   case 460:
09784 
09785 /* Line 1806 of yacc.c  */
09786 #line 3961 "parse.y"
09787     {
09788                     /*%%%*/
09789                         (yyval.node) = NEW_ZARRAY();
09790                     /*%
09791                         $$ = dispatch0(words_new);
09792                         $$ = dispatch1(array, $$);
09793                     %*/
09794                     }
09795     break;
09796 
09797   case 461:
09798 
09799 /* Line 1806 of yacc.c  */
09800 #line 3970 "parse.y"
09801     {
09802                     /*%%%*/
09803                         (yyval.node) = (yyvsp[(2) - (3)].node);
09804                     /*%
09805                         $$ = dispatch1(array, $2);
09806                     %*/
09807                     }
09808     break;
09809 
09810   case 462:
09811 
09812 /* Line 1806 of yacc.c  */
09813 #line 3980 "parse.y"
09814     {
09815                     /*%%%*/
09816                         (yyval.node) = 0;
09817                     /*%
09818                         $$ = dispatch0(words_new);
09819                     %*/
09820                     }
09821     break;
09822 
09823   case 463:
09824 
09825 /* Line 1806 of yacc.c  */
09826 #line 3988 "parse.y"
09827     {
09828                     /*%%%*/
09829                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node)));
09830                     /*%
09831                         $$ = dispatch2(words_add, $1, $2);
09832                     %*/
09833                     }
09834     break;
09835 
09836   case 465:
09837 
09838 /* Line 1806 of yacc.c  */
09839 #line 4006 "parse.y"
09840     {
09841                     /*%%%*/
09842                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
09843                     /*%
09844                         $$ = dispatch2(word_add, $1, $2);
09845                     %*/
09846                     }
09847     break;
09848 
09849   case 466:
09850 
09851 /* Line 1806 of yacc.c  */
09852 #line 4016 "parse.y"
09853     {
09854                     /*%%%*/
09855                         (yyval.node) = NEW_ZARRAY();
09856                     /*%
09857                         $$ = dispatch0(symbols_new);
09858                         $$ = dispatch1(array, $$);
09859                     %*/
09860                     }
09861     break;
09862 
09863   case 467:
09864 
09865 /* Line 1806 of yacc.c  */
09866 #line 4025 "parse.y"
09867     {
09868                     /*%%%*/
09869                         (yyval.node) = (yyvsp[(2) - (3)].node);
09870                     /*%
09871                         $$ = dispatch1(array, $2);
09872                     %*/
09873                     }
09874     break;
09875 
09876   case 468:
09877 
09878 /* Line 1806 of yacc.c  */
09879 #line 4035 "parse.y"
09880     {
09881                     /*%%%*/
09882                         (yyval.node) = 0;
09883                     /*%
09884                         $$ = dispatch0(symbols_new);
09885                     %*/
09886                     }
09887     break;
09888 
09889   case 469:
09890 
09891 /* Line 1806 of yacc.c  */
09892 #line 4043 "parse.y"
09893     {
09894                     /*%%%*/
09895                         (yyvsp[(2) - (3)].node) = evstr2dstr((yyvsp[(2) - (3)].node));
09896                         if (nd_type((yyvsp[(2) - (3)].node)) == NODE_DSTR) {
09897                             nd_set_type((yyvsp[(2) - (3)].node), NODE_DSYM);
09898                         }
09899                         else {
09900                             nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
09901                             (yyvsp[(2) - (3)].node)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].node)->nd_lit);
09902                         }
09903                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
09904                     /*%
09905                         $$ = dispatch2(symbols_add, $1, $2);
09906                     %*/
09907                     }
09908     break;
09909 
09910   case 470:
09911 
09912 /* Line 1806 of yacc.c  */
09913 #line 4061 "parse.y"
09914     {
09915                     /*%%%*/
09916                         (yyval.node) = NEW_ZARRAY();
09917                     /*%
09918                         $$ = dispatch0(qwords_new);
09919                         $$ = dispatch1(array, $$);
09920                     %*/
09921                     }
09922     break;
09923 
09924   case 471:
09925 
09926 /* Line 1806 of yacc.c  */
09927 #line 4070 "parse.y"
09928     {
09929                     /*%%%*/
09930                         (yyval.node) = (yyvsp[(2) - (3)].node);
09931                     /*%
09932                         $$ = dispatch1(array, $2);
09933                     %*/
09934                     }
09935     break;
09936 
09937   case 472:
09938 
09939 /* Line 1806 of yacc.c  */
09940 #line 4080 "parse.y"
09941     {
09942                     /*%%%*/
09943                         (yyval.node) = NEW_ZARRAY();
09944                     /*%
09945                         $$ = dispatch0(qsymbols_new);
09946                         $$ = dispatch1(array, $$);
09947                     %*/
09948                     }
09949     break;
09950 
09951   case 473:
09952 
09953 /* Line 1806 of yacc.c  */
09954 #line 4089 "parse.y"
09955     {
09956                     /*%%%*/
09957                         (yyval.node) = (yyvsp[(2) - (3)].node);
09958                     /*%
09959                         $$ = dispatch1(array, $2);
09960                     %*/
09961                     }
09962     break;
09963 
09964   case 474:
09965 
09966 /* Line 1806 of yacc.c  */
09967 #line 4099 "parse.y"
09968     {
09969                     /*%%%*/
09970                         (yyval.node) = 0;
09971                     /*%
09972                         $$ = dispatch0(qwords_new);
09973                     %*/
09974                     }
09975     break;
09976 
09977   case 475:
09978 
09979 /* Line 1806 of yacc.c  */
09980 #line 4107 "parse.y"
09981     {
09982                     /*%%%*/
09983                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
09984                     /*%
09985                         $$ = dispatch2(qwords_add, $1, $2);
09986                     %*/
09987                     }
09988     break;
09989 
09990   case 476:
09991 
09992 /* Line 1806 of yacc.c  */
09993 #line 4117 "parse.y"
09994     {
09995                     /*%%%*/
09996                         (yyval.node) = 0;
09997                     /*%
09998                         $$ = dispatch0(qsymbols_new);
09999                     %*/
10000                     }
10001     break;
10002 
10003   case 477:
10004 
10005 /* Line 1806 of yacc.c  */
10006 #line 4125 "parse.y"
10007     {
10008                     /*%%%*/
10009                         VALUE lit;
10010                         lit = (yyvsp[(2) - (3)].node)->nd_lit;
10011                         (yyvsp[(2) - (3)].node)->nd_lit = ID2SYM(rb_intern_str(lit));
10012                         nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
10013                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10014                     /*%
10015                         $$ = dispatch2(qsymbols_add, $1, $2);
10016                     %*/
10017                     }
10018     break;
10019 
10020   case 478:
10021 
10022 /* Line 1806 of yacc.c  */
10023 #line 4139 "parse.y"
10024     {
10025                     /*%%%*/
10026                         (yyval.node) = 0;
10027                     /*%
10028                         $$ = dispatch0(string_content);
10029                     %*/
10030                     }
10031     break;
10032 
10033   case 479:
10034 
10035 /* Line 1806 of yacc.c  */
10036 #line 4147 "parse.y"
10037     {
10038                     /*%%%*/
10039                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10040                     /*%
10041                         $$ = dispatch2(string_add, $1, $2);
10042                     %*/
10043                     }
10044     break;
10045 
10046   case 480:
10047 
10048 /* Line 1806 of yacc.c  */
10049 #line 4157 "parse.y"
10050     {
10051                     /*%%%*/
10052                         (yyval.node) = 0;
10053                     /*%
10054                         $$ = dispatch0(xstring_new);
10055                     %*/
10056                     }
10057     break;
10058 
10059   case 481:
10060 
10061 /* Line 1806 of yacc.c  */
10062 #line 4165 "parse.y"
10063     {
10064                     /*%%%*/
10065                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10066                     /*%
10067                         $$ = dispatch2(xstring_add, $1, $2);
10068                     %*/
10069                     }
10070     break;
10071 
10072   case 482:
10073 
10074 /* Line 1806 of yacc.c  */
10075 #line 4175 "parse.y"
10076     {
10077                     /*%%%*/
10078                         (yyval.node) = 0;
10079                     /*%
10080                         $$ = dispatch0(regexp_new);
10081                     %*/
10082                     }
10083     break;
10084 
10085   case 483:
10086 
10087 /* Line 1806 of yacc.c  */
10088 #line 4183 "parse.y"
10089     {
10090                     /*%%%*/
10091                         NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node);
10092                         if (!head) {
10093                             (yyval.node) = tail;
10094                         }
10095                         else if (!tail) {
10096                             (yyval.node) = head;
10097                         }
10098                         else {
10099                             switch (nd_type(head)) {
10100                               case NODE_STR:
10101                                 nd_set_type(head, NODE_DSTR);
10102                                 break;
10103                               case NODE_DSTR:
10104                                 break;
10105                               default:
10106                                 head = list_append(NEW_DSTR(Qnil), head);
10107                                 break;
10108                             }
10109                             (yyval.node) = list_append(head, tail);
10110                         }
10111                     /*%
10112                         $$ = dispatch2(regexp_add, $1, $2);
10113                     %*/
10114                     }
10115     break;
10116 
10117   case 485:
10118 
10119 /* Line 1806 of yacc.c  */
10120 #line 4213 "parse.y"
10121     {
10122                         (yyval.node) = lex_strterm;
10123                         lex_strterm = 0;
10124                         lex_state = EXPR_BEG;
10125                     }
10126     break;
10127 
10128   case 486:
10129 
10130 /* Line 1806 of yacc.c  */
10131 #line 4219 "parse.y"
10132     {
10133                     /*%%%*/
10134                         lex_strterm = (yyvsp[(2) - (3)].node);
10135                         (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node));
10136                     /*%
10137                         lex_strterm = $<node>2;
10138                         $$ = dispatch1(string_dvar, $3);
10139                     %*/
10140                     }
10141     break;
10142 
10143   case 487:
10144 
10145 /* Line 1806 of yacc.c  */
10146 #line 4229 "parse.y"
10147     {
10148                         (yyvsp[(1) - (1)].val) = cond_stack;
10149                         (yyval.val) = cmdarg_stack;
10150                         cond_stack = 0;
10151                         cmdarg_stack = 0;
10152                     }
10153     break;
10154 
10155   case 488:
10156 
10157 /* Line 1806 of yacc.c  */
10158 #line 4235 "parse.y"
10159     {
10160                         (yyval.node) = lex_strterm;
10161                         lex_strterm = 0;
10162                         lex_state = EXPR_BEG;
10163                     }
10164     break;
10165 
10166   case 489:
10167 
10168 /* Line 1806 of yacc.c  */
10169 #line 4240 "parse.y"
10170     {
10171                         (yyval.num) = brace_nest;
10172                         brace_nest = 0;
10173                     }
10174     break;
10175 
10176   case 490:
10177 
10178 /* Line 1806 of yacc.c  */
10179 #line 4245 "parse.y"
10180     {
10181                         cond_stack = (yyvsp[(1) - (6)].val);
10182                         cmdarg_stack = (yyvsp[(2) - (6)].val);
10183                         lex_strterm = (yyvsp[(3) - (6)].node);
10184                         brace_nest = (yyvsp[(4) - (6)].num);
10185                     /*%%%*/
10186                         if ((yyvsp[(5) - (6)].node)) (yyvsp[(5) - (6)].node)->flags &= ~NODE_FL_NEWLINE;
10187                         (yyval.node) = new_evstr((yyvsp[(5) - (6)].node));
10188                     /*%
10189                         $$ = dispatch1(string_embexpr, $5);
10190                     %*/
10191                     }
10192     break;
10193 
10194   case 491:
10195 
10196 /* Line 1806 of yacc.c  */
10197 #line 4260 "parse.y"
10198     {
10199                     /*%%%*/
10200                         (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id));
10201                     /*%
10202                         $$ = dispatch1(var_ref, $1);
10203                     %*/
10204                     }
10205     break;
10206 
10207   case 492:
10208 
10209 /* Line 1806 of yacc.c  */
10210 #line 4268 "parse.y"
10211     {
10212                     /*%%%*/
10213                         (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id));
10214                     /*%
10215                         $$ = dispatch1(var_ref, $1);
10216                     %*/
10217                     }
10218     break;
10219 
10220   case 493:
10221 
10222 /* Line 1806 of yacc.c  */
10223 #line 4276 "parse.y"
10224     {
10225                     /*%%%*/
10226                         (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id));
10227                     /*%
10228                         $$ = dispatch1(var_ref, $1);
10229                     %*/
10230                     }
10231     break;
10232 
10233   case 495:
10234 
10235 /* Line 1806 of yacc.c  */
10236 #line 4287 "parse.y"
10237     {
10238                         lex_state = EXPR_END;
10239                     /*%%%*/
10240                         (yyval.id) = (yyvsp[(2) - (2)].id);
10241                     /*%
10242                         $$ = dispatch1(symbol, $2);
10243                     %*/
10244                     }
10245     break;
10246 
10247   case 500:
10248 
10249 /* Line 1806 of yacc.c  */
10250 #line 4304 "parse.y"
10251     {
10252                         lex_state = EXPR_END;
10253                     /*%%%*/
10254                         (yyval.node) = dsym_node((yyvsp[(2) - (3)].node));
10255                     /*%
10256                         $$ = dispatch1(dyna_symbol, $2);
10257                     %*/
10258                     }
10259     break;
10260 
10261   case 503:
10262 
10263 /* Line 1806 of yacc.c  */
10264 #line 4317 "parse.y"
10265     {
10266                     /*%%%*/
10267                         (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10268                     /*%
10269                         $$ = dispatch2(unary, ripper_intern("-@"), $2);
10270                     %*/
10271                     }
10272     break;
10273 
10274   case 504:
10275 
10276 /* Line 1806 of yacc.c  */
10277 #line 4325 "parse.y"
10278     {
10279                     /*%%%*/
10280                         (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10281                     /*%
10282                         $$ = dispatch2(unary, ripper_intern("-@"), $2);
10283                     %*/
10284                     }
10285     break;
10286 
10287   case 510:
10288 
10289 /* Line 1806 of yacc.c  */
10290 #line 4341 "parse.y"
10291     {ifndef_ripper((yyval.id) = keyword_nil);}
10292     break;
10293 
10294   case 511:
10295 
10296 /* Line 1806 of yacc.c  */
10297 #line 4342 "parse.y"
10298     {ifndef_ripper((yyval.id) = keyword_self);}
10299     break;
10300 
10301   case 512:
10302 
10303 /* Line 1806 of yacc.c  */
10304 #line 4343 "parse.y"
10305     {ifndef_ripper((yyval.id) = keyword_true);}
10306     break;
10307 
10308   case 513:
10309 
10310 /* Line 1806 of yacc.c  */
10311 #line 4344 "parse.y"
10312     {ifndef_ripper((yyval.id) = keyword_false);}
10313     break;
10314 
10315   case 514:
10316 
10317 /* Line 1806 of yacc.c  */
10318 #line 4345 "parse.y"
10319     {ifndef_ripper((yyval.id) = keyword__FILE__);}
10320     break;
10321 
10322   case 515:
10323 
10324 /* Line 1806 of yacc.c  */
10325 #line 4346 "parse.y"
10326     {ifndef_ripper((yyval.id) = keyword__LINE__);}
10327     break;
10328 
10329   case 516:
10330 
10331 /* Line 1806 of yacc.c  */
10332 #line 4347 "parse.y"
10333     {ifndef_ripper((yyval.id) = keyword__ENCODING__);}
10334     break;
10335 
10336   case 517:
10337 
10338 /* Line 1806 of yacc.c  */
10339 #line 4351 "parse.y"
10340     {
10341                     /*%%%*/
10342                         if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10343                     /*%
10344                         if (id_is_var(get_id($1))) {
10345                             $$ = dispatch1(var_ref, $1);
10346                         }
10347                         else {
10348                             $$ = dispatch1(vcall, $1);
10349                         }
10350                     %*/
10351                     }
10352     break;
10353 
10354   case 518:
10355 
10356 /* Line 1806 of yacc.c  */
10357 #line 4364 "parse.y"
10358     {
10359                     /*%%%*/
10360                         if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10361                     /*%
10362                         $$ = dispatch1(var_ref, $1);
10363                     %*/
10364                     }
10365     break;
10366 
10367   case 519:
10368 
10369 /* Line 1806 of yacc.c  */
10370 #line 4374 "parse.y"
10371     {
10372                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10373                     /*%%%*/
10374                     /*%
10375                         $$ = dispatch1(var_field, $$);
10376                     %*/
10377                     }
10378     break;
10379 
10380   case 520:
10381 
10382 /* Line 1806 of yacc.c  */
10383 #line 4382 "parse.y"
10384     {
10385                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10386                     /*%%%*/
10387                     /*%
10388                         $$ = dispatch1(var_field, $$);
10389                     %*/
10390                     }
10391     break;
10392 
10393   case 523:
10394 
10395 /* Line 1806 of yacc.c  */
10396 #line 4396 "parse.y"
10397     {
10398                     /*%%%*/
10399                         (yyval.node) = 0;
10400                     /*%
10401                         $$ = Qnil;
10402                     %*/
10403                     }
10404     break;
10405 
10406   case 524:
10407 
10408 /* Line 1806 of yacc.c  */
10409 #line 4404 "parse.y"
10410     {
10411                         lex_state = EXPR_BEG;
10412                         command_start = TRUE;
10413                     }
10414     break;
10415 
10416   case 525:
10417 
10418 /* Line 1806 of yacc.c  */
10419 #line 4409 "parse.y"
10420     {
10421                         (yyval.node) = (yyvsp[(3) - (4)].node);
10422                     }
10423     break;
10424 
10425   case 526:
10426 
10427 /* Line 1806 of yacc.c  */
10428 #line 4413 "parse.y"
10429     {
10430                     /*%%%*/
10431                         yyerrok;
10432                         (yyval.node) = 0;
10433                     /*%
10434                         yyerrok;
10435                         $$ = Qnil;
10436                     %*/
10437                     }
10438     break;
10439 
10440   case 527:
10441 
10442 /* Line 1806 of yacc.c  */
10443 #line 4425 "parse.y"
10444     {
10445                     /*%%%*/
10446                         (yyval.node) = (yyvsp[(2) - (3)].node);
10447                     /*%
10448                         $$ = dispatch1(paren, $2);
10449                     %*/
10450                         lex_state = EXPR_BEG;
10451                         command_start = TRUE;
10452                     }
10453     break;
10454 
10455   case 528:
10456 
10457 /* Line 1806 of yacc.c  */
10458 #line 4435 "parse.y"
10459     {
10460                         (yyval.node) = (yyvsp[(1) - (2)].node);
10461                         lex_state = EXPR_BEG;
10462                         command_start = TRUE;
10463                     }
10464     break;
10465 
10466   case 529:
10467 
10468 /* Line 1806 of yacc.c  */
10469 #line 4443 "parse.y"
10470     {
10471                         (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
10472                     }
10473     break;
10474 
10475   case 530:
10476 
10477 /* Line 1806 of yacc.c  */
10478 #line 4447 "parse.y"
10479     {
10480                         (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
10481                     }
10482     break;
10483 
10484   case 531:
10485 
10486 /* Line 1806 of yacc.c  */
10487 #line 4451 "parse.y"
10488     {
10489                         (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
10490                     }
10491     break;
10492 
10493   case 532:
10494 
10495 /* Line 1806 of yacc.c  */
10496 #line 4455 "parse.y"
10497     {
10498                         (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
10499                     }
10500     break;
10501 
10502   case 533:
10503 
10504 /* Line 1806 of yacc.c  */
10505 #line 4461 "parse.y"
10506     {
10507                         (yyval.node) = (yyvsp[(2) - (2)].node);
10508                     }
10509     break;
10510 
10511   case 534:
10512 
10513 /* Line 1806 of yacc.c  */
10514 #line 4465 "parse.y"
10515     {
10516                         (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10517                     }
10518     break;
10519 
10520   case 535:
10521 
10522 /* Line 1806 of yacc.c  */
10523 #line 4471 "parse.y"
10524     {
10525                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
10526                     }
10527     break;
10528 
10529   case 536:
10530 
10531 /* Line 1806 of yacc.c  */
10532 #line 4475 "parse.y"
10533     {
10534                         (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
10535                     }
10536     break;
10537 
10538   case 537:
10539 
10540 /* Line 1806 of yacc.c  */
10541 #line 4479 "parse.y"
10542     {
10543                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
10544                     }
10545     break;
10546 
10547   case 538:
10548 
10549 /* Line 1806 of yacc.c  */
10550 #line 4483 "parse.y"
10551     {
10552                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10553                     }
10554     break;
10555 
10556   case 539:
10557 
10558 /* Line 1806 of yacc.c  */
10559 #line 4487 "parse.y"
10560     {
10561                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10562                     }
10563     break;
10564 
10565   case 540:
10566 
10567 /* Line 1806 of yacc.c  */
10568 #line 4491 "parse.y"
10569     {
10570                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10571                     }
10572     break;
10573 
10574   case 541:
10575 
10576 /* Line 1806 of yacc.c  */
10577 #line 4495 "parse.y"
10578     {
10579                         (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
10580                     }
10581     break;
10582 
10583   case 542:
10584 
10585 /* Line 1806 of yacc.c  */
10586 #line 4499 "parse.y"
10587     {
10588                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10589                     }
10590     break;
10591 
10592   case 543:
10593 
10594 /* Line 1806 of yacc.c  */
10595 #line 4503 "parse.y"
10596     {
10597                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10598                     }
10599     break;
10600 
10601   case 544:
10602 
10603 /* Line 1806 of yacc.c  */
10604 #line 4507 "parse.y"
10605     {
10606                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
10607                     }
10608     break;
10609 
10610   case 545:
10611 
10612 /* Line 1806 of yacc.c  */
10613 #line 4511 "parse.y"
10614     {
10615                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10616                     }
10617     break;
10618 
10619   case 546:
10620 
10621 /* Line 1806 of yacc.c  */
10622 #line 4515 "parse.y"
10623     {
10624                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
10625                     }
10626     break;
10627 
10628   case 547:
10629 
10630 /* Line 1806 of yacc.c  */
10631 #line 4519 "parse.y"
10632     {
10633                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10634                     }
10635     break;
10636 
10637   case 548:
10638 
10639 /* Line 1806 of yacc.c  */
10640 #line 4523 "parse.y"
10641     {
10642                         (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
10643                     }
10644     break;
10645 
10646   case 549:
10647 
10648 /* Line 1806 of yacc.c  */
10649 #line 4527 "parse.y"
10650     {
10651                         (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10652                         (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.node));
10653                     }
10654     break;
10655 
10656   case 550:
10657 
10658 /* Line 1806 of yacc.c  */
10659 #line 4534 "parse.y"
10660     {
10661                     /*%%%*/
10662                         yyerror("formal argument cannot be a constant");
10663                         (yyval.id) = 0;
10664                     /*%
10665                         $$ = dispatch1(param_error, $1);
10666                     %*/
10667                     }
10668     break;
10669 
10670   case 551:
10671 
10672 /* Line 1806 of yacc.c  */
10673 #line 4543 "parse.y"
10674     {
10675                     /*%%%*/
10676                         yyerror("formal argument cannot be an instance variable");
10677                         (yyval.id) = 0;
10678                     /*%
10679                         $$ = dispatch1(param_error, $1);
10680                     %*/
10681                     }
10682     break;
10683 
10684   case 552:
10685 
10686 /* Line 1806 of yacc.c  */
10687 #line 4552 "parse.y"
10688     {
10689                     /*%%%*/
10690                         yyerror("formal argument cannot be a global variable");
10691                         (yyval.id) = 0;
10692                     /*%
10693                         $$ = dispatch1(param_error, $1);
10694                     %*/
10695                     }
10696     break;
10697 
10698   case 553:
10699 
10700 /* Line 1806 of yacc.c  */
10701 #line 4561 "parse.y"
10702     {
10703                     /*%%%*/
10704                         yyerror("formal argument cannot be a class variable");
10705                         (yyval.id) = 0;
10706                     /*%
10707                         $$ = dispatch1(param_error, $1);
10708                     %*/
10709                     }
10710     break;
10711 
10712   case 555:
10713 
10714 /* Line 1806 of yacc.c  */
10715 #line 4573 "parse.y"
10716     {
10717                         formal_argument(get_id((yyvsp[(1) - (1)].id)));
10718                         (yyval.id) = (yyvsp[(1) - (1)].id);
10719                     }
10720     break;
10721 
10722   case 556:
10723 
10724 /* Line 1806 of yacc.c  */
10725 #line 4580 "parse.y"
10726     {
10727                         arg_var(get_id((yyvsp[(1) - (1)].id)));
10728                     /*%%%*/
10729                         (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1);
10730                     /*%
10731                         $$ = get_value($1);
10732                     %*/
10733                     }
10734     break;
10735 
10736   case 557:
10737 
10738 /* Line 1806 of yacc.c  */
10739 #line 4589 "parse.y"
10740     {
10741                         ID tid = internal_id();
10742                         arg_var(tid);
10743                     /*%%%*/
10744                         if (dyna_in_block()) {
10745                             (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid);
10746                         }
10747                         else {
10748                             (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid);
10749                         }
10750                         (yyval.node) = NEW_ARGS_AUX(tid, 1);
10751                         (yyval.node)->nd_next = (yyvsp[(2) - (3)].node);
10752                     /*%
10753                         $$ = dispatch1(mlhs_paren, $2);
10754                     %*/
10755                     }
10756     break;
10757 
10758   case 559:
10759 
10760 /* Line 1806 of yacc.c  */
10761 #line 4615 "parse.y"
10762     {
10763                     /*%%%*/
10764                         (yyval.node) = (yyvsp[(1) - (3)].node);
10765                         (yyval.node)->nd_plen++;
10766                         (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next);
10767                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node));
10768                     /*%
10769                         $$ = rb_ary_push($1, $3);
10770                     %*/
10771                     }
10772     break;
10773 
10774   case 560:
10775 
10776 /* Line 1806 of yacc.c  */
10777 #line 4628 "parse.y"
10778     {
10779                         arg_var(formal_argument(get_id((yyvsp[(1) - (2)].id))));
10780                         (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10781                     /*%%%*/
10782                         (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10783                     /*%
10784                         $$ = rb_assoc_new($$, $2);
10785                     %*/
10786                     }
10787     break;
10788 
10789   case 561:
10790 
10791 /* Line 1806 of yacc.c  */
10792 #line 4640 "parse.y"
10793     {
10794                         arg_var(formal_argument(get_id((yyvsp[(1) - (2)].id))));
10795                         (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10796                     /*%%%*/
10797                         (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10798                     /*%
10799                         $$ = rb_assoc_new($$, $2);
10800                     %*/
10801                     }
10802     break;
10803 
10804   case 562:
10805 
10806 /* Line 1806 of yacc.c  */
10807 #line 4652 "parse.y"
10808     {
10809                     /*%%%*/
10810                         (yyval.node) = (yyvsp[(1) - (1)].node);
10811                     /*%
10812                         $$ = rb_ary_new3(1, $1);
10813                     %*/
10814                     }
10815     break;
10816 
10817   case 563:
10818 
10819 /* Line 1806 of yacc.c  */
10820 #line 4660 "parse.y"
10821     {
10822                     /*%%%*/
10823                         NODE *kws = (yyvsp[(1) - (3)].node);
10824 
10825                         while (kws->nd_next) {
10826                             kws = kws->nd_next;
10827                         }
10828                         kws->nd_next = (yyvsp[(3) - (3)].node);
10829                         (yyval.node) = (yyvsp[(1) - (3)].node);
10830                     /*%
10831                         $$ = rb_ary_push($1, $3);
10832                     %*/
10833                     }
10834     break;
10835 
10836   case 564:
10837 
10838 /* Line 1806 of yacc.c  */
10839 #line 4677 "parse.y"
10840     {
10841                     /*%%%*/
10842                         (yyval.node) = (yyvsp[(1) - (1)].node);
10843                     /*%
10844                         $$ = rb_ary_new3(1, $1);
10845                     %*/
10846                     }
10847     break;
10848 
10849   case 565:
10850 
10851 /* Line 1806 of yacc.c  */
10852 #line 4685 "parse.y"
10853     {
10854                     /*%%%*/
10855                         NODE *kws = (yyvsp[(1) - (3)].node);
10856 
10857                         while (kws->nd_next) {
10858                             kws = kws->nd_next;
10859                         }
10860                         kws->nd_next = (yyvsp[(3) - (3)].node);
10861                         (yyval.node) = (yyvsp[(1) - (3)].node);
10862                     /*%
10863                         $$ = rb_ary_push($1, $3);
10864                     %*/
10865                     }
10866     break;
10867 
10868   case 568:
10869 
10870 /* Line 1806 of yacc.c  */
10871 #line 4705 "parse.y"
10872     {
10873                         shadowing_lvar(get_id((yyvsp[(2) - (2)].id)));
10874                         (yyval.id) = (yyvsp[(2) - (2)].id);
10875                     }
10876     break;
10877 
10878   case 569:
10879 
10880 /* Line 1806 of yacc.c  */
10881 #line 4710 "parse.y"
10882     {
10883                         (yyval.id) = internal_id();
10884                     }
10885     break;
10886 
10887   case 570:
10888 
10889 /* Line 1806 of yacc.c  */
10890 #line 4716 "parse.y"
10891     {
10892                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10893                         (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10894                     /*%%%*/
10895                         (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10896                     /*%
10897                         $$ = rb_assoc_new($$, $3);
10898                     %*/
10899                     }
10900     break;
10901 
10902   case 571:
10903 
10904 /* Line 1806 of yacc.c  */
10905 #line 4728 "parse.y"
10906     {
10907                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10908                         (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10909                     /*%%%*/
10910                         (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10911                     /*%
10912                         $$ = rb_assoc_new($$, $3);
10913                     %*/
10914                     }
10915     break;
10916 
10917   case 572:
10918 
10919 /* Line 1806 of yacc.c  */
10920 #line 4740 "parse.y"
10921     {
10922                     /*%%%*/
10923                         (yyval.node) = (yyvsp[(1) - (1)].node);
10924                     /*%
10925                         $$ = rb_ary_new3(1, $1);
10926                     %*/
10927                     }
10928     break;
10929 
10930   case 573:
10931 
10932 /* Line 1806 of yacc.c  */
10933 #line 4748 "parse.y"
10934     {
10935                     /*%%%*/
10936                         NODE *opts = (yyvsp[(1) - (3)].node);
10937 
10938                         while (opts->nd_next) {
10939                             opts = opts->nd_next;
10940                         }
10941                         opts->nd_next = (yyvsp[(3) - (3)].node);
10942                         (yyval.node) = (yyvsp[(1) - (3)].node);
10943                     /*%
10944                         $$ = rb_ary_push($1, $3);
10945                     %*/
10946                     }
10947     break;
10948 
10949   case 574:
10950 
10951 /* Line 1806 of yacc.c  */
10952 #line 4764 "parse.y"
10953     {
10954                     /*%%%*/
10955                         (yyval.node) = (yyvsp[(1) - (1)].node);
10956                     /*%
10957                         $$ = rb_ary_new3(1, $1);
10958                     %*/
10959                     }
10960     break;
10961 
10962   case 575:
10963 
10964 /* Line 1806 of yacc.c  */
10965 #line 4772 "parse.y"
10966     {
10967                     /*%%%*/
10968                         NODE *opts = (yyvsp[(1) - (3)].node);
10969 
10970                         while (opts->nd_next) {
10971                             opts = opts->nd_next;
10972                         }
10973                         opts->nd_next = (yyvsp[(3) - (3)].node);
10974                         (yyval.node) = (yyvsp[(1) - (3)].node);
10975                     /*%
10976                         $$ = rb_ary_push($1, $3);
10977                     %*/
10978                     }
10979     break;
10980 
10981   case 578:
10982 
10983 /* Line 1806 of yacc.c  */
10984 #line 4792 "parse.y"
10985     {
10986                     /*%%%*/
10987                         if (!is_local_id((yyvsp[(2) - (2)].id)))
10988                             yyerror("rest argument must be local variable");
10989                     /*% %*/
10990                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
10991                     /*%%%*/
10992                         (yyval.id) = (yyvsp[(2) - (2)].id);
10993                     /*%
10994                         $$ = dispatch1(rest_param, $2);
10995                     %*/
10996                     }
10997     break;
10998 
10999   case 579:
11000 
11001 /* Line 1806 of yacc.c  */
11002 #line 4805 "parse.y"
11003     {
11004                     /*%%%*/
11005                         (yyval.id) = internal_id();
11006                         arg_var((yyval.id));
11007                     /*%
11008                         $$ = dispatch1(rest_param, Qnil);
11009                     %*/
11010                     }
11011     break;
11012 
11013   case 582:
11014 
11015 /* Line 1806 of yacc.c  */
11016 #line 4820 "parse.y"
11017     {
11018                     /*%%%*/
11019                         if (!is_local_id((yyvsp[(2) - (2)].id)))
11020                             yyerror("block argument must be local variable");
11021                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id)))
11022                             yyerror("duplicated block argument name");
11023                     /*% %*/
11024                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11025                     /*%%%*/
11026                         (yyval.id) = (yyvsp[(2) - (2)].id);
11027                     /*%
11028                         $$ = dispatch1(blockarg, $2);
11029                     %*/
11030                     }
11031     break;
11032 
11033   case 583:
11034 
11035 /* Line 1806 of yacc.c  */
11036 #line 4837 "parse.y"
11037     {
11038                         (yyval.id) = (yyvsp[(2) - (2)].id);
11039                     }
11040     break;
11041 
11042   case 584:
11043 
11044 /* Line 1806 of yacc.c  */
11045 #line 4841 "parse.y"
11046     {
11047                     /*%%%*/
11048                         (yyval.id) = 0;
11049                     /*%
11050                         $$ = Qundef;
11051                     %*/
11052                     }
11053     break;
11054 
11055   case 585:
11056 
11057 /* Line 1806 of yacc.c  */
11058 #line 4851 "parse.y"
11059     {
11060                     /*%%%*/
11061                         value_expr((yyvsp[(1) - (1)].node));
11062                         (yyval.node) = (yyvsp[(1) - (1)].node);
11063                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
11064                     /*%
11065                         $$ = $1;
11066                     %*/
11067                     }
11068     break;
11069 
11070   case 586:
11071 
11072 /* Line 1806 of yacc.c  */
11073 #line 4860 "parse.y"
11074     {lex_state = EXPR_BEG;}
11075     break;
11076 
11077   case 587:
11078 
11079 /* Line 1806 of yacc.c  */
11080 #line 4861 "parse.y"
11081     {
11082                     /*%%%*/
11083                         if ((yyvsp[(3) - (4)].node) == 0) {
11084                             yyerror("can't define singleton method for ().");
11085                         }
11086                         else {
11087                             switch (nd_type((yyvsp[(3) - (4)].node))) {
11088                               case NODE_STR:
11089                               case NODE_DSTR:
11090                               case NODE_XSTR:
11091                               case NODE_DXSTR:
11092                               case NODE_DREGX:
11093                               case NODE_LIT:
11094                               case NODE_ARRAY:
11095                               case NODE_ZARRAY:
11096                                 yyerror("can't define singleton method for literals");
11097                               default:
11098                                 value_expr((yyvsp[(3) - (4)].node));
11099                                 break;
11100                             }
11101                         }
11102                         (yyval.node) = (yyvsp[(3) - (4)].node);
11103                     /*%
11104                         $$ = dispatch1(paren, $3);
11105                     %*/
11106                     }
11107     break;
11108 
11109   case 589:
11110 
11111 /* Line 1806 of yacc.c  */
11112 #line 4891 "parse.y"
11113     {
11114                     /*%%%*/
11115                         (yyval.node) = (yyvsp[(1) - (2)].node);
11116                     /*%
11117                         $$ = dispatch1(assoclist_from_args, $1);
11118                     %*/
11119                     }
11120     break;
11121 
11122   case 591:
11123 
11124 /* Line 1806 of yacc.c  */
11125 #line 4908 "parse.y"
11126     {
11127                     /*%%%*/
11128                         (yyval.node) = list_concat((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
11129                     /*%
11130                         $$ = rb_ary_push($1, $3);
11131                     %*/
11132                     }
11133     break;
11134 
11135   case 592:
11136 
11137 /* Line 1806 of yacc.c  */
11138 #line 4918 "parse.y"
11139     {
11140                     /*%%%*/
11141                         (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node));
11142                     /*%
11143                         $$ = dispatch2(assoc_new, $1, $3);
11144                     %*/
11145                     }
11146     break;
11147 
11148   case 593:
11149 
11150 /* Line 1806 of yacc.c  */
11151 #line 4926 "parse.y"
11152     {
11153                     /*%%%*/
11154                         (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node));
11155                     /*%
11156                         $$ = dispatch2(assoc_new, $1, $2);
11157                     %*/
11158                     }
11159     break;
11160 
11161   case 594:
11162 
11163 /* Line 1806 of yacc.c  */
11164 #line 4934 "parse.y"
11165     {
11166                     /*%%%*/
11167                         (yyval.node) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].node));
11168                     /*%
11169                         $$ = dispatch1(assoc_splat, $2);
11170                     %*/
11171                     }
11172     break;
11173 
11174   case 616:
11175 
11176 /* Line 1806 of yacc.c  */
11177 #line 4992 "parse.y"
11178     {yyerrok;}
11179     break;
11180 
11181   case 619:
11182 
11183 /* Line 1806 of yacc.c  */
11184 #line 4997 "parse.y"
11185     {yyerrok;}
11186     break;
11187 
11188   case 620:
11189 
11190 /* Line 1806 of yacc.c  */
11191 #line 5001 "parse.y"
11192     {
11193                     /*%%%*/
11194                         (yyval.node) = 0;
11195                     /*%
11196                         $$ = Qundef;
11197                     %*/
11198                     }
11199     break;
11200 
11201 
11202 
11203 /* Line 1806 of yacc.c  */
11204 #line 11203 "parse.c"
11205       default: break;
11206     }
11207   /* User semantic actions sometimes alter yychar, and that requires
11208      that yytoken be updated with the new translation.  We take the
11209      approach of translating immediately before every use of yytoken.
11210      One alternative is translating here after every semantic action,
11211      but that translation would be missed if the semantic action invokes
11212      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11213      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
11214      incorrect destructor might then be invoked immediately.  In the
11215      case of YYERROR or YYBACKUP, subsequent parser actions might lead
11216      to an incorrect destructor call or verbose syntax error message
11217      before the lookahead is translated.  */
11218   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11219 
11220   YYPOPSTACK (yylen);
11221   yylen = 0;
11222   YY_STACK_PRINT (yyss, yyssp);
11223 
11224   *++yyvsp = yyval;
11225 
11226   /* Now `shift' the result of the reduction.  Determine what state
11227      that goes to, based on the state we popped back to and the rule
11228      number reduced by.  */
11229 
11230   yyn = yyr1[yyn];
11231 
11232   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11233   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11234     yystate = yytable[yystate];
11235   else
11236     yystate = yydefgoto[yyn - YYNTOKENS];
11237 
11238   goto yynewstate;
11239 
11240 
11241 /*------------------------------------.
11242 | yyerrlab -- here on detecting error |
11243 `------------------------------------*/
11244 yyerrlab:
11245   /* Make sure we have latest lookahead translation.  See comments at
11246      user semantic actions for why this is necessary.  */
11247   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11248 
11249   /* If not already recovering from an error, report this error.  */
11250   if (!yyerrstatus)
11251     {
11252       ++yynerrs;
11253 #if ! YYERROR_VERBOSE
11254       parser_yyerror (parser, YY_("syntax error"));
11255 #else
11256 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11257                                         yyssp, yytoken)
11258       {
11259         char const *yymsgp = YY_("syntax error");
11260         int yysyntax_error_status;
11261         yysyntax_error_status = YYSYNTAX_ERROR;
11262         if (yysyntax_error_status == 0)
11263           yymsgp = yymsg;
11264         else if (yysyntax_error_status == 1)
11265           {
11266             if (yymsg != yymsgbuf)
11267               YYSTACK_FREE (yymsg);
11268             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11269             if (!yymsg)
11270               {
11271                 yymsg = yymsgbuf;
11272                 yymsg_alloc = sizeof yymsgbuf;
11273                 yysyntax_error_status = 2;
11274               }
11275             else
11276               {
11277                 yysyntax_error_status = YYSYNTAX_ERROR;
11278                 yymsgp = yymsg;
11279               }
11280           }
11281         parser_yyerror (parser, yymsgp);
11282         if (yysyntax_error_status == 2)
11283           goto yyexhaustedlab;
11284       }
11285 # undef YYSYNTAX_ERROR
11286 #endif
11287     }
11288 
11289 
11290 
11291   if (yyerrstatus == 3)
11292     {
11293       /* If just tried and failed to reuse lookahead token after an
11294          error, discard it.  */
11295 
11296       if (yychar <= YYEOF)
11297         {
11298           /* Return failure if at end of input.  */
11299           if (yychar == YYEOF)
11300             YYABORT;
11301         }
11302       else
11303         {
11304           yydestruct ("Error: discarding",
11305                       yytoken, &yylval, parser);
11306           yychar = YYEMPTY;
11307         }
11308     }
11309 
11310   /* Else will try to reuse lookahead token after shifting the error
11311      token.  */
11312   goto yyerrlab1;
11313 
11314 
11315 /*---------------------------------------------------.
11316 | yyerrorlab -- error raised explicitly by YYERROR.  |
11317 `---------------------------------------------------*/
11318 yyerrorlab:
11319 
11320   /* Pacify compilers like GCC when the user code never invokes
11321      YYERROR and the label yyerrorlab therefore never appears in user
11322      code.  */
11323   if (/*CONSTCOND*/ 0)
11324      goto yyerrorlab;
11325 
11326   /* Do not reclaim the symbols of the rule which action triggered
11327      this YYERROR.  */
11328   YYPOPSTACK (yylen);
11329   yylen = 0;
11330   YY_STACK_PRINT (yyss, yyssp);
11331   yystate = *yyssp;
11332   goto yyerrlab1;
11333 
11334 
11335 /*-------------------------------------------------------------.
11336 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
11337 `-------------------------------------------------------------*/
11338 yyerrlab1:
11339   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
11340 
11341   for (;;)
11342     {
11343       yyn = yypact[yystate];
11344       if (!yypact_value_is_default (yyn))
11345         {
11346           yyn += YYTERROR;
11347           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11348             {
11349               yyn = yytable[yyn];
11350               if (0 < yyn)
11351                 break;
11352             }
11353         }
11354 
11355       /* Pop the current state because it cannot handle the error token.  */
11356       if (yyssp == yyss)
11357         YYABORT;
11358 
11359 
11360       yydestruct ("Error: popping",
11361                   yystos[yystate], yyvsp, parser);
11362       YYPOPSTACK (1);
11363       yystate = *yyssp;
11364       YY_STACK_PRINT (yyss, yyssp);
11365     }
11366 
11367   *++yyvsp = yylval;
11368 
11369 
11370   /* Shift the error token.  */
11371   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11372 
11373   yystate = yyn;
11374   goto yynewstate;
11375 
11376 
11377 /*-------------------------------------.
11378 | yyacceptlab -- YYACCEPT comes here.  |
11379 `-------------------------------------*/
11380 yyacceptlab:
11381   yyresult = 0;
11382   goto yyreturn;
11383 
11384 /*-----------------------------------.
11385 | yyabortlab -- YYABORT comes here.  |
11386 `-----------------------------------*/
11387 yyabortlab:
11388   yyresult = 1;
11389   goto yyreturn;
11390 
11391 #if !defined(yyoverflow) || YYERROR_VERBOSE
11392 /*-------------------------------------------------.
11393 | yyexhaustedlab -- memory exhaustion comes here.  |
11394 `-------------------------------------------------*/
11395 yyexhaustedlab:
11396   parser_yyerror (parser, YY_("memory exhausted"));
11397   yyresult = 2;
11398   /* Fall through.  */
11399 #endif
11400 
11401 yyreturn:
11402   if (yychar != YYEMPTY)
11403     {
11404       /* Make sure we have latest lookahead translation.  See comments at
11405          user semantic actions for why this is necessary.  */
11406       yytoken = YYTRANSLATE (yychar);
11407       yydestruct ("Cleanup: discarding lookahead",
11408                   yytoken, &yylval, parser);
11409     }
11410   /* Do not reclaim the symbols of the rule which action triggered
11411      this YYABORT or YYACCEPT.  */
11412   YYPOPSTACK (yylen);
11413   YY_STACK_PRINT (yyss, yyssp);
11414   while (yyssp != yyss)
11415     {
11416       yydestruct ("Cleanup: popping",
11417                   yystos[*yyssp], yyvsp, parser);
11418       YYPOPSTACK (1);
11419     }
11420 #ifndef yyoverflow
11421   if (yyss != yyssa)
11422     YYSTACK_FREE (yyss);
11423 #endif
11424 #if YYERROR_VERBOSE
11425   if (yymsg != yymsgbuf)
11426     YYSTACK_FREE (yymsg);
11427 #endif
11428   /* Make sure YYID is used.  */
11429   return YYID (yyresult);
11430 }
11431 
11432 
11433 
11434 /* Line 2067 of yacc.c  */
11435 #line 5009 "parse.y"
11436 
11437 # undef parser
11438 # undef yylex
11439 # undef yylval
11440 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
11441 
11442 static int parser_regx_options(struct parser_params*);
11443 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11444 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11445 static int parser_parse_string(struct parser_params*,NODE*);
11446 static int parser_here_document(struct parser_params*,NODE*);
11447 
11448 
11449 # define nextc()                   parser_nextc(parser)
11450 # define pushback(c)               parser_pushback(parser, (c))
11451 # define newtok()                  parser_newtok(parser)
11452 # define tokspace(n)               parser_tokspace(parser, (n))
11453 # define tokadd(c)                 parser_tokadd(parser, (c))
11454 # define tok_hex(numlen)           parser_tok_hex(parser, (numlen))
11455 # define read_escape(flags,e)      parser_read_escape(parser, (flags), (e))
11456 # define tokadd_escape(e)          parser_tokadd_escape(parser, (e))
11457 # define regx_options()            parser_regx_options(parser)
11458 # define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11459 # define parse_string(n)           parser_parse_string(parser,(n))
11460 # define tokaddmbc(c, enc)         parser_tokaddmbc(parser, (c), (enc))
11461 # define here_document(n)          parser_here_document(parser,(n))
11462 # define heredoc_identifier()      parser_heredoc_identifier(parser)
11463 # define heredoc_restore(n)        parser_heredoc_restore(parser,(n))
11464 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,(e),(l),(i))
11465 
11466 #ifndef RIPPER
11467 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11468 # define set_yylval_num(x) (yylval.num = (x))
11469 # define set_yylval_id(x)  (yylval.id = (x))
11470 # define set_yylval_name(x)  (yylval.id = (x))
11471 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11472 # define set_yylval_node(x) (yylval.node = (x))
11473 # define yylval_id() (yylval.id)
11474 #else
11475 static inline VALUE
11476 ripper_yylval_id(ID x)
11477 {
11478     return (VALUE)NEW_LASGN(x, ID2SYM(x));
11479 }
11480 # define set_yylval_str(x) (void)(x)
11481 # define set_yylval_num(x) (void)(x)
11482 # define set_yylval_id(x)  (void)(x)
11483 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11484 # define set_yylval_literal(x) (void)(x)
11485 # define set_yylval_node(x) (void)(x)
11486 # define yylval_id() yylval.id
11487 #endif
11488 
11489 #ifndef RIPPER
11490 #define ripper_flush(p) (void)(p)
11491 #else
11492 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11493 
11494 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11495 
11496 static int
11497 ripper_has_scan_event(struct parser_params *parser)
11498 {
11499 
11500     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11501     return lex_p > parser->tokp;
11502 }
11503 
11504 static VALUE
11505 ripper_scan_event_val(struct parser_params *parser, int t)
11506 {
11507     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11508     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11509     ripper_flush(parser);
11510     return rval;
11511 }
11512 
11513 static void
11514 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11515 {
11516     if (!ripper_has_scan_event(parser)) return;
11517     yylval_rval = ripper_scan_event_val(parser, t);
11518 }
11519 
11520 static void
11521 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11522 {
11523     if (!ripper_has_scan_event(parser)) return;
11524     (void)ripper_scan_event_val(parser, t);
11525 }
11526 
11527 static void
11528 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11529 {
11530     int saved_line = ruby_sourceline;
11531     const char *saved_tokp = parser->tokp;
11532 
11533     ruby_sourceline = parser->delayed_line;
11534     parser->tokp = lex_pbeg + parser->delayed_col;
11535     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11536     parser->delayed = Qnil;
11537     ruby_sourceline = saved_line;
11538     parser->tokp = saved_tokp;
11539 }
11540 #endif /* RIPPER */
11541 
11542 #include "ruby/regex.h"
11543 #include "ruby/util.h"
11544 
11545 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11546    since ours (we hope) works properly with all combinations of
11547    machines, compilers, `char' and `unsigned char' argument types.
11548    (Per Bothner suggested the basic approach.)  */
11549 #undef SIGN_EXTEND_CHAR
11550 #if __STDC__
11551 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11552 #else  /* not __STDC__ */
11553 /* As in Harbison and Steele.  */
11554 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11555 #endif
11556 
11557 #define parser_encoding_name()  (current_enc->name)
11558 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,current_enc)
11559 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11560 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11561 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11562 
11563 #define parser_isascii() ISASCII(*(lex_p-1))
11564 
11565 #ifndef RIPPER
11566 static int
11567 token_info_get_column(struct parser_params *parser, const char *token)
11568 {
11569     int column = 1;
11570     const char *p, *pend = lex_p - strlen(token);
11571     for (p = lex_pbeg; p < pend; p++) {
11572         if (*p == '\t') {
11573             column = (((column - 1) / 8) + 1) * 8;
11574         }
11575         column++;
11576     }
11577     return column;
11578 }
11579 
11580 static int
11581 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11582 {
11583     const char *p, *pend = lex_p - strlen(token);
11584     for (p = lex_pbeg; p < pend; p++) {
11585         if (*p != ' ' && *p != '\t') {
11586             return 1;
11587         }
11588     }
11589     return 0;
11590 }
11591 
11592 #undef token_info_push
11593 static void
11594 token_info_push(struct parser_params *parser, const char *token)
11595 {
11596     token_info *ptinfo;
11597 
11598     if (!parser->parser_token_info_enabled) return;
11599     ptinfo = ALLOC(token_info);
11600     ptinfo->token = token;
11601     ptinfo->linenum = ruby_sourceline;
11602     ptinfo->column = token_info_get_column(parser, token);
11603     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11604     ptinfo->next = parser->parser_token_info;
11605 
11606     parser->parser_token_info = ptinfo;
11607 }
11608 
11609 #undef token_info_pop
11610 static void
11611 token_info_pop(struct parser_params *parser, const char *token)
11612 {
11613     int linenum;
11614     token_info *ptinfo = parser->parser_token_info;
11615 
11616     if (!ptinfo) return;
11617     parser->parser_token_info = ptinfo->next;
11618     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11619         goto finish;
11620     }
11621     linenum = ruby_sourceline;
11622     if (linenum == ptinfo->linenum) { /* SKIP */
11623         goto finish;
11624     }
11625     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11626         goto finish;
11627     }
11628     if (parser->parser_token_info_enabled) {
11629         rb_compile_warn(ruby_sourcefile, linenum,
11630                         "mismatched indentations at '%s' with '%s' at %d",
11631                         token, ptinfo->token, ptinfo->linenum);
11632     }
11633 
11634   finish:
11635     xfree(ptinfo);
11636 }
11637 #endif  /* RIPPER */
11638 
11639 static int
11640 parser_yyerror(struct parser_params *parser, const char *msg)
11641 {
11642 #ifndef RIPPER
11643     const int max_line_margin = 30;
11644     const char *p, *pe;
11645     char *buf;
11646     long len;
11647     int i;
11648 
11649     compile_error(PARSER_ARG "%s", msg);
11650     p = lex_p;
11651     while (lex_pbeg <= p) {
11652         if (*p == '\n') break;
11653         p--;
11654     }
11655     p++;
11656 
11657     pe = lex_p;
11658     while (pe < lex_pend) {
11659         if (*pe == '\n') break;
11660         pe++;
11661     }
11662 
11663     len = pe - p;
11664     if (len > 4) {
11665         char *p2;
11666         const char *pre = "", *post = "";
11667 
11668         if (len > max_line_margin * 2 + 10) {
11669             if (lex_p - p > max_line_margin) {
11670                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11671                 pre = "...";
11672             }
11673             if (pe - lex_p > max_line_margin) {
11674                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11675                 post = "...";
11676             }
11677             len = pe - p;
11678         }
11679         buf = ALLOCA_N(char, len+2);
11680         MEMCPY(buf, p, char, len);
11681         buf[len] = '\0';
11682         rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11683 
11684         i = (int)(lex_p - p);
11685         p2 = buf; pe = buf + len;
11686 
11687         while (p2 < pe) {
11688             if (*p2 != '\t') *p2 = ' ';
11689             p2++;
11690         }
11691         buf[i] = '^';
11692         buf[i+1] = '\0';
11693         rb_compile_error_append("%s%s", pre, buf);
11694     }
11695 #else
11696     dispatch1(parse_error, STR_NEW2(msg));
11697 #endif /* !RIPPER */
11698     return 0;
11699 }
11700 
11701 static void parser_prepare(struct parser_params *parser);
11702 
11703 #ifndef RIPPER
11704 static VALUE
11705 debug_lines(VALUE fname)
11706 {
11707     ID script_lines;
11708     CONST_ID(script_lines, "SCRIPT_LINES__");
11709     if (rb_const_defined_at(rb_cObject, script_lines)) {
11710         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11711         if (RB_TYPE_P(hash, T_HASH)) {
11712             VALUE lines = rb_ary_new();
11713             rb_hash_aset(hash, fname, lines);
11714             return lines;
11715         }
11716     }
11717     return 0;
11718 }
11719 
11720 static VALUE
11721 coverage(VALUE fname, int n)
11722 {
11723     VALUE coverages = rb_get_coverages();
11724     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11725         VALUE lines = rb_ary_new2(n);
11726         int i;
11727         RBASIC(lines)->klass = 0;
11728         for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11729         RARRAY(lines)->as.heap.len = n;
11730         rb_hash_aset(coverages, fname, lines);
11731         return lines;
11732     }
11733     return 0;
11734 }
11735 
11736 static int
11737 e_option_supplied(struct parser_params *parser)
11738 {
11739     return strcmp(ruby_sourcefile, "-e") == 0;
11740 }
11741 
11742 static VALUE
11743 yycompile0(VALUE arg)
11744 {
11745     int n;
11746     NODE *tree;
11747     struct parser_params *parser = (struct parser_params *)arg;
11748 
11749     if (!compile_for_eval && rb_safe_level() == 0) {
11750         ruby_debug_lines = debug_lines(ruby_sourcefile_string);
11751         if (ruby_debug_lines && ruby_sourceline > 0) {
11752             VALUE str = STR_NEW0();
11753             n = ruby_sourceline;
11754             do {
11755                 rb_ary_push(ruby_debug_lines, str);
11756             } while (--n);
11757         }
11758 
11759         if (!e_option_supplied(parser)) {
11760             ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
11761         }
11762     }
11763 
11764     parser_prepare(parser);
11765     deferred_nodes = 0;
11766 #ifndef RIPPER
11767     parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
11768 #endif
11769 #ifndef RIPPER
11770     if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
11771         RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
11772                                 parser->parser_ruby_sourceline);
11773     }
11774 #endif
11775     n = yyparse((void*)parser);
11776 #ifndef RIPPER
11777     if (RUBY_DTRACE_PARSE_END_ENABLED()) {
11778         RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
11779                               parser->parser_ruby_sourceline);
11780     }
11781 #endif
11782     ruby_debug_lines = 0;
11783     ruby_coverage = 0;
11784     compile_for_eval = 0;
11785 
11786     lex_strterm = 0;
11787     lex_p = lex_pbeg = lex_pend = 0;
11788     lex_lastline = lex_nextline = 0;
11789     if (parser->nerr) {
11790         return 0;
11791     }
11792     tree = ruby_eval_tree;
11793     if (!tree) {
11794         tree = NEW_NIL();
11795     }
11796     else if (ruby_eval_tree_begin) {
11797         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11798     }
11799     return (VALUE)tree;
11800 }
11801 
11802 static NODE*
11803 yycompile(struct parser_params *parser, VALUE fname, int line)
11804 {
11805     ruby_sourcefile_string = rb_str_new_frozen(fname);
11806     ruby_sourcefile = RSTRING_PTR(fname);
11807     ruby_sourceline = line - 1;
11808     return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11809 }
11810 #endif /* !RIPPER */
11811 
11812 static rb_encoding *
11813 must_be_ascii_compatible(VALUE s)
11814 {
11815     rb_encoding *enc = rb_enc_get(s);
11816     if (!rb_enc_asciicompat(enc)) {
11817         rb_raise(rb_eArgError, "invalid source encoding");
11818     }
11819     return enc;
11820 }
11821 
11822 static VALUE
11823 lex_get_str(struct parser_params *parser, VALUE s)
11824 {
11825     char *beg, *end, *pend;
11826     rb_encoding *enc = must_be_ascii_compatible(s);
11827 
11828     beg = RSTRING_PTR(s);
11829     if (lex_gets_ptr) {
11830         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11831         beg += lex_gets_ptr;
11832     }
11833     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11834     end = beg;
11835     while (end < pend) {
11836         if (*end++ == '\n') break;
11837     }
11838     lex_gets_ptr = end - RSTRING_PTR(s);
11839     return rb_enc_str_new(beg, end - beg, enc);
11840 }
11841 
11842 static VALUE
11843 lex_getline(struct parser_params *parser)
11844 {
11845     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11846     if (NIL_P(line)) return line;
11847     must_be_ascii_compatible(line);
11848 #ifndef RIPPER
11849     if (ruby_debug_lines) {
11850         rb_enc_associate(line, current_enc);
11851         rb_ary_push(ruby_debug_lines, line);
11852     }
11853     if (ruby_coverage) {
11854         rb_ary_push(ruby_coverage, Qnil);
11855     }
11856 #endif
11857     return line;
11858 }
11859 
11860 #ifdef RIPPER
11861 static rb_data_type_t parser_data_type;
11862 #else
11863 static const rb_data_type_t parser_data_type;
11864 
11865 static NODE*
11866 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11867 {
11868     struct parser_params *parser;
11869     NODE *node;
11870 
11871     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11872     lex_gets = lex_get_str;
11873     lex_gets_ptr = 0;
11874     lex_input = s;
11875     lex_pbeg = lex_p = lex_pend = 0;
11876     compile_for_eval = rb_parse_in_eval();
11877 
11878     node = yycompile(parser, fname, line);
11879     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11880 
11881     return node;
11882 }
11883 
11884 NODE*
11885 rb_compile_string(const char *f, VALUE s, int line)
11886 {
11887     must_be_ascii_compatible(s);
11888     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
11889 }
11890 
11891 NODE*
11892 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11893 {
11894     return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
11895 }
11896 
11897 NODE*
11898 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
11899 {
11900     must_be_ascii_compatible(s);
11901     return parser_compile_string(vparser, f, s, line);
11902 }
11903 
11904 NODE*
11905 rb_compile_cstr(const char *f, const char *s, int len, int line)
11906 {
11907     VALUE str = rb_str_new(s, len);
11908     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
11909 }
11910 
11911 NODE*
11912 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11913 {
11914     VALUE str = rb_str_new(s, len);
11915     return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
11916 }
11917 
11918 static VALUE
11919 lex_io_gets(struct parser_params *parser, VALUE io)
11920 {
11921     return rb_io_gets(io);
11922 }
11923 
11924 NODE*
11925 rb_compile_file(const char *f, VALUE file, int start)
11926 {
11927     VALUE volatile vparser = rb_parser_new();
11928 
11929     return rb_parser_compile_file(vparser, f, file, start);
11930 }
11931 
11932 NODE*
11933 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11934 {
11935     return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
11936 }
11937 
11938 NODE*
11939 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
11940 {
11941     struct parser_params *parser;
11942     NODE *node;
11943 
11944     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11945     lex_gets = lex_io_gets;
11946     lex_input = file;
11947     lex_pbeg = lex_p = lex_pend = 0;
11948     compile_for_eval = rb_parse_in_eval();
11949 
11950     node = yycompile(parser, fname, start);
11951     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11952 
11953     return node;
11954 }
11955 #endif  /* !RIPPER */
11956 
11957 #define STR_FUNC_ESCAPE 0x01
11958 #define STR_FUNC_EXPAND 0x02
11959 #define STR_FUNC_REGEXP 0x04
11960 #define STR_FUNC_QWORDS 0x08
11961 #define STR_FUNC_SYMBOL 0x10
11962 #define STR_FUNC_INDENT 0x20
11963 
11964 enum string_type {
11965     str_squote = (0),
11966     str_dquote = (STR_FUNC_EXPAND),
11967     str_xquote = (STR_FUNC_EXPAND),
11968     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
11969     str_sword  = (STR_FUNC_QWORDS),
11970     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
11971     str_ssym   = (STR_FUNC_SYMBOL),
11972     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
11973 };
11974 
11975 static VALUE
11976 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11977 {
11978     VALUE str;
11979 
11980     str = rb_enc_str_new(p, n, enc);
11981     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11982         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
11983         }
11984         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11985             rb_enc_associate(str, rb_ascii8bit_encoding());
11986         }
11987     }
11988 
11989     return str;
11990 }
11991 
11992 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11993 #define lex_eol_p() (lex_p >= lex_pend)
11994 #define peek(c) peek_n((c), 0)
11995 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11996 
11997 static inline int
11998 parser_nextc(struct parser_params *parser)
11999 {
12000     int c;
12001 
12002     if (lex_p == lex_pend) {
12003         VALUE v = lex_nextline;
12004         lex_nextline = 0;
12005         if (!v) {
12006             if (parser->eofp)
12007                 return -1;
12008 
12009             if (!lex_input || NIL_P(v = lex_getline(parser))) {
12010                 parser->eofp = Qtrue;
12011                 lex_goto_eol(parser);
12012                 return -1;
12013             }
12014         }
12015         {
12016 #ifdef RIPPER
12017             if (parser->tokp < lex_pend) {
12018                 if (NIL_P(parser->delayed)) {
12019                     parser->delayed = rb_str_buf_new(1024);
12020                     rb_enc_associate(parser->delayed, current_enc);
12021                     rb_str_buf_cat(parser->delayed,
12022                                    parser->tokp, lex_pend - parser->tokp);
12023                     parser->delayed_line = ruby_sourceline;
12024                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12025                 }
12026                 else {
12027                     rb_str_buf_cat(parser->delayed,
12028                                    parser->tokp, lex_pend - parser->tokp);
12029                 }
12030             }
12031 #endif
12032             if (heredoc_end > 0) {
12033                 ruby_sourceline = heredoc_end;
12034                 heredoc_end = 0;
12035             }
12036             ruby_sourceline++;
12037             parser->line_count++;
12038             lex_pbeg = lex_p = RSTRING_PTR(v);
12039             lex_pend = lex_p + RSTRING_LEN(v);
12040             ripper_flush(parser);
12041             lex_lastline = v;
12042         }
12043     }
12044     c = (unsigned char)*lex_p++;
12045     if (c == '\r' && peek('\n')) {
12046         lex_p++;
12047         c = '\n';
12048     }
12049 
12050     return c;
12051 }
12052 
12053 static void
12054 parser_pushback(struct parser_params *parser, int c)
12055 {
12056     if (c == -1) return;
12057     lex_p--;
12058     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12059         lex_p--;
12060     }
12061 }
12062 
12063 #define was_bol() (lex_p == lex_pbeg + 1)
12064 
12065 #define tokfix() (tokenbuf[tokidx]='\0')
12066 #define tok() tokenbuf
12067 #define toklen() tokidx
12068 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12069 
12070 static char*
12071 parser_newtok(struct parser_params *parser)
12072 {
12073     tokidx = 0;
12074     tokline = ruby_sourceline;
12075     if (!tokenbuf) {
12076         toksiz = 60;
12077         tokenbuf = ALLOC_N(char, 60);
12078     }
12079     if (toksiz > 4096) {
12080         toksiz = 60;
12081         REALLOC_N(tokenbuf, char, 60);
12082     }
12083     return tokenbuf;
12084 }
12085 
12086 static char *
12087 parser_tokspace(struct parser_params *parser, int n)
12088 {
12089     tokidx += n;
12090 
12091     if (tokidx >= toksiz) {
12092         do {toksiz *= 2;} while (toksiz < tokidx);
12093         REALLOC_N(tokenbuf, char, toksiz);
12094     }
12095     return &tokenbuf[tokidx-n];
12096 }
12097 
12098 static void
12099 parser_tokadd(struct parser_params *parser, int c)
12100 {
12101     tokenbuf[tokidx++] = (char)c;
12102     if (tokidx >= toksiz) {
12103         toksiz *= 2;
12104         REALLOC_N(tokenbuf, char, toksiz);
12105     }
12106 }
12107 
12108 static int
12109 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12110 {
12111     int c;
12112 
12113     c = scan_hex(lex_p, 2, numlen);
12114     if (!*numlen) {
12115         yyerror("invalid hex escape");
12116         return 0;
12117     }
12118     lex_p += *numlen;
12119     return c;
12120 }
12121 
12122 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12123 
12124 /* return value is for ?\u3042 */
12125 static int
12126 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
12127                    int string_literal, int symbol_literal, int regexp_literal)
12128 {
12129     /*
12130      * If string_literal is true, then we allow multiple codepoints
12131      * in \u{}, and add the codepoints to the current token.
12132      * Otherwise we're parsing a character literal and return a single
12133      * codepoint without adding it
12134      */
12135 
12136     int codepoint;
12137     size_t numlen;
12138 
12139     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12140 
12141     if (peek('{')) {  /* handle \u{...} form */
12142         do {
12143             if (regexp_literal) { tokadd(*lex_p); }
12144             nextc();
12145             codepoint = scan_hex(lex_p, 6, &numlen);
12146             if (numlen == 0)  {
12147                 yyerror("invalid Unicode escape");
12148                 return 0;
12149             }
12150             if (codepoint > 0x10ffff) {
12151                 yyerror("invalid Unicode codepoint (too large)");
12152                 return 0;
12153             }
12154             lex_p += numlen;
12155             if (regexp_literal) {
12156                 tokcopy((int)numlen);
12157             }
12158             else if (codepoint >= 0x80) {
12159                 *encp = rb_utf8_encoding();
12160                 if (string_literal) tokaddmbc(codepoint, *encp);
12161             }
12162             else if (string_literal) {
12163                 tokadd(codepoint);
12164             }
12165         } while (string_literal && (peek(' ') || peek('\t')));
12166 
12167         if (!peek('}')) {
12168             yyerror("unterminated Unicode escape");
12169             return 0;
12170         }
12171 
12172         if (regexp_literal) { tokadd('}'); }
12173         nextc();
12174     }
12175     else {                      /* handle \uxxxx form */
12176         codepoint = scan_hex(lex_p, 4, &numlen);
12177         if (numlen < 4) {
12178             yyerror("invalid Unicode escape");
12179             return 0;
12180         }
12181         lex_p += 4;
12182         if (regexp_literal) {
12183             tokcopy(4);
12184         }
12185         else if (codepoint >= 0x80) {
12186             *encp = rb_utf8_encoding();
12187             if (string_literal) tokaddmbc(codepoint, *encp);
12188         }
12189         else if (string_literal) {
12190             tokadd(codepoint);
12191         }
12192     }
12193 
12194     return codepoint;
12195 }
12196 
12197 #define ESCAPE_CONTROL 1
12198 #define ESCAPE_META    2
12199 
12200 static int
12201 parser_read_escape(struct parser_params *parser, int flags,
12202                    rb_encoding **encp)
12203 {
12204     int c;
12205     size_t numlen;
12206 
12207     switch (c = nextc()) {
12208       case '\\':        /* Backslash */
12209         return c;
12210 
12211       case 'n': /* newline */
12212         return '\n';
12213 
12214       case 't': /* horizontal tab */
12215         return '\t';
12216 
12217       case 'r': /* carriage-return */
12218         return '\r';
12219 
12220       case 'f': /* form-feed */
12221         return '\f';
12222 
12223       case 'v': /* vertical tab */
12224         return '\13';
12225 
12226       case 'a': /* alarm(bell) */
12227         return '\007';
12228 
12229       case 'e': /* escape */
12230         return 033;
12231 
12232       case '0': case '1': case '2': case '3': /* octal constant */
12233       case '4': case '5': case '6': case '7':
12234         pushback(c);
12235         c = scan_oct(lex_p, 3, &numlen);
12236         lex_p += numlen;
12237         return c;
12238 
12239       case 'x': /* hex constant */
12240         c = tok_hex(&numlen);
12241         if (numlen == 0) return 0;
12242         return c;
12243 
12244       case 'b': /* backspace */
12245         return '\010';
12246 
12247       case 's': /* space */
12248         return ' ';
12249 
12250       case 'M':
12251         if (flags & ESCAPE_META) goto eof;
12252         if ((c = nextc()) != '-') {
12253             pushback(c);
12254             goto eof;
12255         }
12256         if ((c = nextc()) == '\\') {
12257             if (peek('u')) goto eof;
12258             return read_escape(flags|ESCAPE_META, encp) | 0x80;
12259         }
12260         else if (c == -1 || !ISASCII(c)) goto eof;
12261         else {
12262             return ((c & 0xff) | 0x80);
12263         }
12264 
12265       case 'C':
12266         if ((c = nextc()) != '-') {
12267             pushback(c);
12268             goto eof;
12269         }
12270       case 'c':
12271         if (flags & ESCAPE_CONTROL) goto eof;
12272         if ((c = nextc())== '\\') {
12273             if (peek('u')) goto eof;
12274             c = read_escape(flags|ESCAPE_CONTROL, encp);
12275         }
12276         else if (c == '?')
12277             return 0177;
12278         else if (c == -1 || !ISASCII(c)) goto eof;
12279         return c & 0x9f;
12280 
12281       eof:
12282       case -1:
12283         yyerror("Invalid escape character syntax");
12284         return '\0';
12285 
12286       default:
12287         return c;
12288     }
12289 }
12290 
12291 static void
12292 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
12293 {
12294     int len = rb_enc_codelen(c, enc);
12295     rb_enc_mbcput(c, tokspace(len), enc);
12296 }
12297 
12298 static int
12299 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
12300 {
12301     int c;
12302     int flags = 0;
12303     size_t numlen;
12304 
12305   first:
12306     switch (c = nextc()) {
12307       case '\n':
12308         return 0;               /* just ignore */
12309 
12310       case '0': case '1': case '2': case '3': /* octal constant */
12311       case '4': case '5': case '6': case '7':
12312         {
12313             ruby_scan_oct(--lex_p, 3, &numlen);
12314             if (numlen == 0) goto eof;
12315             lex_p += numlen;
12316             tokcopy((int)numlen + 1);
12317         }
12318         return 0;
12319 
12320       case 'x': /* hex constant */
12321         {
12322             tok_hex(&numlen);
12323             if (numlen == 0) return -1;
12324             tokcopy((int)numlen + 2);
12325         }
12326         return 0;
12327 
12328       case 'M':
12329         if (flags & ESCAPE_META) goto eof;
12330         if ((c = nextc()) != '-') {
12331             pushback(c);
12332             goto eof;
12333         }
12334         tokcopy(3);
12335         flags |= ESCAPE_META;
12336         goto escaped;
12337 
12338       case 'C':
12339         if (flags & ESCAPE_CONTROL) goto eof;
12340         if ((c = nextc()) != '-') {
12341             pushback(c);
12342             goto eof;
12343         }
12344         tokcopy(3);
12345         goto escaped;
12346 
12347       case 'c':
12348         if (flags & ESCAPE_CONTROL) goto eof;
12349         tokcopy(2);
12350         flags |= ESCAPE_CONTROL;
12351       escaped:
12352         if ((c = nextc()) == '\\') {
12353             goto first;
12354         }
12355         else if (c == -1) goto eof;
12356         tokadd(c);
12357         return 0;
12358 
12359       eof:
12360       case -1:
12361         yyerror("Invalid escape character syntax");
12362         return -1;
12363 
12364       default:
12365         tokadd('\\');
12366         tokadd(c);
12367     }
12368     return 0;
12369 }
12370 
12371 static int
12372 parser_regx_options(struct parser_params *parser)
12373 {
12374     int kcode = 0;
12375     int kopt = 0;
12376     int options = 0;
12377     int c, opt, kc;
12378 
12379     newtok();
12380     while (c = nextc(), ISALPHA(c)) {
12381         if (c == 'o') {
12382             options |= RE_OPTION_ONCE;
12383         }
12384         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12385             if (kc >= 0) {
12386                 if (kc != rb_ascii8bit_encindex()) kcode = c;
12387                 kopt = opt;
12388             }
12389             else {
12390                 options |= opt;
12391             }
12392         }
12393         else {
12394             tokadd(c);
12395         }
12396     }
12397     options |= kopt;
12398     pushback(c);
12399     if (toklen()) {
12400         tokfix();
12401         compile_error(PARSER_ARG "unknown regexp option%s - %s",
12402                       toklen() > 1 ? "s" : "", tok());
12403     }
12404     return options | RE_OPTION_ENCODING(kcode);
12405 }
12406 
12407 static void
12408 dispose_string(VALUE str)
12409 {
12410     rb_str_free(str);
12411     rb_gc_force_recycle(str);
12412 }
12413 
12414 static int
12415 parser_tokadd_mbchar(struct parser_params *parser, int c)
12416 {
12417     int len = parser_precise_mbclen();
12418     if (!MBCLEN_CHARFOUND_P(len)) {
12419         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12420         return -1;
12421     }
12422     tokadd(c);
12423     lex_p += --len;
12424     if (len > 0) tokcopy(len);
12425     return c;
12426 }
12427 
12428 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12429 
12430 static inline int
12431 simple_re_meta(int c)
12432 {
12433     switch (c) {
12434       case '$': case '*': case '+': case '.':
12435       case '?': case '^': case '|':
12436       case ')': case ']': case '}': case '>':
12437         return TRUE;
12438       default:
12439         return FALSE;
12440     }
12441 }
12442 
12443 static int
12444 parser_tokadd_string(struct parser_params *parser,
12445                      int func, int term, int paren, long *nest,
12446                      rb_encoding **encp)
12447 {
12448     int c;
12449     int has_nonascii = 0;
12450     rb_encoding *enc = *encp;
12451     char *errbuf = 0;
12452     static const char mixed_msg[] = "%s mixed within %s source";
12453 
12454 #define mixed_error(enc1, enc2) if (!errbuf) {  \
12455         size_t len = sizeof(mixed_msg) - 4;     \
12456         len += strlen(rb_enc_name(enc1));       \
12457         len += strlen(rb_enc_name(enc2));       \
12458         errbuf = ALLOCA_N(char, len);           \
12459         snprintf(errbuf, len, mixed_msg,        \
12460                  rb_enc_name(enc1),             \
12461                  rb_enc_name(enc2));            \
12462         yyerror(errbuf);                        \
12463     }
12464 #define mixed_escape(beg, enc1, enc2) do {      \
12465         const char *pos = lex_p;                \
12466         lex_p = (beg);                          \
12467         mixed_error((enc1), (enc2));            \
12468         lex_p = pos;                            \
12469     } while (0)
12470 
12471     while ((c = nextc()) != -1) {
12472         if (paren && c == paren) {
12473             ++*nest;
12474         }
12475         else if (c == term) {
12476             if (!nest || !*nest) {
12477                 pushback(c);
12478                 break;
12479             }
12480             --*nest;
12481         }
12482         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12483             int c2 = *lex_p;
12484             if (c2 == '$' || c2 == '@' || c2 == '{') {
12485                 pushback(c);
12486                 break;
12487             }
12488         }
12489         else if (c == '\\') {
12490             const char *beg = lex_p - 1;
12491             c = nextc();
12492             switch (c) {
12493               case '\n':
12494                 if (func & STR_FUNC_QWORDS) break;
12495                 if (func & STR_FUNC_EXPAND) continue;
12496                 tokadd('\\');
12497                 break;
12498 
12499               case '\\':
12500                 if (func & STR_FUNC_ESCAPE) tokadd(c);
12501                 break;
12502 
12503               case 'u':
12504                 if ((func & STR_FUNC_EXPAND) == 0) {
12505                     tokadd('\\');
12506                     break;
12507                 }
12508                 parser_tokadd_utf8(parser, &enc, 1,
12509                                    func & STR_FUNC_SYMBOL,
12510                                    func & STR_FUNC_REGEXP);
12511                 if (has_nonascii && enc != *encp) {
12512                     mixed_escape(beg, enc, *encp);
12513                 }
12514                 continue;
12515 
12516               default:
12517                 if (c == -1) return -1;
12518                 if (!ISASCII(c)) {
12519                     if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12520                     goto non_ascii;
12521                 }
12522                 if (func & STR_FUNC_REGEXP) {
12523                     if (c == term && !simple_re_meta(c)) {
12524                         tokadd(c);
12525                         continue;
12526                     }
12527                     pushback(c);
12528                     if ((c = tokadd_escape(&enc)) < 0)
12529                         return -1;
12530                     if (has_nonascii && enc != *encp) {
12531                         mixed_escape(beg, enc, *encp);
12532                     }
12533                     continue;
12534                 }
12535                 else if (func & STR_FUNC_EXPAND) {
12536                     pushback(c);
12537                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
12538                     c = read_escape(0, &enc);
12539                 }
12540                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12541                     /* ignore backslashed spaces in %w */
12542                 }
12543                 else if (c != term && !(paren && c == paren)) {
12544                     tokadd('\\');
12545                     pushback(c);
12546                     continue;
12547                 }
12548             }
12549         }
12550         else if (!parser_isascii()) {
12551           non_ascii:
12552             has_nonascii = 1;
12553             if (enc != *encp) {
12554                 mixed_error(enc, *encp);
12555                 continue;
12556             }
12557             if (tokadd_mbchar(c) == -1) return -1;
12558             continue;
12559         }
12560         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12561             pushback(c);
12562             break;
12563         }
12564         if (c & 0x80) {
12565             has_nonascii = 1;
12566             if (enc != *encp) {
12567                 mixed_error(enc, *encp);
12568                 continue;
12569             }
12570         }
12571         tokadd(c);
12572     }
12573     *encp = enc;
12574     return c;
12575 }
12576 
12577 #define NEW_STRTERM(func, term, paren) \
12578         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12579 
12580 #ifdef RIPPER
12581 static void
12582 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12583 {
12584     if (!NIL_P(parser->delayed)) {
12585         ptrdiff_t len = lex_p - parser->tokp;
12586         if (len > 0) {
12587             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12588         }
12589         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12590         parser->tokp = lex_p;
12591     }
12592 }
12593 
12594 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12595 #else
12596 #define flush_string_content(enc) ((void)(enc))
12597 #endif
12598 
12599 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12600 /* this can be shared with ripper, since it's independent from struct
12601  * parser_params. */
12602 #ifndef RIPPER
12603 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12604 #define SPECIAL_PUNCT(idx) ( \
12605         BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12606         BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12607         BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12608         BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12609         BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12610         BIT('0', idx))
12611 const unsigned int ruby_global_name_punct_bits[] = {
12612     SPECIAL_PUNCT(0),
12613     SPECIAL_PUNCT(1),
12614     SPECIAL_PUNCT(2),
12615 };
12616 #undef BIT
12617 #undef SPECIAL_PUNCT
12618 #endif
12619 
12620 static inline int
12621 is_global_name_punct(const char c)
12622 {
12623     if (c <= 0x20 || 0x7e < c) return 0;
12624     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12625 }
12626 
12627 static int
12628 parser_peek_variable_name(struct parser_params *parser)
12629 {
12630     int c;
12631     const char *p = lex_p;
12632 
12633     if (p + 1 >= lex_pend) return 0;
12634     c = *p++;
12635     switch (c) {
12636       case '$':
12637         if ((c = *p) == '-') {
12638             if (++p >= lex_pend) return 0;
12639             c = *p;
12640         }
12641         else if (is_global_name_punct(c) || ISDIGIT(c)) {
12642             return tSTRING_DVAR;
12643         }
12644         break;
12645       case '@':
12646         if ((c = *p) == '@') {
12647             if (++p >= lex_pend) return 0;
12648             c = *p;
12649         }
12650         break;
12651       case '{':
12652         lex_p = p;
12653         command_start = TRUE;
12654         return tSTRING_DBEG;
12655       default:
12656         return 0;
12657     }
12658     if (!ISASCII(c) || c == '_' || ISALPHA(c))
12659         return tSTRING_DVAR;
12660     return 0;
12661 }
12662 
12663 static int
12664 parser_parse_string(struct parser_params *parser, NODE *quote)
12665 {
12666     int func = (int)quote->nd_func;
12667     int term = nd_term(quote);
12668     int paren = nd_paren(quote);
12669     int c, space = 0;
12670     rb_encoding *enc = current_enc;
12671 
12672     if (func == -1) return tSTRING_END;
12673     c = nextc();
12674     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12675         do {c = nextc();} while (ISSPACE(c));
12676         space = 1;
12677     }
12678     if (c == term && !quote->nd_nest) {
12679         if (func & STR_FUNC_QWORDS) {
12680             quote->nd_func = -1;
12681             return ' ';
12682         }
12683         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12684         set_yylval_num(regx_options());
12685         return tREGEXP_END;
12686     }
12687     if (space) {
12688         pushback(c);
12689         return ' ';
12690     }
12691     newtok();
12692     if ((func & STR_FUNC_EXPAND) && c == '#') {
12693         int t = parser_peek_variable_name(parser);
12694         if (t) return t;
12695         tokadd('#');
12696         c = nextc();
12697     }
12698     pushback(c);
12699     if (tokadd_string(func, term, paren, &quote->nd_nest,
12700                       &enc) == -1) {
12701         ruby_sourceline = nd_line(quote);
12702         if (func & STR_FUNC_REGEXP) {
12703             if (parser->eofp)
12704                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
12705             return tREGEXP_END;
12706         }
12707         else {
12708             if (parser->eofp)
12709                 compile_error(PARSER_ARG "unterminated string meets end of file");
12710             return tSTRING_END;
12711         }
12712     }
12713 
12714     tokfix();
12715     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12716     flush_string_content(enc);
12717 
12718     return tSTRING_CONTENT;
12719 }
12720 
12721 static int
12722 parser_heredoc_identifier(struct parser_params *parser)
12723 {
12724     int c = nextc(), term, func = 0;
12725     long len;
12726 
12727     if (c == '-') {
12728         c = nextc();
12729         func = STR_FUNC_INDENT;
12730     }
12731     switch (c) {
12732       case '\'':
12733         func |= str_squote; goto quoted;
12734       case '"':
12735         func |= str_dquote; goto quoted;
12736       case '`':
12737         func |= str_xquote;
12738       quoted:
12739         newtok();
12740         tokadd(func);
12741         term = c;
12742         while ((c = nextc()) != -1 && c != term) {
12743             if (tokadd_mbchar(c) == -1) return 0;
12744         }
12745         if (c == -1) {
12746             compile_error(PARSER_ARG "unterminated here document identifier");
12747             return 0;
12748         }
12749         break;
12750 
12751       default:
12752         if (!parser_is_identchar()) {
12753             pushback(c);
12754             if (func & STR_FUNC_INDENT) {
12755                 pushback('-');
12756             }
12757             return 0;
12758         }
12759         newtok();
12760         term = '"';
12761         tokadd(func |= str_dquote);
12762         do {
12763             if (tokadd_mbchar(c) == -1) return 0;
12764         } while ((c = nextc()) != -1 && parser_is_identchar());
12765         pushback(c);
12766         break;
12767     }
12768 
12769     tokfix();
12770 #ifdef RIPPER
12771     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12772 #endif
12773     len = lex_p - lex_pbeg;
12774     lex_goto_eol(parser);
12775     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12776                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12777                                   len,                          /* nd_nth */
12778                                   lex_lastline);                /* nd_orig */
12779     nd_set_line(lex_strterm, ruby_sourceline);
12780     ripper_flush(parser);
12781     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12782 }
12783 
12784 static void
12785 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12786 {
12787     VALUE line;
12788 
12789     line = here->nd_orig;
12790     lex_lastline = line;
12791     lex_pbeg = RSTRING_PTR(line);
12792     lex_pend = lex_pbeg + RSTRING_LEN(line);
12793     lex_p = lex_pbeg + here->nd_nth;
12794     heredoc_end = ruby_sourceline;
12795     ruby_sourceline = nd_line(here);
12796     dispose_string(here->nd_lit);
12797     rb_gc_force_recycle((VALUE)here);
12798     ripper_flush(parser);
12799 }
12800 
12801 static int
12802 parser_whole_match_p(struct parser_params *parser,
12803     const char *eos, long len, int indent)
12804 {
12805     const char *p = lex_pbeg;
12806     long n;
12807 
12808     if (indent) {
12809         while (*p && ISSPACE(*p)) p++;
12810     }
12811     n = lex_pend - (p + len);
12812     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12813     return strncmp(eos, p, len) == 0;
12814 }
12815 
12816 #ifdef RIPPER
12817 static void
12818 ripper_dispatch_heredoc_end(struct parser_params *parser)
12819 {
12820     if (!NIL_P(parser->delayed))
12821         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12822     lex_goto_eol(parser);
12823     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12824 }
12825 
12826 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12827 #else
12828 #define dispatch_heredoc_end() ((void)0)
12829 #endif
12830 
12831 static int
12832 parser_here_document(struct parser_params *parser, NODE *here)
12833 {
12834     int c, func, indent = 0;
12835     const char *eos, *p, *pend;
12836     long len;
12837     VALUE str = 0;
12838     rb_encoding *enc = current_enc;
12839 
12840     eos = RSTRING_PTR(here->nd_lit);
12841     len = RSTRING_LEN(here->nd_lit) - 1;
12842     indent = (func = *eos++) & STR_FUNC_INDENT;
12843 
12844     if ((c = nextc()) == -1) {
12845       error:
12846         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12847 #ifdef RIPPER
12848         if (NIL_P(parser->delayed)) {
12849             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12850         }
12851         else {
12852             if (str ||
12853                 ((len = lex_p - parser->tokp) > 0 &&
12854                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12855                 rb_str_append(parser->delayed, str);
12856             }
12857             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12858         }
12859         lex_goto_eol(parser);
12860 #endif
12861       restore:
12862         heredoc_restore(lex_strterm);
12863         lex_strterm = 0;
12864         return 0;
12865     }
12866     if (was_bol() && whole_match_p(eos, len, indent)) {
12867         dispatch_heredoc_end();
12868         heredoc_restore(lex_strterm);
12869         return tSTRING_END;
12870     }
12871 
12872     if (!(func & STR_FUNC_EXPAND)) {
12873         do {
12874             p = RSTRING_PTR(lex_lastline);
12875             pend = lex_pend;
12876             if (pend > p) {
12877                 switch (pend[-1]) {
12878                   case '\n':
12879                     if (--pend == p || pend[-1] != '\r') {
12880                         pend++;
12881                         break;
12882                     }
12883                   case '\r':
12884                     --pend;
12885                 }
12886             }
12887             if (str)
12888                 rb_str_cat(str, p, pend - p);
12889             else
12890                 str = STR_NEW(p, pend - p);
12891             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12892             lex_goto_eol(parser);
12893             if (nextc() == -1) {
12894                 if (str) {
12895                     dispose_string(str);
12896                     str = 0;
12897                 }
12898                 goto error;
12899             }
12900         } while (!whole_match_p(eos, len, indent));
12901     }
12902     else {
12903         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12904         newtok();
12905         if (c == '#') {
12906             int t = parser_peek_variable_name(parser);
12907             if (t) return t;
12908             tokadd('#');
12909             c = nextc();
12910         }
12911         do {
12912             pushback(c);
12913             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12914                 if (parser->eofp) goto error;
12915                 goto restore;
12916             }
12917             if (c != '\n') {
12918                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12919                 flush_string_content(enc);
12920                 return tSTRING_CONTENT;
12921             }
12922             tokadd(nextc());
12923             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12924             if ((c = nextc()) == -1) goto error;
12925         } while (!whole_match_p(eos, len, indent));
12926         str = STR_NEW3(tok(), toklen(), enc, func);
12927     }
12928     dispatch_heredoc_end();
12929     heredoc_restore(lex_strterm);
12930     lex_strterm = NEW_STRTERM(-1, 0, 0);
12931     set_yylval_str(str);
12932     return tSTRING_CONTENT;
12933 }
12934 
12935 #include "lex.c"
12936 
12937 static void
12938 arg_ambiguous_gen(struct parser_params *parser)
12939 {
12940 #ifndef RIPPER
12941     rb_warning0("ambiguous first argument; put parentheses or even spaces");
12942 #else
12943     dispatch0(arg_ambiguous);
12944 #endif
12945 }
12946 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12947 
12948 static ID
12949 formal_argument_gen(struct parser_params *parser, ID lhs)
12950 {
12951 #ifndef RIPPER
12952     if (!is_local_id(lhs))
12953         yyerror("formal argument must be local variable");
12954 #endif
12955     shadowing_lvar(lhs);
12956     return lhs;
12957 }
12958 
12959 static int
12960 lvar_defined_gen(struct parser_params *parser, ID id)
12961 {
12962     return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12963 }
12964 
12965 /* emacsen -*- hack */
12966 static long
12967 parser_encode_length(struct parser_params *parser, const char *name, long len)
12968 {
12969     long nlen;
12970 
12971     if (len > 5 && name[nlen = len - 5] == '-') {
12972         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12973             return nlen;
12974     }
12975     if (len > 4 && name[nlen = len - 4] == '-') {
12976         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12977             return nlen;
12978         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12979             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12980             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12981             return nlen;
12982     }
12983     return len;
12984 }
12985 
12986 static void
12987 parser_set_encode(struct parser_params *parser, const char *name)
12988 {
12989     int idx = rb_enc_find_index(name);
12990     rb_encoding *enc;
12991     VALUE excargs[3];
12992 
12993     if (idx < 0) {
12994         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12995       error:
12996         excargs[0] = rb_eArgError;
12997         excargs[2] = rb_make_backtrace();
12998         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12999         rb_exc_raise(rb_make_exception(3, excargs));
13000     }
13001     enc = rb_enc_from_index(idx);
13002     if (!rb_enc_asciicompat(enc)) {
13003         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13004         goto error;
13005     }
13006     parser->enc = enc;
13007 #ifndef RIPPER
13008     if (ruby_debug_lines) {
13009         long i, n = RARRAY_LEN(ruby_debug_lines);
13010         const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13011         for (i = 0; i < n; ++i) {
13012             rb_enc_associate_index(*p, idx);
13013         }
13014     }
13015 #endif
13016 }
13017 
13018 static int
13019 comment_at_top(struct parser_params *parser)
13020 {
13021     const char *p = lex_pbeg, *pend = lex_p - 1;
13022     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13023     while (p < pend) {
13024         if (!ISSPACE(*p)) return 0;
13025         p++;
13026     }
13027     return 1;
13028 }
13029 
13030 #ifndef RIPPER
13031 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13032 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13033 
13034 static void
13035 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13036 {
13037     if (!comment_at_top(parser)) {
13038         return;
13039     }
13040     parser_set_encode(parser, val);
13041 }
13042 
13043 static void
13044 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13045 {
13046     int *p = &parser->parser_token_info_enabled;
13047 
13048     switch (*val) {
13049       case 't': case 'T':
13050         if (strcasecmp(val, "true") == 0) {
13051             *p = TRUE;
13052             return;
13053         }
13054         break;
13055       case 'f': case 'F':
13056         if (strcasecmp(val, "false") == 0) {
13057             *p = FALSE;
13058             return;
13059         }
13060         break;
13061     }
13062     rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13063 }
13064 
13065 struct magic_comment {
13066     const char *name;
13067     rb_magic_comment_setter_t func;
13068     rb_magic_comment_length_t length;
13069 };
13070 
13071 static const struct magic_comment magic_comments[] = {
13072     {"coding", magic_comment_encoding, parser_encode_length},
13073     {"encoding", magic_comment_encoding, parser_encode_length},
13074     {"warn_indent", parser_set_token_info},
13075 };
13076 #endif
13077 
13078 static const char *
13079 magic_comment_marker(const char *str, long len)
13080 {
13081     long i = 2;
13082 
13083     while (i < len) {
13084         switch (str[i]) {
13085           case '-':
13086             if (str[i-1] == '*' && str[i-2] == '-') {
13087                 return str + i + 1;
13088             }
13089             i += 2;
13090             break;
13091           case '*':
13092             if (i + 1 >= len) return 0;
13093             if (str[i+1] != '-') {
13094                 i += 4;
13095             }
13096             else if (str[i-1] != '-') {
13097                 i += 2;
13098             }
13099             else {
13100                 return str + i + 2;
13101             }
13102             break;
13103           default:
13104             i += 3;
13105             break;
13106         }
13107     }
13108     return 0;
13109 }
13110 
13111 static int
13112 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13113 {
13114     VALUE name = 0, val = 0;
13115     const char *beg, *end, *vbeg, *vend;
13116 #define str_copy(_s, _p, _n) ((_s) \
13117         ? (void)(rb_str_resize((_s), (_n)), \
13118            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13119         : (void)((_s) = STR_NEW((_p), (_n))))
13120 
13121     if (len <= 7) return FALSE;
13122     if (!(beg = magic_comment_marker(str, len))) return FALSE;
13123     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13124     str = beg;
13125     len = end - beg - 3;
13126 
13127     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13128     while (len > 0) {
13129 #ifndef RIPPER
13130         const struct magic_comment *p = magic_comments;
13131 #endif
13132         char *s;
13133         int i;
13134         long n = 0;
13135 
13136         for (; len > 0 && *str; str++, --len) {
13137             switch (*str) {
13138               case '\'': case '"': case ':': case ';':
13139                 continue;
13140             }
13141             if (!ISSPACE(*str)) break;
13142         }
13143         for (beg = str; len > 0; str++, --len) {
13144             switch (*str) {
13145               case '\'': case '"': case ':': case ';':
13146                 break;
13147               default:
13148                 if (ISSPACE(*str)) break;
13149                 continue;
13150             }
13151             break;
13152         }
13153         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13154         if (!len) break;
13155         if (*str != ':') continue;
13156 
13157         do str++; while (--len > 0 && ISSPACE(*str));
13158         if (!len) break;
13159         if (*str == '"') {
13160             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13161                 if (*str == '\\') {
13162                     --len;
13163                     ++str;
13164                 }
13165             }
13166             vend = str;
13167             if (len) {
13168                 --len;
13169                 ++str;
13170             }
13171         }
13172         else {
13173             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13174             vend = str;
13175         }
13176         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13177 
13178         n = end - beg;
13179         str_copy(name, beg, n);
13180         s = RSTRING_PTR(name);
13181         for (i = 0; i < n; ++i) {
13182             if (s[i] == '-') s[i] = '_';
13183         }
13184 #ifndef RIPPER
13185         do {
13186             if (STRNCASECMP(p->name, s, n) == 0) {
13187                 n = vend - vbeg;
13188                 if (p->length) {
13189                     n = (*p->length)(parser, vbeg, n);
13190                 }
13191                 str_copy(val, vbeg, n);
13192                 (*p->func)(parser, s, RSTRING_PTR(val));
13193                 break;
13194             }
13195         } while (++p < magic_comments + numberof(magic_comments));
13196 #else
13197         str_copy(val, vbeg, vend - vbeg);
13198         dispatch2(magic_comment, name, val);
13199 #endif
13200     }
13201 
13202     return TRUE;
13203 }
13204 
13205 static void
13206 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13207 {
13208     int sep = 0;
13209     const char *beg = str;
13210     VALUE s;
13211 
13212     for (;;) {
13213         if (send - str <= 6) return;
13214         switch (str[6]) {
13215           case 'C': case 'c': str += 6; continue;
13216           case 'O': case 'o': str += 5; continue;
13217           case 'D': case 'd': str += 4; continue;
13218           case 'I': case 'i': str += 3; continue;
13219           case 'N': case 'n': str += 2; continue;
13220           case 'G': case 'g': str += 1; continue;
13221           case '=': case ':':
13222             sep = 1;
13223             str += 6;
13224             break;
13225           default:
13226             str += 6;
13227             if (ISSPACE(*str)) break;
13228             continue;
13229         }
13230         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13231     }
13232     for (;;) {
13233         do {
13234             if (++str >= send) return;
13235         } while (ISSPACE(*str));
13236         if (sep) break;
13237         if (*str != '=' && *str != ':') return;
13238         sep = 1;
13239         str++;
13240     }
13241     beg = str;
13242     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13243     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13244     parser_set_encode(parser, RSTRING_PTR(s));
13245     rb_str_resize(s, 0);
13246 }
13247 
13248 static void
13249 parser_prepare(struct parser_params *parser)
13250 {
13251     int c = nextc();
13252     switch (c) {
13253       case '#':
13254         if (peek('!')) parser->has_shebang = 1;
13255         break;
13256       case 0xef:                /* UTF-8 BOM marker */
13257         if (lex_pend - lex_p >= 2 &&
13258             (unsigned char)lex_p[0] == 0xbb &&
13259             (unsigned char)lex_p[1] == 0xbf) {
13260             parser->enc = rb_utf8_encoding();
13261             lex_p += 2;
13262             lex_pbeg = lex_p;
13263             return;
13264         }
13265         break;
13266       case EOF:
13267         return;
13268     }
13269     pushback(c);
13270     parser->enc = rb_enc_get(lex_lastline);
13271 }
13272 
13273 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13274 #define IS_END() IS_lex_state(EXPR_END_ANY)
13275 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13276 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13277 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13278 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13279 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13280 
13281 #ifndef RIPPER
13282 #define ambiguous_operator(op, syn) ( \
13283     rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13284     rb_warning0("even though it seems like "syn""))
13285 #else
13286 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13287 #endif
13288 #define warn_balanced(op, syn) ((void) \
13289     (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13290      space_seen && !ISSPACE(c) && \
13291      (ambiguous_operator(op, syn), 0)))
13292 
13293 static int
13294 parser_yylex(struct parser_params *parser)
13295 {
13296     register int c;
13297     int space_seen = 0;
13298     int cmd_state;
13299     enum lex_state_e last_state;
13300     rb_encoding *enc;
13301     int mb;
13302 #ifdef RIPPER
13303     int fallthru = FALSE;
13304 #endif
13305 
13306     if (lex_strterm) {
13307         int token;
13308         if (nd_type(lex_strterm) == NODE_HEREDOC) {
13309             token = here_document(lex_strterm);
13310             if (token == tSTRING_END) {
13311                 lex_strterm = 0;
13312                 lex_state = EXPR_END;
13313             }
13314         }
13315         else {
13316             token = parse_string(lex_strterm);
13317             if (token == tSTRING_END || token == tREGEXP_END) {
13318                 rb_gc_force_recycle((VALUE)lex_strterm);
13319                 lex_strterm = 0;
13320                 lex_state = EXPR_END;
13321             }
13322         }
13323         return token;
13324     }
13325     cmd_state = command_start;
13326     command_start = FALSE;
13327   retry:
13328     last_state = lex_state;
13329     switch (c = nextc()) {
13330       case '\0':                /* NUL */
13331       case '\004':              /* ^D */
13332       case '\032':              /* ^Z */
13333       case -1:                  /* end of script. */
13334         return 0;
13335 
13336         /* white spaces */
13337       case ' ': case '\t': case '\f': case '\r':
13338       case '\13': /* '\v' */
13339         space_seen = 1;
13340 #ifdef RIPPER
13341         while ((c = nextc())) {
13342             switch (c) {
13343               case ' ': case '\t': case '\f': case '\r':
13344               case '\13': /* '\v' */
13345                 break;
13346               default:
13347                 goto outofloop;
13348             }
13349         }
13350       outofloop:
13351         pushback(c);
13352         ripper_dispatch_scan_event(parser, tSP);
13353 #endif
13354         goto retry;
13355 
13356       case '#':         /* it's a comment */
13357         /* no magic_comment in shebang line */
13358         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13359             if (comment_at_top(parser)) {
13360                 set_file_encoding(parser, lex_p, lex_pend);
13361             }
13362         }
13363         lex_p = lex_pend;
13364 #ifdef RIPPER
13365         ripper_dispatch_scan_event(parser, tCOMMENT);
13366         fallthru = TRUE;
13367 #endif
13368         /* fall through */
13369       case '\n':
13370         if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13371 #ifdef RIPPER
13372             if (!fallthru) {
13373                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
13374             }
13375             fallthru = FALSE;
13376 #endif
13377             goto retry;
13378         }
13379         while ((c = nextc())) {
13380             switch (c) {
13381               case ' ': case '\t': case '\f': case '\r':
13382               case '\13': /* '\v' */
13383                 space_seen = 1;
13384                 break;
13385               case '.': {
13386                   if ((c = nextc()) != '.') {
13387                       pushback(c);
13388                       pushback('.');
13389                       goto retry;
13390                   }
13391               }
13392               default:
13393                 --ruby_sourceline;
13394                 lex_nextline = lex_lastline;
13395               case -1:          /* EOF no decrement*/
13396                 lex_goto_eol(parser);
13397 #ifdef RIPPER
13398                 if (c != -1) {
13399                     parser->tokp = lex_p;
13400                 }
13401 #endif
13402                 goto normal_newline;
13403             }
13404         }
13405       normal_newline:
13406         command_start = TRUE;
13407         lex_state = EXPR_BEG;
13408         return '\n';
13409 
13410       case '*':
13411         if ((c = nextc()) == '*') {
13412             if ((c = nextc()) == '=') {
13413                 set_yylval_id(tPOW);
13414                 lex_state = EXPR_BEG;
13415                 return tOP_ASGN;
13416             }
13417             pushback(c);
13418             if (IS_SPCARG(c)) {
13419                 rb_warning0("`**' interpreted as argument prefix");
13420                 c = tDSTAR;
13421             }
13422             else if (IS_BEG()) {
13423                 c = tDSTAR;
13424             }
13425             else {
13426                 warn_balanced("**", "argument prefix");
13427                 c = tPOW;
13428             }
13429         }
13430         else {
13431             if (c == '=') {
13432                 set_yylval_id('*');
13433                 lex_state = EXPR_BEG;
13434                 return tOP_ASGN;
13435             }
13436             pushback(c);
13437             if (IS_SPCARG(c)) {
13438                 rb_warning0("`*' interpreted as argument prefix");
13439                 c = tSTAR;
13440             }
13441             else if (IS_BEG()) {
13442                 c = tSTAR;
13443             }
13444             else {
13445                 warn_balanced("*", "argument prefix");
13446                 c = '*';
13447             }
13448         }
13449         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13450         return c;
13451 
13452       case '!':
13453         c = nextc();
13454         if (IS_AFTER_OPERATOR()) {
13455             lex_state = EXPR_ARG;
13456             if (c == '@') {
13457                 return '!';
13458             }
13459         }
13460         else {
13461             lex_state = EXPR_BEG;
13462         }
13463         if (c == '=') {
13464             return tNEQ;
13465         }
13466         if (c == '~') {
13467             return tNMATCH;
13468         }
13469         pushback(c);
13470         return '!';
13471 
13472       case '=':
13473         if (was_bol()) {
13474             /* skip embedded rd document */
13475             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13476 #ifdef RIPPER
13477                 int first_p = TRUE;
13478 
13479                 lex_goto_eol(parser);
13480                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13481 #endif
13482                 for (;;) {
13483                     lex_goto_eol(parser);
13484 #ifdef RIPPER
13485                     if (!first_p) {
13486                         ripper_dispatch_scan_event(parser, tEMBDOC);
13487                     }
13488                     first_p = FALSE;
13489 #endif
13490                     c = nextc();
13491                     if (c == -1) {
13492                         compile_error(PARSER_ARG "embedded document meets end of file");
13493                         return 0;
13494                     }
13495                     if (c != '=') continue;
13496                     if (strncmp(lex_p, "end", 3) == 0 &&
13497                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13498                         break;
13499                     }
13500                 }
13501                 lex_goto_eol(parser);
13502 #ifdef RIPPER
13503                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
13504 #endif
13505                 goto retry;
13506             }
13507         }
13508 
13509         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13510         if ((c = nextc()) == '=') {
13511             if ((c = nextc()) == '=') {
13512                 return tEQQ;
13513             }
13514             pushback(c);
13515             return tEQ;
13516         }
13517         if (c == '~') {
13518             return tMATCH;
13519         }
13520         else if (c == '>') {
13521             return tASSOC;
13522         }
13523         pushback(c);
13524         return '=';
13525 
13526       case '<':
13527         last_state = lex_state;
13528         c = nextc();
13529         if (c == '<' &&
13530             !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13531             !IS_END() &&
13532             (!IS_ARG() || space_seen)) {
13533             int token = heredoc_identifier();
13534             if (token) return token;
13535         }
13536         if (IS_AFTER_OPERATOR()) {
13537             lex_state = EXPR_ARG;
13538         }
13539         else {
13540             if (IS_lex_state(EXPR_CLASS))
13541                 command_start = TRUE;
13542             lex_state = EXPR_BEG;
13543         }
13544         if (c == '=') {
13545             if ((c = nextc()) == '>') {
13546                 return tCMP;
13547             }
13548             pushback(c);
13549             return tLEQ;
13550         }
13551         if (c == '<') {
13552             if ((c = nextc()) == '=') {
13553                 set_yylval_id(tLSHFT);
13554                 lex_state = EXPR_BEG;
13555                 return tOP_ASGN;
13556             }
13557             pushback(c);
13558             warn_balanced("<<", "here document");
13559             return tLSHFT;
13560         }
13561         pushback(c);
13562         return '<';
13563 
13564       case '>':
13565         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13566         if ((c = nextc()) == '=') {
13567             return tGEQ;
13568         }
13569         if (c == '>') {
13570             if ((c = nextc()) == '=') {
13571                 set_yylval_id(tRSHFT);
13572                 lex_state = EXPR_BEG;
13573                 return tOP_ASGN;
13574             }
13575             pushback(c);
13576             return tRSHFT;
13577         }
13578         pushback(c);
13579         return '>';
13580 
13581       case '"':
13582         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13583         return tSTRING_BEG;
13584 
13585       case '`':
13586         if (IS_lex_state(EXPR_FNAME)) {
13587             lex_state = EXPR_ENDFN;
13588             return c;
13589         }
13590         if (IS_lex_state(EXPR_DOT)) {
13591             if (cmd_state)
13592                 lex_state = EXPR_CMDARG;
13593             else
13594                 lex_state = EXPR_ARG;
13595             return c;
13596         }
13597         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13598         return tXSTRING_BEG;
13599 
13600       case '\'':
13601         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13602         return tSTRING_BEG;
13603 
13604       case '?':
13605         if (IS_END()) {
13606             lex_state = EXPR_VALUE;
13607             return '?';
13608         }
13609         c = nextc();
13610         if (c == -1) {
13611             compile_error(PARSER_ARG "incomplete character syntax");
13612             return 0;
13613         }
13614         if (rb_enc_isspace(c, current_enc)) {
13615             if (!IS_ARG()) {
13616                 int c2 = 0;
13617                 switch (c) {
13618                   case ' ':
13619                     c2 = 's';
13620                     break;
13621                   case '\n':
13622                     c2 = 'n';
13623                     break;
13624                   case '\t':
13625                     c2 = 't';
13626                     break;
13627                   case '\v':
13628                     c2 = 'v';
13629                     break;
13630                   case '\r':
13631                     c2 = 'r';
13632                     break;
13633                   case '\f':
13634                     c2 = 'f';
13635                     break;
13636                 }
13637                 if (c2) {
13638                     rb_warnI("invalid character syntax; use ?\\%c", c2);
13639                 }
13640             }
13641           ternary:
13642             pushback(c);
13643             lex_state = EXPR_VALUE;
13644             return '?';
13645         }
13646         newtok();
13647         enc = current_enc;
13648         if (!parser_isascii()) {
13649             if (tokadd_mbchar(c) == -1) return 0;
13650         }
13651         else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13652                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13653             goto ternary;
13654         }
13655         else if (c == '\\') {
13656             if (peek('u')) {
13657                 nextc();
13658                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13659                 if (0x80 <= c) {
13660                     tokaddmbc(c, enc);
13661                 }
13662                 else {
13663                     tokadd(c);
13664                 }
13665             }
13666             else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13667                 nextc();
13668                 if (tokadd_mbchar(c) == -1) return 0;
13669             }
13670             else {
13671                 c = read_escape(0, &enc);
13672                 tokadd(c);
13673             }
13674         }
13675         else {
13676             tokadd(c);
13677         }
13678         tokfix();
13679         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13680         lex_state = EXPR_END;
13681         return tCHAR;
13682 
13683       case '&':
13684         if ((c = nextc()) == '&') {
13685             lex_state = EXPR_BEG;
13686             if ((c = nextc()) == '=') {
13687                 set_yylval_id(tANDOP);
13688                 lex_state = EXPR_BEG;
13689                 return tOP_ASGN;
13690             }
13691             pushback(c);
13692             return tANDOP;
13693         }
13694         else if (c == '=') {
13695             set_yylval_id('&');
13696             lex_state = EXPR_BEG;
13697             return tOP_ASGN;
13698         }
13699         pushback(c);
13700         if (IS_SPCARG(c)) {
13701             rb_warning0("`&' interpreted as argument prefix");
13702             c = tAMPER;
13703         }
13704         else if (IS_BEG()) {
13705             c = tAMPER;
13706         }
13707         else {
13708             warn_balanced("&", "argument prefix");
13709             c = '&';
13710         }
13711         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13712         return c;
13713 
13714       case '|':
13715         if ((c = nextc()) == '|') {
13716             lex_state = EXPR_BEG;
13717             if ((c = nextc()) == '=') {
13718                 set_yylval_id(tOROP);
13719                 lex_state = EXPR_BEG;
13720                 return tOP_ASGN;
13721             }
13722             pushback(c);
13723             return tOROP;
13724         }
13725         if (c == '=') {
13726             set_yylval_id('|');
13727             lex_state = EXPR_BEG;
13728             return tOP_ASGN;
13729         }
13730         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13731         pushback(c);
13732         return '|';
13733 
13734       case '+':
13735         c = nextc();
13736         if (IS_AFTER_OPERATOR()) {
13737             lex_state = EXPR_ARG;
13738             if (c == '@') {
13739                 return tUPLUS;
13740             }
13741             pushback(c);
13742             return '+';
13743         }
13744         if (c == '=') {
13745             set_yylval_id('+');
13746             lex_state = EXPR_BEG;
13747             return tOP_ASGN;
13748         }
13749         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13750             lex_state = EXPR_BEG;
13751             pushback(c);
13752             if (c != -1 && ISDIGIT(c)) {
13753                 c = '+';
13754                 goto start_num;
13755             }
13756             return tUPLUS;
13757         }
13758         lex_state = EXPR_BEG;
13759         pushback(c);
13760         warn_balanced("+", "unary operator");
13761         return '+';
13762 
13763       case '-':
13764         c = nextc();
13765         if (IS_AFTER_OPERATOR()) {
13766             lex_state = EXPR_ARG;
13767             if (c == '@') {
13768                 return tUMINUS;
13769             }
13770             pushback(c);
13771             return '-';
13772         }
13773         if (c == '=') {
13774             set_yylval_id('-');
13775             lex_state = EXPR_BEG;
13776             return tOP_ASGN;
13777         }
13778         if (c == '>') {
13779             lex_state = EXPR_ENDFN;
13780             return tLAMBDA;
13781         }
13782         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13783             lex_state = EXPR_BEG;
13784             pushback(c);
13785             if (c != -1 && ISDIGIT(c)) {
13786                 return tUMINUS_NUM;
13787             }
13788             return tUMINUS;
13789         }
13790         lex_state = EXPR_BEG;
13791         pushback(c);
13792         warn_balanced("-", "unary operator");
13793         return '-';
13794 
13795       case '.':
13796         lex_state = EXPR_BEG;
13797         if ((c = nextc()) == '.') {
13798             if ((c = nextc()) == '.') {
13799                 return tDOT3;
13800             }
13801             pushback(c);
13802             return tDOT2;
13803         }
13804         pushback(c);
13805         if (c != -1 && ISDIGIT(c)) {
13806             yyerror("no .<digit> floating literal anymore; put 0 before dot");
13807         }
13808         lex_state = EXPR_DOT;
13809         return '.';
13810 
13811       start_num:
13812       case '0': case '1': case '2': case '3': case '4':
13813       case '5': case '6': case '7': case '8': case '9':
13814         {
13815             int is_float, seen_point, seen_e, nondigit;
13816 
13817             is_float = seen_point = seen_e = nondigit = 0;
13818             lex_state = EXPR_END;
13819             newtok();
13820             if (c == '-' || c == '+') {
13821                 tokadd(c);
13822                 c = nextc();
13823             }
13824             if (c == '0') {
13825 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13826                 int start = toklen();
13827                 c = nextc();
13828                 if (c == 'x' || c == 'X') {
13829                     /* hexadecimal */
13830                     c = nextc();
13831                     if (c != -1 && ISXDIGIT(c)) {
13832                         do {
13833                             if (c == '_') {
13834                                 if (nondigit) break;
13835                                 nondigit = c;
13836                                 continue;
13837                             }
13838                             if (!ISXDIGIT(c)) break;
13839                             nondigit = 0;
13840                             tokadd(c);
13841                         } while ((c = nextc()) != -1);
13842                     }
13843                     pushback(c);
13844                     tokfix();
13845                     if (toklen() == start) {
13846                         no_digits();
13847                     }
13848                     else if (nondigit) goto trailing_uc;
13849                     set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
13850                     return tINTEGER;
13851                 }
13852                 if (c == 'b' || c == 'B') {
13853                     /* binary */
13854                     c = nextc();
13855                     if (c == '0' || c == '1') {
13856                         do {
13857                             if (c == '_') {
13858                                 if (nondigit) break;
13859                                 nondigit = c;
13860                                 continue;
13861                             }
13862                             if (c != '0' && c != '1') break;
13863                             nondigit = 0;
13864                             tokadd(c);
13865                         } while ((c = nextc()) != -1);
13866                     }
13867                     pushback(c);
13868                     tokfix();
13869                     if (toklen() == start) {
13870                         no_digits();
13871                     }
13872                     else if (nondigit) goto trailing_uc;
13873                     set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
13874                     return tINTEGER;
13875                 }
13876                 if (c == 'd' || c == 'D') {
13877                     /* decimal */
13878                     c = nextc();
13879                     if (c != -1 && ISDIGIT(c)) {
13880                         do {
13881                             if (c == '_') {
13882                                 if (nondigit) break;
13883                                 nondigit = c;
13884                                 continue;
13885                             }
13886                             if (!ISDIGIT(c)) break;
13887                             nondigit = 0;
13888                             tokadd(c);
13889                         } while ((c = nextc()) != -1);
13890                     }
13891                     pushback(c);
13892                     tokfix();
13893                     if (toklen() == start) {
13894                         no_digits();
13895                     }
13896                     else if (nondigit) goto trailing_uc;
13897                     set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13898                     return tINTEGER;
13899                 }
13900                 if (c == '_') {
13901                     /* 0_0 */
13902                     goto octal_number;
13903                 }
13904                 if (c == 'o' || c == 'O') {
13905                     /* prefixed octal */
13906                     c = nextc();
13907                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
13908                         no_digits();
13909                     }
13910                 }
13911                 if (c >= '0' && c <= '7') {
13912                     /* octal */
13913                   octal_number:
13914                     do {
13915                         if (c == '_') {
13916                             if (nondigit) break;
13917                             nondigit = c;
13918                             continue;
13919                         }
13920                         if (c < '0' || c > '9') break;
13921                         if (c > '7') goto invalid_octal;
13922                         nondigit = 0;
13923                         tokadd(c);
13924                     } while ((c = nextc()) != -1);
13925                     if (toklen() > start) {
13926                         pushback(c);
13927                         tokfix();
13928                         if (nondigit) goto trailing_uc;
13929                         set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
13930                         return tINTEGER;
13931                     }
13932                     if (nondigit) {
13933                         pushback(c);
13934                         goto trailing_uc;
13935                     }
13936                 }
13937                 if (c > '7' && c <= '9') {
13938                   invalid_octal:
13939                     yyerror("Invalid octal digit");
13940                 }
13941                 else if (c == '.' || c == 'e' || c == 'E') {
13942                     tokadd('0');
13943                 }
13944                 else {
13945                     pushback(c);
13946                     set_yylval_literal(INT2FIX(0));
13947                     return tINTEGER;
13948                 }
13949             }
13950 
13951             for (;;) {
13952                 switch (c) {
13953                   case '0': case '1': case '2': case '3': case '4':
13954                   case '5': case '6': case '7': case '8': case '9':
13955                     nondigit = 0;
13956                     tokadd(c);
13957                     break;
13958 
13959                   case '.':
13960                     if (nondigit) goto trailing_uc;
13961                     if (seen_point || seen_e) {
13962                         goto decode_num;
13963                     }
13964                     else {
13965                         int c0 = nextc();
13966                         if (c0 == -1 || !ISDIGIT(c0)) {
13967                             pushback(c0);
13968                             goto decode_num;
13969                         }
13970                         c = c0;
13971                     }
13972                     tokadd('.');
13973                     tokadd(c);
13974                     is_float++;
13975                     seen_point++;
13976                     nondigit = 0;
13977                     break;
13978 
13979                   case 'e':
13980                   case 'E':
13981                     if (nondigit) {
13982                         pushback(c);
13983                         c = nondigit;
13984                         goto decode_num;
13985                     }
13986                     if (seen_e) {
13987                         goto decode_num;
13988                     }
13989                     tokadd(c);
13990                     seen_e++;
13991                     is_float++;
13992                     nondigit = c;
13993                     c = nextc();
13994                     if (c != '-' && c != '+') continue;
13995                     tokadd(c);
13996                     nondigit = c;
13997                     break;
13998 
13999                   case '_':     /* `_' in number just ignored */
14000                     if (nondigit) goto decode_num;
14001                     nondigit = c;
14002                     break;
14003 
14004                   default:
14005                     goto decode_num;
14006                 }
14007                 c = nextc();
14008             }
14009 
14010           decode_num:
14011             pushback(c);
14012             if (nondigit) {
14013                 char tmp[30];
14014               trailing_uc:
14015                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14016                 yyerror(tmp);
14017             }
14018             tokfix();
14019             if (is_float) {
14020                 double d = strtod(tok(), 0);
14021                 if (errno == ERANGE) {
14022                     rb_warningS("Float %s out of range", tok());
14023                     errno = 0;
14024                 }
14025                 set_yylval_literal(DBL2NUM(d));
14026                 return tFLOAT;
14027             }
14028             set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
14029             return tINTEGER;
14030         }
14031 
14032       case ')':
14033       case ']':
14034         paren_nest--;
14035       case '}':
14036         COND_LEXPOP();
14037         CMDARG_LEXPOP();
14038         if (c == ')')
14039             lex_state = EXPR_ENDFN;
14040         else
14041             lex_state = EXPR_ENDARG;
14042         if (c == '}') {
14043             if (!brace_nest--) c = tSTRING_DEND;
14044         }
14045         return c;
14046 
14047       case ':':
14048         c = nextc();
14049         if (c == ':') {
14050             if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14051                 lex_state = EXPR_BEG;
14052                 return tCOLON3;
14053             }
14054             lex_state = EXPR_DOT;
14055             return tCOLON2;
14056         }
14057         if (IS_END() || ISSPACE(c)) {
14058             pushback(c);
14059             warn_balanced(":", "symbol literal");
14060             lex_state = EXPR_BEG;
14061             return ':';
14062         }
14063         switch (c) {
14064           case '\'':
14065             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14066             break;
14067           case '"':
14068             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14069             break;
14070           default:
14071             pushback(c);
14072             break;
14073         }
14074         lex_state = EXPR_FNAME;
14075         return tSYMBEG;
14076 
14077       case '/':
14078         if (IS_lex_state(EXPR_BEG_ANY)) {
14079             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14080             return tREGEXP_BEG;
14081         }
14082         if ((c = nextc()) == '=') {
14083             set_yylval_id('/');
14084             lex_state = EXPR_BEG;
14085             return tOP_ASGN;
14086         }
14087         pushback(c);
14088         if (IS_SPCARG(c)) {
14089             (void)arg_ambiguous();
14090             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14091             return tREGEXP_BEG;
14092         }
14093         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14094         warn_balanced("/", "regexp literal");
14095         return '/';
14096 
14097       case '^':
14098         if ((c = nextc()) == '=') {
14099             set_yylval_id('^');
14100             lex_state = EXPR_BEG;
14101             return tOP_ASGN;
14102         }
14103         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14104         pushback(c);
14105         return '^';
14106 
14107       case ';':
14108         lex_state = EXPR_BEG;
14109         command_start = TRUE;
14110         return ';';
14111 
14112       case ',':
14113         lex_state = EXPR_BEG;
14114         return ',';
14115 
14116       case '~':
14117         if (IS_AFTER_OPERATOR()) {
14118             if ((c = nextc()) != '@') {
14119                 pushback(c);
14120             }
14121             lex_state = EXPR_ARG;
14122         }
14123         else {
14124             lex_state = EXPR_BEG;
14125         }
14126         return '~';
14127 
14128       case '(':
14129         if (IS_BEG()) {
14130             c = tLPAREN;
14131         }
14132         else if (IS_SPCARG(-1)) {
14133             c = tLPAREN_ARG;
14134         }
14135         paren_nest++;
14136         COND_PUSH(0);
14137         CMDARG_PUSH(0);
14138         lex_state = EXPR_BEG;
14139         return c;
14140 
14141       case '[':
14142         paren_nest++;
14143         if (IS_AFTER_OPERATOR()) {
14144             lex_state = EXPR_ARG;
14145             if ((c = nextc()) == ']') {
14146                 if ((c = nextc()) == '=') {
14147                     return tASET;
14148                 }
14149                 pushback(c);
14150                 return tAREF;
14151             }
14152             pushback(c);
14153             return '[';
14154         }
14155         else if (IS_BEG()) {
14156             c = tLBRACK;
14157         }
14158         else if (IS_ARG() && space_seen) {
14159             c = tLBRACK;
14160         }
14161         lex_state = EXPR_BEG;
14162         COND_PUSH(0);
14163         CMDARG_PUSH(0);
14164         return c;
14165 
14166       case '{':
14167         ++brace_nest;
14168         if (lpar_beg && lpar_beg == paren_nest) {
14169             lex_state = EXPR_BEG;
14170             lpar_beg = 0;
14171             --paren_nest;
14172             COND_PUSH(0);
14173             CMDARG_PUSH(0);
14174             return tLAMBEG;
14175         }
14176         if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14177             c = '{';          /* block (primary) */
14178         else if (IS_lex_state(EXPR_ENDARG))
14179             c = tLBRACE_ARG;  /* block (expr) */
14180         else
14181             c = tLBRACE;      /* hash */
14182         COND_PUSH(0);
14183         CMDARG_PUSH(0);
14184         lex_state = EXPR_BEG;
14185         if (c != tLBRACE) command_start = TRUE;
14186         return c;
14187 
14188       case '\\':
14189         c = nextc();
14190         if (c == '\n') {
14191             space_seen = 1;
14192 #ifdef RIPPER
14193             ripper_dispatch_scan_event(parser, tSP);
14194 #endif
14195             goto retry; /* skip \\n */
14196         }
14197         pushback(c);
14198         return '\\';
14199 
14200       case '%':
14201         if (IS_lex_state(EXPR_BEG_ANY)) {
14202             int term;
14203             int paren;
14204 
14205             c = nextc();
14206           quotation:
14207             if (c == -1 || !ISALNUM(c)) {
14208                 term = c;
14209                 c = 'Q';
14210             }
14211             else {
14212                 term = nextc();
14213                 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14214                     yyerror("unknown type of %string");
14215                     return 0;
14216                 }
14217             }
14218             if (c == -1 || term == -1) {
14219                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14220                 return 0;
14221             }
14222             paren = term;
14223             if (term == '(') term = ')';
14224             else if (term == '[') term = ']';
14225             else if (term == '{') term = '}';
14226             else if (term == '<') term = '>';
14227             else paren = 0;
14228 
14229             switch (c) {
14230               case 'Q':
14231                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14232                 return tSTRING_BEG;
14233 
14234               case 'q':
14235                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
14236                 return tSTRING_BEG;
14237 
14238               case 'W':
14239                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14240                 do {c = nextc();} while (ISSPACE(c));
14241                 pushback(c);
14242                 return tWORDS_BEG;
14243 
14244               case 'w':
14245                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14246                 do {c = nextc();} while (ISSPACE(c));
14247                 pushback(c);
14248                 return tQWORDS_BEG;
14249 
14250               case 'I':
14251                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14252                 do {c = nextc();} while (ISSPACE(c));
14253                 pushback(c);
14254                 return tSYMBOLS_BEG;
14255 
14256               case 'i':
14257                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14258                 do {c = nextc();} while (ISSPACE(c));
14259                 pushback(c);
14260                 return tQSYMBOLS_BEG;
14261 
14262               case 'x':
14263                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14264                 return tXSTRING_BEG;
14265 
14266               case 'r':
14267                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14268                 return tREGEXP_BEG;
14269 
14270               case 's':
14271                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14272                 lex_state = EXPR_FNAME;
14273                 return tSYMBEG;
14274 
14275               default:
14276                 yyerror("unknown type of %string");
14277                 return 0;
14278             }
14279         }
14280         if ((c = nextc()) == '=') {
14281             set_yylval_id('%');
14282             lex_state = EXPR_BEG;
14283             return tOP_ASGN;
14284         }
14285         if (IS_SPCARG(c)) {
14286             goto quotation;
14287         }
14288         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14289         pushback(c);
14290         warn_balanced("%%", "string literal");
14291         return '%';
14292 
14293       case '$':
14294         lex_state = EXPR_END;
14295         newtok();
14296         c = nextc();
14297         switch (c) {
14298           case '_':             /* $_: last read line string */
14299             c = nextc();
14300             if (parser_is_identchar()) {
14301                 tokadd('$');
14302                 tokadd('_');
14303                 break;
14304             }
14305             pushback(c);
14306             c = '_';
14307             /* fall through */
14308           case '~':             /* $~: match-data */
14309           case '*':             /* $*: argv */
14310           case '$':             /* $$: pid */
14311           case '?':             /* $?: last status */
14312           case '!':             /* $!: error string */
14313           case '@':             /* $@: error position */
14314           case '/':             /* $/: input record separator */
14315           case '\\':            /* $\: output record separator */
14316           case ';':             /* $;: field separator */
14317           case ',':             /* $,: output field separator */
14318           case '.':             /* $.: last read line number */
14319           case '=':             /* $=: ignorecase */
14320           case ':':             /* $:: load path */
14321           case '<':             /* $<: reading filename */
14322           case '>':             /* $>: default output handle */
14323           case '\"':            /* $": already loaded files */
14324             tokadd('$');
14325             tokadd(c);
14326             tokfix();
14327             set_yylval_name(rb_intern(tok()));
14328             return tGVAR;
14329 
14330           case '-':
14331             tokadd('$');
14332             tokadd(c);
14333             c = nextc();
14334             if (parser_is_identchar()) {
14335                 if (tokadd_mbchar(c) == -1) return 0;
14336             }
14337             else {
14338                 pushback(c);
14339             }
14340           gvar:
14341             tokfix();
14342             set_yylval_name(rb_intern(tok()));
14343             return tGVAR;
14344 
14345           case '&':             /* $&: last match */
14346           case '`':             /* $`: string before last match */
14347           case '\'':            /* $': string after last match */
14348           case '+':             /* $+: string matches last paren. */
14349             if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14350                 tokadd('$');
14351                 tokadd(c);
14352                 goto gvar;
14353             }
14354             set_yylval_node(NEW_BACK_REF(c));
14355             return tBACK_REF;
14356 
14357           case '1': case '2': case '3':
14358           case '4': case '5': case '6':
14359           case '7': case '8': case '9':
14360             tokadd('$');
14361             do {
14362                 tokadd(c);
14363                 c = nextc();
14364             } while (c != -1 && ISDIGIT(c));
14365             pushback(c);
14366             if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14367             tokfix();
14368             set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14369             return tNTH_REF;
14370 
14371           default:
14372             if (!parser_is_identchar()) {
14373                 pushback(c);
14374                 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14375                 return 0;
14376             }
14377           case '0':
14378             tokadd('$');
14379         }
14380         break;
14381 
14382       case '@':
14383         c = nextc();
14384         newtok();
14385         tokadd('@');
14386         if (c == '@') {
14387             tokadd('@');
14388             c = nextc();
14389         }
14390         if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14391             pushback(c);
14392             if (tokidx == 1) {
14393                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14394             }
14395             else {
14396                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14397             }
14398             return 0;
14399         }
14400         break;
14401 
14402       case '_':
14403         if (was_bol() && whole_match_p("__END__", 7, 0)) {
14404             ruby__end__seen = 1;
14405             parser->eofp = Qtrue;
14406 #ifndef RIPPER
14407             return -1;
14408 #else
14409             lex_goto_eol(parser);
14410             ripper_dispatch_scan_event(parser, k__END__);
14411             return 0;
14412 #endif
14413         }
14414         newtok();
14415         break;
14416 
14417       default:
14418         if (!parser_is_identchar()) {
14419             compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
14420             goto retry;
14421         }
14422 
14423         newtok();
14424         break;
14425     }
14426 
14427     mb = ENC_CODERANGE_7BIT;
14428     do {
14429         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14430         if (tokadd_mbchar(c) == -1) return 0;
14431         c = nextc();
14432     } while (parser_is_identchar());
14433     switch (tok()[0]) {
14434       case '@': case '$':
14435         pushback(c);
14436         break;
14437       default:
14438         if ((c == '!' || c == '?') && !peek('=')) {
14439             tokadd(c);
14440         }
14441         else {
14442             pushback(c);
14443         }
14444     }
14445     tokfix();
14446 
14447     {
14448         int result = 0;
14449 
14450         last_state = lex_state;
14451         switch (tok()[0]) {
14452           case '$':
14453             lex_state = EXPR_END;
14454             result = tGVAR;
14455             break;
14456           case '@':
14457             lex_state = EXPR_END;
14458             if (tok()[1] == '@')
14459                 result = tCVAR;
14460             else
14461                 result = tIVAR;
14462             break;
14463 
14464           default:
14465             if (toklast() == '!' || toklast() == '?') {
14466                 result = tFID;
14467             }
14468             else {
14469                 if (IS_lex_state(EXPR_FNAME)) {
14470                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14471                         (!peek('=') || (peek_n('>', 1)))) {
14472                         result = tIDENTIFIER;
14473                         tokadd(c);
14474                         tokfix();
14475                     }
14476                     else {
14477                         pushback(c);
14478                     }
14479                 }
14480                 if (result == 0 && ISUPPER(tok()[0])) {
14481                     result = tCONSTANT;
14482                 }
14483                 else {
14484                     result = tIDENTIFIER;
14485                 }
14486             }
14487 
14488             if (IS_LABEL_POSSIBLE()) {
14489                 if (IS_LABEL_SUFFIX(0)) {
14490                     lex_state = EXPR_BEG;
14491                     nextc();
14492                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
14493                     return tLABEL;
14494                 }
14495             }
14496             if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14497                 const struct kwtable *kw;
14498 
14499                 /* See if it is a reserved word.  */
14500                 kw = rb_reserved_word(tok(), toklen());
14501                 if (kw) {
14502                     enum lex_state_e state = lex_state;
14503                     lex_state = kw->state;
14504                     if (state == EXPR_FNAME) {
14505                         set_yylval_name(rb_intern(kw->name));
14506                         return kw->id[0];
14507                     }
14508                     if (lex_state == EXPR_BEG) {
14509                         command_start = TRUE;
14510                     }
14511                     if (kw->id[0] == keyword_do) {
14512                         if (lpar_beg && lpar_beg == paren_nest) {
14513                             lpar_beg = 0;
14514                             --paren_nest;
14515                             return keyword_do_LAMBDA;
14516                         }
14517                         if (COND_P()) return keyword_do_cond;
14518                         if (CMDARG_P() && state != EXPR_CMDARG)
14519                             return keyword_do_block;
14520                         if (state & (EXPR_BEG | EXPR_ENDARG))
14521                             return keyword_do_block;
14522                         return keyword_do;
14523                     }
14524                     if (state & (EXPR_BEG | EXPR_VALUE))
14525                         return kw->id[0];
14526                     else {
14527                         if (kw->id[0] != kw->id[1])
14528                             lex_state = EXPR_BEG;
14529                         return kw->id[1];
14530                     }
14531                 }
14532             }
14533 
14534             if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14535                 if (cmd_state) {
14536                     lex_state = EXPR_CMDARG;
14537                 }
14538                 else {
14539                     lex_state = EXPR_ARG;
14540                 }
14541             }
14542             else if (lex_state == EXPR_FNAME) {
14543                 lex_state = EXPR_ENDFN;
14544             }
14545             else {
14546                 lex_state = EXPR_END;
14547             }
14548         }
14549         {
14550             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14551 
14552             set_yylval_name(ident);
14553             if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14554                 is_local_id(ident) && lvar_defined(ident)) {
14555                 lex_state = EXPR_END;
14556             }
14557         }
14558         return result;
14559     }
14560 }
14561 
14562 #if YYPURE
14563 static int
14564 yylex(void *lval, void *p)
14565 #else
14566 yylex(void *p)
14567 #endif
14568 {
14569     struct parser_params *parser = (struct parser_params*)p;
14570     int t;
14571 
14572 #if YYPURE
14573     parser->parser_yylval = lval;
14574     parser->parser_yylval->val = Qundef;
14575 #endif
14576     t = parser_yylex(parser);
14577 #ifdef RIPPER
14578     if (!NIL_P(parser->delayed)) {
14579         ripper_dispatch_delayed_token(parser, t);
14580         return t;
14581     }
14582     if (t != 0)
14583         ripper_dispatch_scan_event(parser, t);
14584 #endif
14585 
14586     return t;
14587 }
14588 
14589 #ifndef RIPPER
14590 static NODE*
14591 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14592 {
14593     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14594     nd_set_line(n, ruby_sourceline);
14595     return n;
14596 }
14597 
14598 static enum node_type
14599 nodetype(NODE *node)                    /* for debug */
14600 {
14601     return (enum node_type)nd_type(node);
14602 }
14603 
14604 static int
14605 nodeline(NODE *node)
14606 {
14607     return nd_line(node);
14608 }
14609 
14610 static NODE*
14611 newline_node(NODE *node)
14612 {
14613     if (node) {
14614         node = remove_begin(node);
14615         node->flags |= NODE_FL_NEWLINE;
14616     }
14617     return node;
14618 }
14619 
14620 static void
14621 fixpos(NODE *node, NODE *orig)
14622 {
14623     if (!node) return;
14624     if (!orig) return;
14625     if (orig == (NODE*)1) return;
14626     nd_set_line(node, nd_line(orig));
14627 }
14628 
14629 static void
14630 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14631 {
14632     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14633 }
14634 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14635 
14636 static void
14637 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14638 {
14639     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14640 }
14641 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14642 
14643 static NODE*
14644 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14645 {
14646     NODE *end, *h = head, *nd;
14647 
14648     if (tail == 0) return head;
14649 
14650     if (h == 0) return tail;
14651     switch (nd_type(h)) {
14652       case NODE_LIT:
14653       case NODE_STR:
14654       case NODE_SELF:
14655       case NODE_TRUE:
14656       case NODE_FALSE:
14657       case NODE_NIL:
14658         parser_warning(h, "unused literal ignored");
14659         return tail;
14660       default:
14661         h = end = NEW_BLOCK(head);
14662         end->nd_end = end;
14663         fixpos(end, head);
14664         head = end;
14665         break;
14666       case NODE_BLOCK:
14667         end = h->nd_end;
14668         break;
14669     }
14670 
14671     nd = end->nd_head;
14672     switch (nd_type(nd)) {
14673       case NODE_RETURN:
14674       case NODE_BREAK:
14675       case NODE_NEXT:
14676       case NODE_REDO:
14677       case NODE_RETRY:
14678         if (RTEST(ruby_verbose)) {
14679             parser_warning(tail, "statement not reached");
14680         }
14681         break;
14682 
14683       default:
14684         break;
14685     }
14686 
14687     if (nd_type(tail) != NODE_BLOCK) {
14688         tail = NEW_BLOCK(tail);
14689         tail->nd_end = tail;
14690     }
14691     end->nd_next = tail;
14692     h->nd_end = tail->nd_end;
14693     return head;
14694 }
14695 
14696 /* append item to the list */
14697 static NODE*
14698 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14699 {
14700     NODE *last;
14701 
14702     if (list == 0) return NEW_LIST(item);
14703     if (list->nd_next) {
14704         last = list->nd_next->nd_end;
14705     }
14706     else {
14707         last = list;
14708     }
14709 
14710     list->nd_alen += 1;
14711     last->nd_next = NEW_LIST(item);
14712     list->nd_next->nd_end = last->nd_next;
14713     return list;
14714 }
14715 
14716 /* concat two lists */
14717 static NODE*
14718 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14719 {
14720     NODE *last;
14721 
14722     if (head->nd_next) {
14723         last = head->nd_next->nd_end;
14724     }
14725     else {
14726         last = head;
14727     }
14728 
14729     head->nd_alen += tail->nd_alen;
14730     last->nd_next = tail;
14731     if (tail->nd_next) {
14732         head->nd_next->nd_end = tail->nd_next->nd_end;
14733     }
14734     else {
14735         head->nd_next->nd_end = tail;
14736     }
14737 
14738     return head;
14739 }
14740 
14741 static int
14742 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14743 {
14744     if (NIL_P(tail)) return 1;
14745     if (!rb_enc_compatible(head, tail)) {
14746         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14747                       rb_enc_name(rb_enc_get(head)),
14748                       rb_enc_name(rb_enc_get(tail)));
14749         rb_str_resize(head, 0);
14750         rb_str_resize(tail, 0);
14751         return 0;
14752     }
14753     rb_str_buf_append(head, tail);
14754     return 1;
14755 }
14756 
14757 /* concat two string literals */
14758 static NODE *
14759 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14760 {
14761     enum node_type htype;
14762     NODE *headlast;
14763     VALUE lit;
14764 
14765     if (!head) return tail;
14766     if (!tail) return head;
14767 
14768     htype = nd_type(head);
14769     if (htype == NODE_EVSTR) {
14770         NODE *node = NEW_DSTR(Qnil);
14771         head = list_append(node, head);
14772         htype = NODE_DSTR;
14773     }
14774     switch (nd_type(tail)) {
14775       case NODE_STR:
14776         if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14777             nd_type(headlast) == NODE_STR) {
14778             htype = NODE_STR;
14779             lit = headlast->nd_lit;
14780         }
14781         else {
14782             lit = head->nd_lit;
14783         }
14784         if (htype == NODE_STR) {
14785             if (!literal_concat0(parser, lit, tail->nd_lit)) {
14786               error:
14787                 rb_gc_force_recycle((VALUE)head);
14788                 rb_gc_force_recycle((VALUE)tail);
14789                 return 0;
14790             }
14791             rb_gc_force_recycle((VALUE)tail);
14792         }
14793         else {
14794             list_append(head, tail);
14795         }
14796         break;
14797 
14798       case NODE_DSTR:
14799         if (htype == NODE_STR) {
14800             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14801                 goto error;
14802             tail->nd_lit = head->nd_lit;
14803             rb_gc_force_recycle((VALUE)head);
14804             head = tail;
14805         }
14806         else if (NIL_P(tail->nd_lit)) {
14807           append:
14808             head->nd_alen += tail->nd_alen - 1;
14809             head->nd_next->nd_end->nd_next = tail->nd_next;
14810             head->nd_next->nd_end = tail->nd_next->nd_end;
14811             rb_gc_force_recycle((VALUE)tail);
14812         }
14813         else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14814                  nd_type(headlast) == NODE_STR) {
14815             lit = headlast->nd_lit;
14816             if (!literal_concat0(parser, lit, tail->nd_lit))
14817                 goto error;
14818             tail->nd_lit = Qnil;
14819             goto append;
14820         }
14821         else {
14822             nd_set_type(tail, NODE_ARRAY);
14823             tail->nd_head = NEW_STR(tail->nd_lit);
14824             list_concat(head, tail);
14825         }
14826         break;
14827 
14828       case NODE_EVSTR:
14829         if (htype == NODE_STR) {
14830             nd_set_type(head, NODE_DSTR);
14831             head->nd_alen = 1;
14832         }
14833         list_append(head, tail);
14834         break;
14835     }
14836     return head;
14837 }
14838 
14839 static NODE *
14840 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14841 {
14842     if (nd_type(node) == NODE_EVSTR) {
14843         node = list_append(NEW_DSTR(Qnil), node);
14844     }
14845     return node;
14846 }
14847 
14848 static NODE *
14849 new_evstr_gen(struct parser_params *parser, NODE *node)
14850 {
14851     NODE *head = node;
14852 
14853     if (node) {
14854         switch (nd_type(node)) {
14855           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14856             return node;
14857         }
14858     }
14859     return NEW_EVSTR(head);
14860 }
14861 
14862 static NODE *
14863 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14864 {
14865     value_expr(recv);
14866     value_expr(arg1);
14867     return NEW_CALL(recv, id, NEW_LIST(arg1));
14868 }
14869 
14870 static NODE *
14871 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14872 {
14873     value_expr(recv);
14874     return NEW_CALL(recv, id, 0);
14875 }
14876 
14877 static NODE*
14878 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14879 {
14880     value_expr(node1);
14881     value_expr(node2);
14882     if (node1) {
14883         switch (nd_type(node1)) {
14884           case NODE_DREGX:
14885           case NODE_DREGX_ONCE:
14886             return NEW_MATCH2(node1, node2);
14887 
14888           case NODE_LIT:
14889             if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14890                 return NEW_MATCH2(node1, node2);
14891             }
14892         }
14893     }
14894 
14895     if (node2) {
14896         switch (nd_type(node2)) {
14897           case NODE_DREGX:
14898           case NODE_DREGX_ONCE:
14899             return NEW_MATCH3(node2, node1);
14900 
14901           case NODE_LIT:
14902             if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14903                 return NEW_MATCH3(node2, node1);
14904             }
14905         }
14906     }
14907 
14908     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14909 }
14910 
14911 static NODE*
14912 gettable_gen(struct parser_params *parser, ID id)
14913 {
14914     switch (id) {
14915       case keyword_self:
14916         return NEW_SELF();
14917       case keyword_nil:
14918         return NEW_NIL();
14919       case keyword_true:
14920         return NEW_TRUE();
14921       case keyword_false:
14922         return NEW_FALSE();
14923       case keyword__FILE__:
14924         return NEW_STR(rb_str_dup(ruby_sourcefile_string));
14925       case keyword__LINE__:
14926         return NEW_LIT(INT2FIX(tokline));
14927       case keyword__ENCODING__:
14928         return NEW_LIT(rb_enc_from_encoding(current_enc));
14929     }
14930     switch (id_type(id)) {
14931       case ID_LOCAL:
14932         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14933         if (local_id(id)) return NEW_LVAR(id);
14934         /* method call without arguments */
14935         return NEW_VCALL(id);
14936       case ID_GLOBAL:
14937         return NEW_GVAR(id);
14938       case ID_INSTANCE:
14939         return NEW_IVAR(id);
14940       case ID_CONST:
14941         return NEW_CONST(id);
14942       case ID_CLASS:
14943         return NEW_CVAR(id);
14944     }
14945     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14946     return 0;
14947 }
14948 #else  /* !RIPPER */
14949 static int
14950 id_is_var_gen(struct parser_params *parser, ID id)
14951 {
14952     if (is_notop_id(id)) {
14953         switch (id & ID_SCOPE_MASK) {
14954           case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14955             return 1;
14956           case ID_LOCAL:
14957             if (dyna_in_block() && dvar_defined(id)) return 1;
14958             if (local_id(id)) return 1;
14959             /* method call without arguments */
14960             return 0;
14961         }
14962     }
14963     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14964     return 0;
14965 }
14966 #endif /* !RIPPER */
14967 
14968 #if PARSER_DEBUG
14969 static const char *
14970 lex_state_name(enum lex_state_e state)
14971 {
14972     static const char names[][12] = {
14973         "EXPR_BEG",    "EXPR_END",    "EXPR_ENDARG", "EXPR_ENDFN",  "EXPR_ARG",
14974         "EXPR_CMDARG", "EXPR_MID",    "EXPR_FNAME",  "EXPR_DOT",    "EXPR_CLASS",
14975         "EXPR_VALUE",
14976     };
14977 
14978     if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
14979         return names[ffs(state)];
14980     return NULL;
14981 }
14982 #endif
14983 
14984 #ifdef RIPPER
14985 static VALUE
14986 assignable_gen(struct parser_params *parser, VALUE lhs)
14987 #else
14988 static NODE*
14989 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14990 #endif
14991 {
14992 #ifdef RIPPER
14993     ID id = get_id(lhs);
14994 # define assignable_result(x) get_value(lhs)
14995 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14996 #else
14997 # define assignable_result(x) (x)
14998 #endif
14999     if (!id) return assignable_result(0);
15000     switch (id) {
15001       case keyword_self:
15002         yyerror("Can't change the value of self");
15003         goto error;
15004       case keyword_nil:
15005         yyerror("Can't assign to nil");
15006         goto error;
15007       case keyword_true:
15008         yyerror("Can't assign to true");
15009         goto error;
15010       case keyword_false:
15011         yyerror("Can't assign to false");
15012         goto error;
15013       case keyword__FILE__:
15014         yyerror("Can't assign to __FILE__");
15015         goto error;
15016       case keyword__LINE__:
15017         yyerror("Can't assign to __LINE__");
15018         goto error;
15019       case keyword__ENCODING__:
15020         yyerror("Can't assign to __ENCODING__");
15021         goto error;
15022     }
15023     switch (id_type(id)) {
15024       case ID_LOCAL:
15025         if (dyna_in_block()) {
15026             if (dvar_curr(id)) {
15027                 return assignable_result(NEW_DASGN_CURR(id, val));
15028             }
15029             else if (dvar_defined(id)) {
15030                 return assignable_result(NEW_DASGN(id, val));
15031             }
15032             else if (local_id(id)) {
15033                 return assignable_result(NEW_LASGN(id, val));
15034             }
15035             else {
15036                 dyna_var(id);
15037                 return assignable_result(NEW_DASGN_CURR(id, val));
15038             }
15039         }
15040         else {
15041             if (!local_id(id)) {
15042                 local_var(id);
15043             }
15044             return assignable_result(NEW_LASGN(id, val));
15045         }
15046         break;
15047       case ID_GLOBAL:
15048         return assignable_result(NEW_GASGN(id, val));
15049       case ID_INSTANCE:
15050         return assignable_result(NEW_IASGN(id, val));
15051       case ID_CONST:
15052         if (!in_def && !in_single)
15053             return assignable_result(NEW_CDECL(id, val, 0));
15054         yyerror("dynamic constant assignment");
15055         break;
15056       case ID_CLASS:
15057         return assignable_result(NEW_CVASGN(id, val));
15058       default:
15059         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15060     }
15061   error:
15062     return assignable_result(0);
15063 #undef assignable_result
15064 #undef parser_yyerror
15065 }
15066 
15067 static int
15068 is_private_local_id(ID name)
15069 {
15070     VALUE s;
15071     if (name == idUScore) return 1;
15072     if (!is_local_id(name)) return 0;
15073     s = rb_id2str(name);
15074     if (!s) return 0;
15075     return RSTRING_PTR(s)[0] == '_';
15076 }
15077 
15078 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15079 
15080 static ID
15081 shadowing_lvar_gen(struct parser_params *parser, ID name)
15082 {
15083     if (is_private_local_id(name)) return name;
15084     if (dyna_in_block()) {
15085         if (dvar_curr(name)) {
15086             yyerror("duplicated argument name");
15087         }
15088         else if (dvar_defined_get(name) || local_id(name)) {
15089             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15090             vtable_add(lvtbl->vars, name);
15091             if (lvtbl->used) {
15092                 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15093             }
15094         }
15095     }
15096     else {
15097         if (local_id(name)) {
15098             yyerror("duplicated argument name");
15099         }
15100     }
15101     return name;
15102 }
15103 
15104 static void
15105 new_bv_gen(struct parser_params *parser, ID name)
15106 {
15107     if (!name) return;
15108     if (!is_local_id(name)) {
15109         compile_error(PARSER_ARG "invalid local variable - %s",
15110                       rb_id2name(name));
15111         return;
15112     }
15113     shadowing_lvar(name);
15114     dyna_var(name);
15115 }
15116 
15117 #ifndef RIPPER
15118 static NODE *
15119 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15120 {
15121     if (recv && nd_type(recv) == NODE_SELF)
15122         recv = (NODE *)1;
15123     return NEW_ATTRASGN(recv, tASET, idx);
15124 }
15125 
15126 static void
15127 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15128 {
15129     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15130         compile_error(PARSER_ARG "both block arg and actual block given");
15131     }
15132 }
15133 
15134 static const char id_type_names[][9] = {
15135     "LOCAL",
15136     "INSTANCE",
15137     "",                         /* INSTANCE2 */
15138     "GLOBAL",
15139     "ATTRSET",
15140     "CONST",
15141     "CLASS",
15142     "JUNK",
15143 };
15144 
15145 ID
15146 rb_id_attrset(ID id)
15147 {
15148     if (!is_notop_id(id)) {
15149         switch (id) {
15150           case tAREF: case tASET:
15151             return tASET;       /* only exception */
15152         }
15153         rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15154     }
15155     else {
15156         int scope = (int)(id & ID_SCOPE_MASK);
15157         switch (scope) {
15158           case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15159           case ID_CONST: case ID_CLASS: case ID_JUNK:
15160             break;
15161           case ID_ATTRSET:
15162             return id;
15163           default:
15164             rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15165                           id_type_names[scope], ID2SYM(id));
15166 
15167         }
15168     }
15169     id &= ~ID_SCOPE_MASK;
15170     id |= ID_ATTRSET;
15171     return id;
15172 }
15173 
15174 static NODE *
15175 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15176 {
15177     if (recv && nd_type(recv) == NODE_SELF)
15178         recv = (NODE *)1;
15179     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15180 }
15181 
15182 static void
15183 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15184 {
15185     switch (nd_type(node)) {
15186       case NODE_NTH_REF:
15187         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15188         break;
15189       case NODE_BACK_REF:
15190         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15191         break;
15192     }
15193 }
15194 
15195 static NODE *
15196 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15197 {
15198     if (!node2) return node1;
15199     switch (nd_type(node1)) {
15200       case NODE_BLOCK_PASS:
15201         if (node1->nd_head)
15202             node1->nd_head = arg_concat(node1->nd_head, node2);
15203         else
15204             node1->nd_head = NEW_LIST(node2);
15205         return node1;
15206       case NODE_ARGSPUSH:
15207         if (nd_type(node2) != NODE_ARRAY) break;
15208         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15209         nd_set_type(node1, NODE_ARGSCAT);
15210         return node1;
15211       case NODE_ARGSCAT:
15212         if (nd_type(node2) != NODE_ARRAY ||
15213             nd_type(node1->nd_body) != NODE_ARRAY) break;
15214         node1->nd_body = list_concat(node1->nd_body, node2);
15215         return node1;
15216     }
15217     return NEW_ARGSCAT(node1, node2);
15218 }
15219 
15220 static NODE *
15221 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15222 {
15223     if (!node1) return NEW_LIST(node2);
15224     switch (nd_type(node1))  {
15225       case NODE_ARRAY:
15226         return list_append(node1, node2);
15227       case NODE_BLOCK_PASS:
15228         node1->nd_head = arg_append(node1->nd_head, node2);
15229         return node1;
15230       case NODE_ARGSPUSH:
15231         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15232         nd_set_type(node1, NODE_ARGSCAT);
15233         return node1;
15234     }
15235     return NEW_ARGSPUSH(node1, node2);
15236 }
15237 
15238 static NODE *
15239 splat_array(NODE* node)
15240 {
15241     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15242     if (nd_type(node) == NODE_ARRAY) return node;
15243     return 0;
15244 }
15245 
15246 static NODE *
15247 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15248 {
15249     if (!lhs) return 0;
15250 
15251     switch (nd_type(lhs)) {
15252       case NODE_GASGN:
15253       case NODE_IASGN:
15254       case NODE_IASGN2:
15255       case NODE_LASGN:
15256       case NODE_DASGN:
15257       case NODE_DASGN_CURR:
15258       case NODE_MASGN:
15259       case NODE_CDECL:
15260       case NODE_CVASGN:
15261         lhs->nd_value = rhs;
15262         break;
15263 
15264       case NODE_ATTRASGN:
15265       case NODE_CALL:
15266         lhs->nd_args = arg_append(lhs->nd_args, rhs);
15267         break;
15268 
15269       default:
15270         /* should not happen */
15271         break;
15272     }
15273 
15274     return lhs;
15275 }
15276 
15277 static int
15278 value_expr_gen(struct parser_params *parser, NODE *node)
15279 {
15280     int cond = 0;
15281 
15282     if (!node) {
15283         rb_warning0("empty expression");
15284     }
15285     while (node) {
15286         switch (nd_type(node)) {
15287           case NODE_DEFN:
15288           case NODE_DEFS:
15289             parser_warning(node, "void value expression");
15290             return FALSE;
15291 
15292           case NODE_RETURN:
15293           case NODE_BREAK:
15294           case NODE_NEXT:
15295           case NODE_REDO:
15296           case NODE_RETRY:
15297             if (!cond) yyerror("void value expression");
15298             /* or "control never reach"? */
15299             return FALSE;
15300 
15301           case NODE_BLOCK:
15302             while (node->nd_next) {
15303                 node = node->nd_next;
15304             }
15305             node = node->nd_head;
15306             break;
15307 
15308           case NODE_BEGIN:
15309             node = node->nd_body;
15310             break;
15311 
15312           case NODE_IF:
15313             if (!node->nd_body) {
15314                 node = node->nd_else;
15315                 break;
15316             }
15317             else if (!node->nd_else) {
15318                 node = node->nd_body;
15319                 break;
15320             }
15321             if (!value_expr(node->nd_body)) return FALSE;
15322             node = node->nd_else;
15323             break;
15324 
15325           case NODE_AND:
15326           case NODE_OR:
15327             cond = 1;
15328             node = node->nd_2nd;
15329             break;
15330 
15331           default:
15332             return TRUE;
15333         }
15334     }
15335 
15336     return TRUE;
15337 }
15338 
15339 static void
15340 void_expr_gen(struct parser_params *parser, NODE *node)
15341 {
15342     const char *useless = 0;
15343 
15344     if (!RTEST(ruby_verbose)) return;
15345 
15346     if (!node) return;
15347     switch (nd_type(node)) {
15348       case NODE_CALL:
15349         switch (node->nd_mid) {
15350           case '+':
15351           case '-':
15352           case '*':
15353           case '/':
15354           case '%':
15355           case tPOW:
15356           case tUPLUS:
15357           case tUMINUS:
15358           case '|':
15359           case '^':
15360           case '&':
15361           case tCMP:
15362           case '>':
15363           case tGEQ:
15364           case '<':
15365           case tLEQ:
15366           case tEQ:
15367           case tNEQ:
15368             useless = rb_id2name(node->nd_mid);
15369             break;
15370         }
15371         break;
15372 
15373       case NODE_LVAR:
15374       case NODE_DVAR:
15375       case NODE_GVAR:
15376       case NODE_IVAR:
15377       case NODE_CVAR:
15378       case NODE_NTH_REF:
15379       case NODE_BACK_REF:
15380         useless = "a variable";
15381         break;
15382       case NODE_CONST:
15383         useless = "a constant";
15384         break;
15385       case NODE_LIT:
15386       case NODE_STR:
15387       case NODE_DSTR:
15388       case NODE_DREGX:
15389       case NODE_DREGX_ONCE:
15390         useless = "a literal";
15391         break;
15392       case NODE_COLON2:
15393       case NODE_COLON3:
15394         useless = "::";
15395         break;
15396       case NODE_DOT2:
15397         useless = "..";
15398         break;
15399       case NODE_DOT3:
15400         useless = "...";
15401         break;
15402       case NODE_SELF:
15403         useless = "self";
15404         break;
15405       case NODE_NIL:
15406         useless = "nil";
15407         break;
15408       case NODE_TRUE:
15409         useless = "true";
15410         break;
15411       case NODE_FALSE:
15412         useless = "false";
15413         break;
15414       case NODE_DEFINED:
15415         useless = "defined?";
15416         break;
15417     }
15418 
15419     if (useless) {
15420         int line = ruby_sourceline;
15421 
15422         ruby_sourceline = nd_line(node);
15423         rb_warnS("possibly useless use of %s in void context", useless);
15424         ruby_sourceline = line;
15425     }
15426 }
15427 
15428 static void
15429 void_stmts_gen(struct parser_params *parser, NODE *node)
15430 {
15431     if (!RTEST(ruby_verbose)) return;
15432     if (!node) return;
15433     if (nd_type(node) != NODE_BLOCK) return;
15434 
15435     for (;;) {
15436         if (!node->nd_next) return;
15437         void_expr0(node->nd_head);
15438         node = node->nd_next;
15439     }
15440 }
15441 
15442 static NODE *
15443 remove_begin(NODE *node)
15444 {
15445     NODE **n = &node, *n1 = node;
15446     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15447         *n = n1 = n1->nd_body;
15448     }
15449     return node;
15450 }
15451 
15452 static void
15453 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15454 {
15455     NODE *node = *body;
15456 
15457     if (!node) {
15458         *body = NEW_NIL();
15459         return;
15460     }
15461 #define subnodes(n1, n2) \
15462     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15463      (!node->n2) ? (body = &node->n1, 1) : \
15464      (reduce_nodes(&node->n1), body = &node->n2, 1))
15465 
15466     while (node) {
15467         int newline = (int)(node->flags & NODE_FL_NEWLINE);
15468         switch (nd_type(node)) {
15469           end:
15470           case NODE_NIL:
15471             *body = 0;
15472             return;
15473           case NODE_RETURN:
15474             *body = node = node->nd_stts;
15475             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15476             continue;
15477           case NODE_BEGIN:
15478             *body = node = node->nd_body;
15479             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15480             continue;
15481           case NODE_BLOCK:
15482             body = &node->nd_end->nd_head;
15483             break;
15484           case NODE_IF:
15485             if (subnodes(nd_body, nd_else)) break;
15486             return;
15487           case NODE_CASE:
15488             body = &node->nd_body;
15489             break;
15490           case NODE_WHEN:
15491             if (!subnodes(nd_body, nd_next)) goto end;
15492             break;
15493           case NODE_ENSURE:
15494             if (!subnodes(nd_head, nd_resq)) goto end;
15495             break;
15496           case NODE_RESCUE:
15497             if (node->nd_else) {
15498                 body = &node->nd_resq;
15499                 break;
15500             }
15501             if (!subnodes(nd_head, nd_resq)) goto end;
15502             break;
15503           default:
15504             return;
15505         }
15506         node = *body;
15507         if (newline && node) node->flags |= NODE_FL_NEWLINE;
15508     }
15509 
15510 #undef subnodes
15511 }
15512 
15513 static int
15514 is_static_content(NODE *node)
15515 {
15516     if (!node) return 1;
15517     switch (nd_type(node)) {
15518       case NODE_HASH:
15519         if (!(node = node->nd_head)) break;
15520       case NODE_ARRAY:
15521         do {
15522             if (!is_static_content(node->nd_head)) return 0;
15523         } while ((node = node->nd_next) != 0);
15524       case NODE_LIT:
15525       case NODE_STR:
15526       case NODE_NIL:
15527       case NODE_TRUE:
15528       case NODE_FALSE:
15529       case NODE_ZARRAY:
15530         break;
15531       default:
15532         return 0;
15533     }
15534     return 1;
15535 }
15536 
15537 static int
15538 assign_in_cond(struct parser_params *parser, NODE *node)
15539 {
15540     switch (nd_type(node)) {
15541       case NODE_MASGN:
15542         yyerror("multiple assignment in conditional");
15543         return 1;
15544 
15545       case NODE_LASGN:
15546       case NODE_DASGN:
15547       case NODE_DASGN_CURR:
15548       case NODE_GASGN:
15549       case NODE_IASGN:
15550         break;
15551 
15552       default:
15553         return 0;
15554     }
15555 
15556     if (!node->nd_value) return 1;
15557     if (is_static_content(node->nd_value)) {
15558         /* reports always */
15559         parser_warn(node->nd_value, "found = in conditional, should be ==");
15560     }
15561     return 1;
15562 }
15563 
15564 static void
15565 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15566 {
15567     if (!e_option_supplied(parser)) parser_warn(node, str);
15568 }
15569 
15570 static void
15571 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15572 {
15573     if (!e_option_supplied(parser)) parser_warning(node, str);
15574 }
15575 
15576 static void
15577 fixup_nodes(NODE **rootnode)
15578 {
15579     NODE *node, *next, *head;
15580 
15581     for (node = *rootnode; node; node = next) {
15582         enum node_type type;
15583         VALUE val;
15584 
15585         next = node->nd_next;
15586         head = node->nd_head;
15587         rb_gc_force_recycle((VALUE)node);
15588         *rootnode = next;
15589         switch (type = nd_type(head)) {
15590           case NODE_DOT2:
15591           case NODE_DOT3:
15592             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15593                                type == NODE_DOT3);
15594             rb_gc_force_recycle((VALUE)head->nd_beg);
15595             rb_gc_force_recycle((VALUE)head->nd_end);
15596             nd_set_type(head, NODE_LIT);
15597             head->nd_lit = val;
15598             break;
15599           default:
15600             break;
15601         }
15602     }
15603 }
15604 
15605 static NODE *cond0(struct parser_params*,NODE*);
15606 
15607 static NODE*
15608 range_op(struct parser_params *parser, NODE *node)
15609 {
15610     enum node_type type;
15611 
15612     if (node == 0) return 0;
15613 
15614     type = nd_type(node);
15615     value_expr(node);
15616     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15617         warn_unless_e_option(parser, node, "integer literal in conditional range");
15618         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15619     }
15620     return cond0(parser, node);
15621 }
15622 
15623 static int
15624 literal_node(NODE *node)
15625 {
15626     if (!node) return 1;        /* same as NODE_NIL */
15627     switch (nd_type(node)) {
15628       case NODE_LIT:
15629       case NODE_STR:
15630       case NODE_DSTR:
15631       case NODE_EVSTR:
15632       case NODE_DREGX:
15633       case NODE_DREGX_ONCE:
15634       case NODE_DSYM:
15635         return 2;
15636       case NODE_TRUE:
15637       case NODE_FALSE:
15638       case NODE_NIL:
15639         return 1;
15640     }
15641     return 0;
15642 }
15643 
15644 static NODE*
15645 cond0(struct parser_params *parser, NODE *node)
15646 {
15647     if (node == 0) return 0;
15648     assign_in_cond(parser, node);
15649 
15650     switch (nd_type(node)) {
15651       case NODE_DSTR:
15652       case NODE_EVSTR:
15653       case NODE_STR:
15654         rb_warn0("string literal in condition");
15655         break;
15656 
15657       case NODE_DREGX:
15658       case NODE_DREGX_ONCE:
15659         warning_unless_e_option(parser, node, "regex literal in condition");
15660         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15661 
15662       case NODE_AND:
15663       case NODE_OR:
15664         node->nd_1st = cond0(parser, node->nd_1st);
15665         node->nd_2nd = cond0(parser, node->nd_2nd);
15666         break;
15667 
15668       case NODE_DOT2:
15669       case NODE_DOT3:
15670         node->nd_beg = range_op(parser, node->nd_beg);
15671         node->nd_end = range_op(parser, node->nd_end);
15672         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15673         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15674         if (!e_option_supplied(parser)) {
15675             int b = literal_node(node->nd_beg);
15676             int e = literal_node(node->nd_end);
15677             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15678                 parser_warn(node, "range literal in condition");
15679             }
15680         }
15681         break;
15682 
15683       case NODE_DSYM:
15684         parser_warning(node, "literal in condition");
15685         break;
15686 
15687       case NODE_LIT:
15688         if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15689             warn_unless_e_option(parser, node, "regex literal in condition");
15690             nd_set_type(node, NODE_MATCH);
15691         }
15692         else {
15693             parser_warning(node, "literal in condition");
15694         }
15695       default:
15696         break;
15697     }
15698     return node;
15699 }
15700 
15701 static NODE*
15702 cond_gen(struct parser_params *parser, NODE *node)
15703 {
15704     if (node == 0) return 0;
15705     return cond0(parser, node);
15706 }
15707 
15708 static NODE*
15709 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15710 {
15711     value_expr(left);
15712     if (left && (enum node_type)nd_type(left) == type) {
15713         NODE *node = left, *second;
15714         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15715             node = second;
15716         }
15717         node->nd_2nd = NEW_NODE(type, second, right, 0);
15718         return left;
15719     }
15720     return NEW_NODE(type, left, right, 0);
15721 }
15722 
15723 static void
15724 no_blockarg(struct parser_params *parser, NODE *node)
15725 {
15726     if (node && nd_type(node) == NODE_BLOCK_PASS) {
15727         compile_error(PARSER_ARG "block argument should not be given");
15728     }
15729 }
15730 
15731 static NODE *
15732 ret_args_gen(struct parser_params *parser, NODE *node)
15733 {
15734     if (node) {
15735         no_blockarg(parser, node);
15736         if (nd_type(node) == NODE_ARRAY) {
15737             if (node->nd_next == 0) {
15738                 node = node->nd_head;
15739             }
15740             else {
15741                 nd_set_type(node, NODE_VALUES);
15742             }
15743         }
15744     }
15745     return node;
15746 }
15747 
15748 static NODE *
15749 new_yield_gen(struct parser_params *parser, NODE *node)
15750 {
15751     if (node) no_blockarg(parser, node);
15752 
15753     return NEW_YIELD(node);
15754 }
15755 
15756 static NODE*
15757 negate_lit(NODE *node)
15758 {
15759     switch (TYPE(node->nd_lit)) {
15760       case T_FIXNUM:
15761         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15762         break;
15763       case T_BIGNUM:
15764         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15765         break;
15766       case T_FLOAT:
15767 #if USE_FLONUM
15768         if (FLONUM_P(node->nd_lit)) {
15769             node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15770         }
15771         else {
15772             RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15773         }
15774 #else
15775         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15776 #endif
15777         break;
15778       default:
15779         break;
15780     }
15781     return node;
15782 }
15783 
15784 static NODE *
15785 arg_blk_pass(NODE *node1, NODE *node2)
15786 {
15787     if (node2) {
15788         node2->nd_head = node1;
15789         return node2;
15790     }
15791     return node1;
15792 }
15793 
15794 
15795 static NODE*
15796 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15797 {
15798     int saved_line = ruby_sourceline;
15799     struct rb_args_info *args = tail->nd_ainfo;
15800 
15801     args->pre_args_num   = m ? rb_long2int(m->nd_plen) : 0;
15802     args->pre_init       = m ? m->nd_next : 0;
15803 
15804     args->post_args_num  = p ? rb_long2int(p->nd_plen) : 0;
15805     args->post_init      = p ? p->nd_next : 0;
15806     args->first_post_arg = p ? p->nd_pid : 0;
15807 
15808     args->rest_arg       = r;
15809 
15810     args->opt_args       = o;
15811 
15812     ruby_sourceline = saved_line;
15813 
15814     return tail;
15815 }
15816 
15817 static NODE*
15818 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15819 {
15820     int saved_line = ruby_sourceline;
15821     struct rb_args_info *args;
15822     NODE *kw_rest_arg = 0;
15823     NODE *node;
15824 
15825     args = ALLOC(struct rb_args_info);
15826     MEMZERO(args, struct rb_args_info, 1);
15827     node = NEW_NODE(NODE_ARGS, 0, 0, args);
15828 
15829     args->block_arg      = b;
15830     args->kw_args        = k;
15831     if (k && !kr) kr = internal_id();
15832     if (kr) {
15833         arg_var(kr);
15834         kw_rest_arg  = NEW_DVAR(kr);
15835     }
15836     args->kw_rest_arg    = kw_rest_arg;
15837 
15838     ruby_sourceline = saved_line;
15839     return node;
15840 }
15841 
15842 static NODE*
15843 dsym_node_gen(struct parser_params *parser, NODE *node)
15844 {
15845     VALUE lit;
15846 
15847     if (!node) {
15848         return NEW_LIT(ID2SYM(idNULL));
15849     }
15850 
15851     switch (nd_type(node)) {
15852       case NODE_DSTR:
15853         nd_set_type(node, NODE_DSYM);
15854         break;
15855       case NODE_STR:
15856         lit = node->nd_lit;
15857         node->nd_lit = ID2SYM(rb_intern_str(lit));
15858         nd_set_type(node, NODE_LIT);
15859         break;
15860       default:
15861         node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15862         break;
15863     }
15864     return node;
15865 }
15866 #endif /* !RIPPER */
15867 
15868 #ifndef RIPPER
15869 static NODE *
15870 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15871 {
15872     NODE *asgn;
15873 
15874     if (lhs) {
15875         ID vid = lhs->nd_vid;
15876         if (op == tOROP) {
15877             lhs->nd_value = rhs;
15878             asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15879             if (is_asgn_or_id(vid)) {
15880                 asgn->nd_aid = vid;
15881             }
15882         }
15883         else if (op == tANDOP) {
15884             lhs->nd_value = rhs;
15885             asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15886         }
15887         else {
15888             asgn = lhs;
15889             asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15890         }
15891     }
15892     else {
15893         asgn = NEW_BEGIN(0);
15894     }
15895     return asgn;
15896 }
15897 
15898 static NODE *
15899 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15900 {
15901     NODE *asgn;
15902 
15903     if (op == tOROP) {
15904         op = 0;
15905     }
15906     else if (op == tANDOP) {
15907         op = 1;
15908     }
15909     asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
15910     fixpos(asgn, lhs);
15911     return asgn;
15912 }
15913 
15914 static NODE *
15915 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15916 {
15917     NODE *asgn;
15918 
15919     if (op == tOROP) {
15920         op = 0;
15921     }
15922     else if (op == tANDOP) {
15923         op = 1;
15924     }
15925     if (lhs) {
15926         asgn = NEW_OP_CDECL(lhs, op, rhs);
15927     }
15928     else {
15929         asgn = NEW_BEGIN(0);
15930     }
15931     fixpos(asgn, lhs);
15932     return asgn;
15933 }
15934 #else
15935 static VALUE
15936 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
15937 {
15938     return dispatch3(opassign, lhs, op, rhs);
15939 }
15940 
15941 static VALUE
15942 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
15943 {
15944     VALUE recv = dispatch3(field, lhs, type, attr);
15945     return dispatch3(opassign, recv, op, rhs);
15946 }
15947 #endif
15948 
15949 static void
15950 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15951 {
15952     int i, cnt;
15953     ID *v, *u;
15954 
15955     if (!local->used) return;
15956     v = local->vars->tbl;
15957     u = local->used->tbl;
15958     cnt = local->used->pos;
15959     if (cnt != local->vars->pos) {
15960         rb_bug("local->used->pos != local->vars->pos");
15961     }
15962     for (i = 0; i < cnt; ++i) {
15963         if (!v[i] || (u[i] & LVAR_USED)) continue;
15964         if (is_private_local_id(v[i])) continue;
15965         rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15966     }
15967 }
15968 
15969 static void
15970 local_push_gen(struct parser_params *parser, int inherit_dvars)
15971 {
15972     struct local_vars *local;
15973 
15974     local = ALLOC(struct local_vars);
15975     local->prev = lvtbl;
15976     local->args = vtable_alloc(0);
15977     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15978     local->used = !(inherit_dvars &&
15979                     (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
15980         RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15981     local->cmdargs = cmdarg_stack;
15982     cmdarg_stack = 0;
15983     lvtbl = local;
15984 }
15985 
15986 static void
15987 local_pop_gen(struct parser_params *parser)
15988 {
15989     struct local_vars *local = lvtbl->prev;
15990     if (lvtbl->used) {
15991         warn_unused_var(parser, lvtbl);
15992         vtable_free(lvtbl->used);
15993     }
15994     vtable_free(lvtbl->args);
15995     vtable_free(lvtbl->vars);
15996     cmdarg_stack = lvtbl->cmdargs;
15997     xfree(lvtbl);
15998     lvtbl = local;
15999 }
16000 
16001 #ifndef RIPPER
16002 static ID*
16003 local_tbl_gen(struct parser_params *parser)
16004 {
16005     int cnt_args = vtable_size(lvtbl->args);
16006     int cnt_vars = vtable_size(lvtbl->vars);
16007     int cnt = cnt_args + cnt_vars;
16008     int i, j;
16009     ID *buf;
16010 
16011     if (cnt <= 0) return 0;
16012     buf = ALLOC_N(ID, cnt + 1);
16013     MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16014     /* remove IDs duplicated to warn shadowing */
16015     for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16016         ID id = lvtbl->vars->tbl[i];
16017         if (!vtable_included(lvtbl->args, id)) {
16018             buf[j++] = id;
16019         }
16020     }
16021     if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16022     buf[0] = cnt;
16023     return buf;
16024 }
16025 #endif
16026 
16027 static int
16028 arg_var_gen(struct parser_params *parser, ID id)
16029 {
16030     vtable_add(lvtbl->args, id);
16031     return vtable_size(lvtbl->args) - 1;
16032 }
16033 
16034 static int
16035 local_var_gen(struct parser_params *parser, ID id)
16036 {
16037     vtable_add(lvtbl->vars, id);
16038     if (lvtbl->used) {
16039         vtable_add(lvtbl->used, (ID)ruby_sourceline);
16040     }
16041     return vtable_size(lvtbl->vars) - 1;
16042 }
16043 
16044 static int
16045 local_id_gen(struct parser_params *parser, ID id)
16046 {
16047     struct vtable *vars, *args, *used;
16048 
16049     vars = lvtbl->vars;
16050     args = lvtbl->args;
16051     used = lvtbl->used;
16052 
16053     while (vars && POINTER_P(vars->prev)) {
16054         vars = vars->prev;
16055         args = args->prev;
16056         if (used) used = used->prev;
16057     }
16058 
16059     if (vars && vars->prev == DVARS_INHERIT) {
16060         return rb_local_defined(id);
16061     }
16062     else if (vtable_included(args, id)) {
16063         return 1;
16064     }
16065     else {
16066         int i = vtable_included(vars, id);
16067         if (i && used) used->tbl[i-1] |= LVAR_USED;
16068         return i != 0;
16069     }
16070 }
16071 
16072 static const struct vtable *
16073 dyna_push_gen(struct parser_params *parser)
16074 {
16075     lvtbl->args = vtable_alloc(lvtbl->args);
16076     lvtbl->vars = vtable_alloc(lvtbl->vars);
16077     if (lvtbl->used) {
16078         lvtbl->used = vtable_alloc(lvtbl->used);
16079     }
16080     return lvtbl->args;
16081 }
16082 
16083 static void
16084 dyna_pop_1(struct parser_params *parser)
16085 {
16086     struct vtable *tmp;
16087 
16088     if ((tmp = lvtbl->used) != 0) {
16089         warn_unused_var(parser, lvtbl);
16090         lvtbl->used = lvtbl->used->prev;
16091         vtable_free(tmp);
16092     }
16093     tmp = lvtbl->args;
16094     lvtbl->args = lvtbl->args->prev;
16095     vtable_free(tmp);
16096     tmp = lvtbl->vars;
16097     lvtbl->vars = lvtbl->vars->prev;
16098     vtable_free(tmp);
16099 }
16100 
16101 static void
16102 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16103 {
16104     while (lvtbl->args != lvargs) {
16105         dyna_pop_1(parser);
16106         if (!lvtbl->args) {
16107             struct local_vars *local = lvtbl->prev;
16108             xfree(lvtbl);
16109             lvtbl = local;
16110         }
16111     }
16112     dyna_pop_1(parser);
16113 }
16114 
16115 static int
16116 dyna_in_block_gen(struct parser_params *parser)
16117 {
16118     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16119 }
16120 
16121 static int
16122 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16123 {
16124     struct vtable *vars, *args, *used;
16125     int i;
16126 
16127     args = lvtbl->args;
16128     vars = lvtbl->vars;
16129     used = lvtbl->used;
16130 
16131     while (POINTER_P(vars)) {
16132         if (vtable_included(args, id)) {
16133             return 1;
16134         }
16135         if ((i = vtable_included(vars, id)) != 0) {
16136             if (used) used->tbl[i-1] |= LVAR_USED;
16137             return 1;
16138         }
16139         args = args->prev;
16140         vars = vars->prev;
16141         if (get) used = 0;
16142         if (used) used = used->prev;
16143     }
16144 
16145     if (vars == DVARS_INHERIT) {
16146         return rb_dvar_defined(id);
16147     }
16148 
16149     return 0;
16150 }
16151 
16152 static int
16153 dvar_curr_gen(struct parser_params *parser, ID id)
16154 {
16155     return (vtable_included(lvtbl->args, id) ||
16156             vtable_included(lvtbl->vars, id));
16157 }
16158 
16159 #ifndef RIPPER
16160 static void
16161 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
16162 {
16163     int c = RE_OPTION_ENCODING_IDX(options);
16164 
16165     if (c) {
16166         int opt, idx;
16167         rb_char_to_option_kcode(c, &opt, &idx);
16168         if (idx != ENCODING_GET(str) &&
16169             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16170             goto error;
16171         }
16172         ENCODING_SET(str, idx);
16173     }
16174     else if (RE_OPTION_ENCODING_NONE(options)) {
16175         if (!ENCODING_IS_ASCII8BIT(str) &&
16176             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16177             c = 'n';
16178             goto error;
16179         }
16180         rb_enc_associate(str, rb_ascii8bit_encoding());
16181     }
16182     else if (current_enc == rb_usascii_encoding()) {
16183         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16184             /* raise in re.c */
16185             rb_enc_associate(str, rb_usascii_encoding());
16186         }
16187         else {
16188             rb_enc_associate(str, rb_ascii8bit_encoding());
16189         }
16190     }
16191     return;
16192 
16193   error:
16194     compile_error(PARSER_ARG
16195         "regexp encoding option '%c' differs from source encoding '%s'",
16196         c, rb_enc_name(rb_enc_get(str)));
16197 }
16198 
16199 static int
16200 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
16201 {
16202     VALUE err;
16203     reg_fragment_setenc(str, options);
16204     err = rb_reg_check_preprocess(str);
16205     if (err != Qnil) {
16206         err = rb_obj_as_string(err);
16207         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16208         RB_GC_GUARD(err);
16209         return 0;
16210     }
16211     return 1;
16212 }
16213 
16214 typedef struct {
16215     struct parser_params* parser;
16216     rb_encoding *enc;
16217     NODE *succ_block;
16218     NODE *fail_block;
16219     int num;
16220 } reg_named_capture_assign_t;
16221 
16222 static int
16223 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
16224           int back_num, int *back_refs, OnigRegex regex, void *arg0)
16225 {
16226     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
16227     struct parser_params* parser = arg->parser;
16228     rb_encoding *enc = arg->enc;
16229     long len = name_end - name;
16230     const char *s = (const char *)name;
16231     ID var;
16232 
16233     arg->num++;
16234 
16235     if (arg->succ_block == 0) {
16236         arg->succ_block = NEW_BEGIN(0);
16237         arg->fail_block = NEW_BEGIN(0);
16238     }
16239 
16240     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16241         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16242         !rb_enc_symname2_p(s, len, enc)) {
16243         return ST_CONTINUE;
16244     }
16245     var = rb_intern3(s, len, enc);
16246     if (dvar_defined(var) || local_id(var)) {
16247         rb_warningS("named capture conflicts a local variable - %s",
16248                     rb_id2name(var));
16249     }
16250     arg->succ_block = block_append(arg->succ_block,
16251         newline_node(node_assign(assignable(var,0),
16252             NEW_CALL(
16253               gettable(rb_intern("$~")),
16254               idAREF,
16255               NEW_LIST(NEW_LIT(ID2SYM(var))))
16256             )));
16257     arg->fail_block = block_append(arg->fail_block,
16258         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
16259     return ST_CONTINUE;
16260 }
16261 
16262 static NODE *
16263 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
16264 {
16265     reg_named_capture_assign_t arg;
16266 
16267     arg.parser = parser;
16268     arg.enc = rb_enc_get(regexp);
16269     arg.succ_block = 0;
16270     arg.fail_block = 0;
16271     arg.num = 0;
16272     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16273 
16274     if (arg.num == 0)
16275         return match;
16276 
16277     return
16278         block_append(
16279             newline_node(match),
16280             NEW_IF(gettable(rb_intern("$~")),
16281                 block_append(
16282                     newline_node(arg.succ_block),
16283                     newline_node(
16284                         NEW_CALL(
16285                           gettable(rb_intern("$~")),
16286                           rb_intern("begin"),
16287                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16288                 block_append(
16289                     newline_node(arg.fail_block),
16290                     newline_node(
16291                         NEW_LIT(Qnil)))));
16292 }
16293 
16294 static VALUE
16295 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16296 {
16297     VALUE re;
16298     VALUE err;
16299 
16300     reg_fragment_setenc(str, options);
16301     err = rb_errinfo();
16302     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
16303     if (NIL_P(re)) {
16304         ID mesg = rb_intern("mesg");
16305         VALUE m = rb_attr_get(rb_errinfo(), mesg);
16306         rb_set_errinfo(err);
16307         if (!NIL_P(err)) {
16308             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16309         }
16310         else {
16311             compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
16312         }
16313         return Qnil;
16314     }
16315     return re;
16316 }
16317 
16318 void
16319 rb_gc_mark_parser(void)
16320 {
16321 }
16322 
16323 NODE*
16324 rb_parser_append_print(VALUE vparser, NODE *node)
16325 {
16326     NODE *prelude = 0;
16327     NODE *scope = node;
16328     struct parser_params *parser;
16329 
16330     if (!node) return node;
16331 
16332     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16333 
16334     node = node->nd_body;
16335 
16336     if (nd_type(node) == NODE_PRELUDE) {
16337         prelude = node;
16338         node = node->nd_body;
16339     }
16340 
16341     node = block_append(node,
16342                         NEW_FCALL(rb_intern("print"),
16343                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16344     if (prelude) {
16345         prelude->nd_body = node;
16346         scope->nd_body = prelude;
16347     }
16348     else {
16349         scope->nd_body = node;
16350     }
16351 
16352     return scope;
16353 }
16354 
16355 NODE *
16356 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16357 {
16358     NODE *prelude = 0;
16359     NODE *scope = node;
16360     struct parser_params *parser;
16361 
16362     if (!node) return node;
16363 
16364     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16365 
16366     node = node->nd_body;
16367 
16368     if (nd_type(node) == NODE_PRELUDE) {
16369         prelude = node;
16370         node = node->nd_body;
16371     }
16372     if (split) {
16373         node = block_append(NEW_GASGN(rb_intern("$F"),
16374                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
16375                                                rb_intern("split"), 0)),
16376                             node);
16377     }
16378     if (chop) {
16379         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16380                                      rb_intern("chop!"), 0), node);
16381     }
16382 
16383     node = NEW_OPT_N(node);
16384 
16385     if (prelude) {
16386         prelude->nd_body = node;
16387         scope->nd_body = prelude;
16388     }
16389     else {
16390         scope->nd_body = node;
16391     }
16392 
16393     return scope;
16394 }
16395 
16396 static const struct {
16397     ID token;
16398     const char *name;
16399 } op_tbl[] = {
16400     {tDOT2,     ".."},
16401     {tDOT3,     "..."},
16402     {tPOW,      "**"},
16403     {tDSTAR,    "**"},
16404     {tUPLUS,    "+@"},
16405     {tUMINUS,   "-@"},
16406     {tCMP,      "<=>"},
16407     {tGEQ,      ">="},
16408     {tLEQ,      "<="},
16409     {tEQ,       "=="},
16410     {tEQQ,      "==="},
16411     {tNEQ,      "!="},
16412     {tMATCH,    "=~"},
16413     {tNMATCH,   "!~"},
16414     {tAREF,     "[]"},
16415     {tASET,     "[]="},
16416     {tLSHFT,    "<<"},
16417     {tRSHFT,    ">>"},
16418     {tCOLON2,   "::"},
16419 };
16420 
16421 #define op_tbl_count numberof(op_tbl)
16422 
16423 #ifndef ENABLE_SELECTOR_NAMESPACE
16424 #define ENABLE_SELECTOR_NAMESPACE 0
16425 #endif
16426 
16427 static struct symbols {
16428     ID last_id;
16429     st_table *sym_id;
16430     st_table *id_str;
16431 #if ENABLE_SELECTOR_NAMESPACE
16432     st_table *ivar2_id;
16433     st_table *id_ivar2;
16434 #endif
16435     VALUE op_sym[tLAST_OP_ID];
16436 } global_symbols = {tLAST_TOKEN};
16437 
16438 static const struct st_hash_type symhash = {
16439     rb_str_hash_cmp,
16440     rb_str_hash,
16441 };
16442 
16443 #if ENABLE_SELECTOR_NAMESPACE
16444 struct ivar2_key {
16445     ID id;
16446     VALUE klass;
16447 };
16448 
16449 static int
16450 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16451 {
16452     if (key1->id == key2->id && key1->klass == key2->klass) {
16453         return 0;
16454     }
16455     return 1;
16456 }
16457 
16458 static int
16459 ivar2_hash(struct ivar2_key *key)
16460 {
16461     return (key->id << 8) ^ (key->klass >> 2);
16462 }
16463 
16464 static const struct st_hash_type ivar2_hash_type = {
16465     ivar2_cmp,
16466     ivar2_hash,
16467 };
16468 #endif
16469 
16470 void
16471 Init_sym(void)
16472 {
16473     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16474     global_symbols.id_str = st_init_numtable_with_size(1000);
16475 #if ENABLE_SELECTOR_NAMESPACE
16476     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16477     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16478 #endif
16479 
16480     (void)nodetype;
16481     (void)nodeline;
16482 #if PARSER_DEBUG
16483     (void)lex_state_name(-1);
16484 #endif
16485 
16486     Init_id();
16487 }
16488 
16489 void
16490 rb_gc_mark_symbols(void)
16491 {
16492     rb_mark_tbl(global_symbols.id_str);
16493     rb_gc_mark_locations(global_symbols.op_sym,
16494                          global_symbols.op_sym + numberof(global_symbols.op_sym));
16495 }
16496 #endif /* !RIPPER */
16497 
16498 static ID
16499 internal_id_gen(struct parser_params *parser)
16500 {
16501     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16502     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16503     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16504 }
16505 
16506 #ifndef RIPPER
16507 static int
16508 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16509 {
16510     int mb = 0;
16511 
16512     if (m >= e) return 0;
16513     if (is_global_name_punct(*m)) {
16514         ++m;
16515     }
16516     else if (*m == '-') {
16517         ++m;
16518         if (m < e && is_identchar(m, e, enc)) {
16519             if (!ISASCII(*m)) mb = 1;
16520             m += rb_enc_mbclen(m, e, enc);
16521         }
16522     }
16523     else {
16524         if (!rb_enc_isdigit(*m, enc)) return 0;
16525         do {
16526             if (!ISASCII(*m)) mb = 1;
16527             ++m;
16528         } while (m < e && rb_enc_isdigit(*m, enc));
16529     }
16530     return m == e ? mb + 1 : 0;
16531 }
16532 
16533 int
16534 rb_symname_p(const char *name)
16535 {
16536     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16537 }
16538 
16539 int
16540 rb_enc_symname_p(const char *name, rb_encoding *enc)
16541 {
16542     return rb_enc_symname2_p(name, strlen(name), enc);
16543 }
16544 
16545 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16546 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
16547 
16548 static int
16549 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
16550 {
16551     const char *m = name;
16552     const char *e = m + len;
16553     int type = ID_JUNK;
16554 
16555     if (!m || len <= 0) return -1;
16556     switch (*m) {
16557       case '\0':
16558         return -1;
16559 
16560       case '$':
16561         type = ID_GLOBAL;
16562         if (is_special_global_name(++m, e, enc)) return type;
16563         goto id;
16564 
16565       case '@':
16566         type = ID_INSTANCE;
16567         if (*++m == '@') {
16568             ++m;
16569             type = ID_CLASS;
16570         }
16571         goto id;
16572 
16573       case '<':
16574         switch (*++m) {
16575           case '<': ++m; break;
16576           case '=': if (*++m == '>') ++m; break;
16577           default: break;
16578         }
16579         break;
16580 
16581       case '>':
16582         switch (*++m) {
16583           case '>': case '=': ++m; break;
16584         }
16585         break;
16586 
16587       case '=':
16588         switch (*++m) {
16589           case '~': ++m; break;
16590           case '=': if (*++m == '=') ++m; break;
16591           default: return -1;
16592         }
16593         break;
16594 
16595       case '*':
16596         if (*++m == '*') ++m;
16597         break;
16598 
16599       case '+': case '-':
16600         if (*++m == '@') ++m;
16601         break;
16602 
16603       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16604         ++m;
16605         break;
16606 
16607       case '[':
16608         if (*++m != ']') return -1;
16609         if (*++m == '=') ++m;
16610         break;
16611 
16612       case '!':
16613         if (len == 1) return ID_JUNK;
16614         switch (*++m) {
16615           case '=': case '~': ++m; break;
16616           default: return -1;
16617         }
16618         break;
16619 
16620       default:
16621         type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16622       id:
16623         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16624             return -1;
16625         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16626         if (m >= e) break;
16627         switch (*m) {
16628           case '!': case '?':
16629             if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16630             type = ID_JUNK;
16631             ++m;
16632             if (m + 1 < e || *m != '=') break;
16633             /* fall through */
16634           case '=':
16635             if (!(allowed_atttset & (1U << type))) return -1;
16636             type = ID_ATTRSET;
16637             ++m;
16638             break;
16639         }
16640         break;
16641     }
16642     return m == e ? type : -1;
16643 }
16644 
16645 int
16646 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16647 {
16648     return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16649 }
16650 
16651 static int
16652 rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
16653 {
16654     const char *ptr = StringValuePtr(name);
16655     long len = RSTRING_LEN(name);
16656     int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset);
16657     RB_GC_GUARD(name);
16658     return type;
16659 }
16660 
16661 static ID
16662 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16663 {
16664     VALUE str = rb_enc_str_new(name, len, enc);
16665     return register_symid_str(id, str);
16666 }
16667 
16668 static ID
16669 register_symid_str(ID id, VALUE str)
16670 {
16671     OBJ_FREEZE(str);
16672     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
16673     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
16674     return id;
16675 }
16676 
16677 static int
16678 sym_check_asciionly(VALUE str)
16679 {
16680     if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16681     switch (rb_enc_str_coderange(str)) {
16682       case ENC_CODERANGE_BROKEN:
16683         rb_raise(rb_eEncodingError, "invalid encoding symbol");
16684       case ENC_CODERANGE_7BIT:
16685         return TRUE;
16686     }
16687     return FALSE;
16688 }
16689 
16690 /*
16691  * _str_ itself will be registered at the global symbol table.  _str_
16692  * can be modified before the registration, since the encoding will be
16693  * set to ASCII-8BIT if it is a special global name.
16694  */
16695 static ID intern_str(VALUE str);
16696 
16697 ID
16698 rb_intern3(const char *name, long len, rb_encoding *enc)
16699 {
16700     VALUE str;
16701     st_data_t data;
16702     struct RString fake_str;
16703     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16704     fake_str.basic.klass = rb_cString;
16705     fake_str.as.heap.len = len;
16706     fake_str.as.heap.ptr = (char *)name;
16707     fake_str.as.heap.aux.capa = len;
16708     str = (VALUE)&fake_str;
16709     rb_enc_associate(str, enc);
16710     OBJ_FREEZE(str);
16711 
16712     if (st_lookup(global_symbols.sym_id, str, &data))
16713         return (ID)data;
16714 
16715     str = rb_enc_str_new(name, len, enc); /* make true string */
16716     return intern_str(str);
16717 }
16718 
16719 static ID
16720 intern_str(VALUE str)
16721 {
16722     const char *name, *m, *e;
16723     long len, last;
16724     rb_encoding *enc, *symenc;
16725     unsigned char c;
16726     ID id;
16727     int mb;
16728 
16729     RSTRING_GETMEM(str, name, len);
16730     m = name;
16731     e = m + len;
16732     enc = rb_enc_get(str);
16733     symenc = enc;
16734 
16735     if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16736       junk:
16737         id = ID_JUNK;
16738         goto new_id;
16739     }
16740     last = len-1;
16741     id = 0;
16742     switch (*m) {
16743       case '$':
16744         if (len < 2) goto junk;
16745         id |= ID_GLOBAL;
16746         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16747             if (!--mb) symenc = rb_usascii_encoding();
16748             goto new_id;
16749         }
16750         break;
16751       case '@':
16752         if (m[1] == '@') {
16753             if (len < 3) goto junk;
16754             m++;
16755             id |= ID_CLASS;
16756         }
16757         else {
16758             if (len < 2) goto junk;
16759             id |= ID_INSTANCE;
16760         }
16761         m++;
16762         break;
16763       default:
16764         c = m[0];
16765         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16766             /* operators */
16767             int i;
16768 
16769             if (len == 1) {
16770                 id = c;
16771                 goto id_register;
16772             }
16773             for (i = 0; i < op_tbl_count; i++) {
16774                 if (*op_tbl[i].name == *m &&
16775                     strcmp(op_tbl[i].name, m) == 0) {
16776                     id = op_tbl[i].token;
16777                     goto id_register;
16778                 }
16779             }
16780         }
16781         break;
16782     }
16783     if (name[last] == '=') {
16784         /* attribute assignment */
16785         if (last > 1 && name[last-1] == '=')
16786             goto junk;
16787         id = rb_intern3(name, last, enc);
16788         if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16789             enc = rb_enc_get(rb_id2str(id));
16790             id = rb_id_attrset(id);
16791             goto id_register;
16792         }
16793         id = ID_ATTRSET;
16794     }
16795     else if (id == 0) {
16796         if (rb_enc_isupper(m[0], enc)) {
16797             id = ID_CONST;
16798         }
16799         else {
16800             id = ID_LOCAL;
16801         }
16802     }
16803     if (!rb_enc_isdigit(*m, enc)) {
16804         while (m <= name + last && is_identchar(m, e, enc)) {
16805             if (ISASCII(*m)) {
16806                 m++;
16807             }
16808             else {
16809                 m += rb_enc_mbclen(m, e, enc);
16810             }
16811         }
16812     }
16813     if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
16814     if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16815   new_id:
16816     if (symenc != enc) rb_enc_associate(str, symenc);
16817     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
16818         if (len > 20) {
16819             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16820                      name);
16821         }
16822         else {
16823             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16824                      (int)len, name);
16825         }
16826     }
16827     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
16828   id_register:
16829     return register_symid_str(id, str);
16830 }
16831 
16832 ID
16833 rb_intern2(const char *name, long len)
16834 {
16835     return rb_intern3(name, len, rb_usascii_encoding());
16836 }
16837 
16838 #undef rb_intern
16839 ID
16840 rb_intern(const char *name)
16841 {
16842     return rb_intern2(name, strlen(name));
16843 }
16844 
16845 ID
16846 rb_intern_str(VALUE str)
16847 {
16848     st_data_t id;
16849 
16850     if (st_lookup(global_symbols.sym_id, str, &id))
16851         return (ID)id;
16852     return intern_str(rb_str_dup(str));
16853 }
16854 
16855 VALUE
16856 rb_id2str(ID id)
16857 {
16858     st_data_t data;
16859 
16860     if (id < tLAST_TOKEN) {
16861         int i = 0;
16862 
16863         if (id < INT_MAX && rb_ispunct((int)id)) {
16864             VALUE str = global_symbols.op_sym[i = (int)id];
16865             if (!str) {
16866                 char name[2];
16867                 name[0] = (char)id;
16868                 name[1] = 0;
16869                 str = rb_usascii_str_new(name, 1);
16870                 OBJ_FREEZE(str);
16871                 global_symbols.op_sym[i] = str;
16872             }
16873             return str;
16874         }
16875         for (i = 0; i < op_tbl_count; i++) {
16876             if (op_tbl[i].token == id) {
16877                 VALUE str = global_symbols.op_sym[i];
16878                 if (!str) {
16879                     str = rb_usascii_str_new2(op_tbl[i].name);
16880                     OBJ_FREEZE(str);
16881                     global_symbols.op_sym[i] = str;
16882                 }
16883                 return str;
16884             }
16885         }
16886     }
16887 
16888     if (st_lookup(global_symbols.id_str, id, &data)) {
16889         VALUE str = (VALUE)data;
16890         if (RBASIC(str)->klass == 0)
16891             RBASIC(str)->klass = rb_cString;
16892         return str;
16893     }
16894 
16895     if (is_attrset_id(id)) {
16896         ID id_stem = (id & ~ID_SCOPE_MASK);
16897         VALUE str;
16898 
16899         do {
16900             if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
16901             if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
16902             if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
16903             if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
16904             if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
16905             if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
16906             return 0;
16907         } while (0);
16908         str = rb_str_dup(str);
16909         rb_str_cat(str, "=", 1);
16910         register_symid_str(id, str);
16911         if (st_lookup(global_symbols.id_str, id, &data)) {
16912             VALUE str = (VALUE)data;
16913             if (RBASIC(str)->klass == 0)
16914                 RBASIC(str)->klass = rb_cString;
16915             return str;
16916         }
16917     }
16918     return 0;
16919 }
16920 
16921 const char *
16922 rb_id2name(ID id)
16923 {
16924     VALUE str = rb_id2str(id);
16925 
16926     if (!str) return 0;
16927     return RSTRING_PTR(str);
16928 }
16929 
16930 static int
16931 symbols_i(VALUE sym, ID value, VALUE ary)
16932 {
16933     rb_ary_push(ary, ID2SYM(value));
16934     return ST_CONTINUE;
16935 }
16936 
16937 /*
16938  *  call-seq:
16939  *     Symbol.all_symbols    => array
16940  *
16941  *  Returns an array of all the symbols currently in Ruby's symbol
16942  *  table.
16943  *
16944  *     Symbol.all_symbols.size    #=> 903
16945  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
16946  *                                     :chown, :EOFError, :$;, :String,
16947  *                                     :LOCK_SH, :"setuid?", :$<,
16948  *                                     :default_proc, :compact, :extend,
16949  *                                     :Tms, :getwd, :$=, :ThreadGroup,
16950  *                                     :wait2, :$>]
16951  */
16952 
16953 VALUE
16954 rb_sym_all_symbols(void)
16955 {
16956     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
16957 
16958     st_foreach(global_symbols.sym_id, symbols_i, ary);
16959     return ary;
16960 }
16961 
16962 int
16963 rb_is_const_id(ID id)
16964 {
16965     return is_const_id(id);
16966 }
16967 
16968 int
16969 rb_is_class_id(ID id)
16970 {
16971     return is_class_id(id);
16972 }
16973 
16974 int
16975 rb_is_global_id(ID id)
16976 {
16977     return is_global_id(id);
16978 }
16979 
16980 int
16981 rb_is_instance_id(ID id)
16982 {
16983     return is_instance_id(id);
16984 }
16985 
16986 int
16987 rb_is_attrset_id(ID id)
16988 {
16989     return is_attrset_id(id);
16990 }
16991 
16992 int
16993 rb_is_local_id(ID id)
16994 {
16995     return is_local_id(id);
16996 }
16997 
16998 int
16999 rb_is_junk_id(ID id)
17000 {
17001     return is_junk_id(id);
17002 }
17003 
17015 ID
17016 rb_check_id(volatile VALUE *namep)
17017 {
17018     st_data_t id;
17019     VALUE tmp;
17020     VALUE name = *namep;
17021 
17022     if (SYMBOL_P(name)) {
17023         return SYM2ID(name);
17024     }
17025     else if (!RB_TYPE_P(name, T_STRING)) {
17026         tmp = rb_check_string_type(name);
17027         if (NIL_P(tmp)) {
17028             tmp = rb_inspect(name);
17029             rb_raise(rb_eTypeError, "%s is not a symbol",
17030                      RSTRING_PTR(tmp));
17031         }
17032         name = tmp;
17033         *namep = name;
17034     }
17035 
17036     sym_check_asciionly(name);
17037 
17038     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17039         return (ID)id;
17040 
17041     if (rb_is_attrset_name(name)) {
17042         struct RString fake_str;
17043         const VALUE localname = (VALUE)&fake_str;
17044         /* make local name by chopping '=' */
17045         fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17046         fake_str.basic.klass = rb_cString;
17047         fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17048         fake_str.as.heap.ptr = RSTRING_PTR(name);
17049         fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17050         rb_enc_copy(localname, name);
17051         OBJ_FREEZE(localname);
17052 
17053         if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17054             return rb_id_attrset((ID)id);
17055         }
17056         RB_GC_GUARD(name);
17057     }
17058 
17059     return (ID)0;
17060 }
17061 
17062 ID
17063 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17064 {
17065     st_data_t id;
17066     struct RString fake_str;
17067     const VALUE name = (VALUE)&fake_str;
17068     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17069     fake_str.basic.klass = rb_cString;
17070     fake_str.as.heap.len = len;
17071     fake_str.as.heap.ptr = (char *)ptr;
17072     fake_str.as.heap.aux.capa = len;
17073     rb_enc_associate(name, enc);
17074 
17075     sym_check_asciionly(name);
17076 
17077     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17078         return (ID)id;
17079 
17080     if (rb_is_attrset_name(name)) {
17081         fake_str.as.heap.len = len - 1;
17082         if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17083             return rb_id_attrset((ID)id);
17084         }
17085     }
17086 
17087     return (ID)0;
17088 }
17089 
17090 int
17091 rb_is_const_name(VALUE name)
17092 {
17093     return rb_str_symname_type(name, 0) == ID_CONST;
17094 }
17095 
17096 int
17097 rb_is_class_name(VALUE name)
17098 {
17099     return rb_str_symname_type(name, 0) == ID_CLASS;
17100 }
17101 
17102 int
17103 rb_is_global_name(VALUE name)
17104 {
17105     return rb_str_symname_type(name, 0) == ID_GLOBAL;
17106 }
17107 
17108 int
17109 rb_is_instance_name(VALUE name)
17110 {
17111     return rb_str_symname_type(name, 0) == ID_INSTANCE;
17112 }
17113 
17114 int
17115 rb_is_attrset_name(VALUE name)
17116 {
17117     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
17118 }
17119 
17120 int
17121 rb_is_local_name(VALUE name)
17122 {
17123     return rb_str_symname_type(name, 0) == ID_LOCAL;
17124 }
17125 
17126 int
17127 rb_is_method_name(VALUE name)
17128 {
17129     switch (rb_str_symname_type(name, 0)) {
17130       case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17131         return TRUE;
17132     }
17133     return FALSE;
17134 }
17135 
17136 int
17137 rb_is_junk_name(VALUE name)
17138 {
17139     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17140 }
17141 
17142 #endif /* !RIPPER */
17143 
17144 static void
17145 parser_initialize(struct parser_params *parser)
17146 {
17147     parser->eofp = Qfalse;
17148 
17149     parser->parser_lex_strterm = 0;
17150     parser->parser_cond_stack = 0;
17151     parser->parser_cmdarg_stack = 0;
17152     parser->parser_class_nest = 0;
17153     parser->parser_paren_nest = 0;
17154     parser->parser_lpar_beg = 0;
17155     parser->parser_brace_nest = 0;
17156     parser->parser_in_single = 0;
17157     parser->parser_in_def = 0;
17158     parser->parser_in_defined = 0;
17159     parser->parser_compile_for_eval = 0;
17160     parser->parser_cur_mid = 0;
17161     parser->parser_tokenbuf = NULL;
17162     parser->parser_tokidx = 0;
17163     parser->parser_toksiz = 0;
17164     parser->parser_heredoc_end = 0;
17165     parser->parser_command_start = TRUE;
17166     parser->parser_deferred_nodes = 0;
17167     parser->parser_lex_pbeg = 0;
17168     parser->parser_lex_p = 0;
17169     parser->parser_lex_pend = 0;
17170     parser->parser_lvtbl = 0;
17171     parser->parser_ruby__end__seen = 0;
17172     parser->parser_ruby_sourcefile = 0;
17173     parser->parser_ruby_sourcefile_string = Qnil;
17174 #ifndef RIPPER
17175     parser->is_ripper = 0;
17176     parser->parser_eval_tree_begin = 0;
17177     parser->parser_eval_tree = 0;
17178 #else
17179     parser->is_ripper = 1;
17180     parser->delayed = Qnil;
17181 
17182     parser->result = Qnil;
17183     parser->parsing_thread = Qnil;
17184     parser->toplevel_p = TRUE;
17185 #endif
17186 #ifdef YYMALLOC
17187     parser->heap = NULL;
17188 #endif
17189     parser->enc = rb_utf8_encoding();
17190 }
17191 
17192 #ifdef RIPPER
17193 #define parser_mark ripper_parser_mark
17194 #define parser_free ripper_parser_free
17195 #endif
17196 
17197 static void
17198 parser_mark(void *ptr)
17199 {
17200     struct parser_params *p = (struct parser_params*)ptr;
17201 
17202     rb_gc_mark((VALUE)p->parser_lex_strterm);
17203     rb_gc_mark((VALUE)p->parser_deferred_nodes);
17204     rb_gc_mark(p->parser_lex_input);
17205     rb_gc_mark(p->parser_lex_lastline);
17206     rb_gc_mark(p->parser_lex_nextline);
17207     rb_gc_mark(p->parser_ruby_sourcefile_string);
17208 #ifndef RIPPER
17209     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
17210     rb_gc_mark((VALUE)p->parser_eval_tree) ;
17211     rb_gc_mark(p->debug_lines);
17212 #else
17213     rb_gc_mark(p->delayed);
17214     rb_gc_mark(p->value);
17215     rb_gc_mark(p->result);
17216     rb_gc_mark(p->parsing_thread);
17217 #endif
17218 #ifdef YYMALLOC
17219     rb_gc_mark((VALUE)p->heap);
17220 #endif
17221 }
17222 
17223 static void
17224 parser_free(void *ptr)
17225 {
17226     struct parser_params *p = (struct parser_params*)ptr;
17227     struct local_vars *local, *prev;
17228 
17229     if (p->parser_tokenbuf) {
17230         xfree(p->parser_tokenbuf);
17231     }
17232     for (local = p->parser_lvtbl; local; local = prev) {
17233         if (local->vars) xfree(local->vars);
17234         prev = local->prev;
17235         xfree(local);
17236     }
17237     xfree(p);
17238 }
17239 
17240 static size_t
17241 parser_memsize(const void *ptr)
17242 {
17243     struct parser_params *p = (struct parser_params*)ptr;
17244     struct local_vars *local;
17245     size_t size = sizeof(*p);
17246 
17247     if (!ptr) return 0;
17248     size += p->parser_toksiz;
17249     for (local = p->parser_lvtbl; local; local = local->prev) {
17250         size += sizeof(*local);
17251         if (local->vars) size += local->vars->capa * sizeof(ID);
17252     }
17253     return size;
17254 }
17255 
17256 static
17257 #ifndef RIPPER
17258 const
17259 #endif
17260 rb_data_type_t parser_data_type = {
17261     "parser",
17262     {
17263         parser_mark,
17264         parser_free,
17265         parser_memsize,
17266     },
17267 };
17268 
17269 #ifndef RIPPER
17270 #undef rb_reserved_word
17271 
17272 const struct kwtable *
17273 rb_reserved_word(const char *str, unsigned int len)
17274 {
17275     return reserved_word(str, len);
17276 }
17277 
17278 static struct parser_params *
17279 parser_new(void)
17280 {
17281     struct parser_params *p;
17282 
17283     p = ALLOC_N(struct parser_params, 1);
17284     MEMZERO(p, struct parser_params, 1);
17285     parser_initialize(p);
17286     return p;
17287 }
17288 
17289 VALUE
17290 rb_parser_new(void)
17291 {
17292     struct parser_params *p = parser_new();
17293 
17294     return TypedData_Wrap_Struct(0, &parser_data_type, p);
17295 }
17296 
17297 /*
17298  *  call-seq:
17299  *    ripper#end_seen?   -> Boolean
17300  *
17301  *  Return true if parsed source ended by +\_\_END\_\_+.
17302  */
17303 VALUE
17304 rb_parser_end_seen_p(VALUE vparser)
17305 {
17306     struct parser_params *parser;
17307 
17308     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17309     return ruby__end__seen ? Qtrue : Qfalse;
17310 }
17311 
17312 /*
17313  *  call-seq:
17314  *    ripper#encoding   -> encoding
17315  *
17316  *  Return encoding of the source.
17317  */
17318 VALUE
17319 rb_parser_encoding(VALUE vparser)
17320 {
17321     struct parser_params *parser;
17322 
17323     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17324     return rb_enc_from_encoding(current_enc);
17325 }
17326 
17327 /*
17328  *  call-seq:
17329  *    ripper.yydebug   -> true or false
17330  *
17331  *  Get yydebug.
17332  */
17333 VALUE
17334 rb_parser_get_yydebug(VALUE self)
17335 {
17336     struct parser_params *parser;
17337 
17338     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17339     return yydebug ? Qtrue : Qfalse;
17340 }
17341 
17342 /*
17343  *  call-seq:
17344  *    ripper.yydebug = flag
17345  *
17346  *  Set yydebug.
17347  */
17348 VALUE
17349 rb_parser_set_yydebug(VALUE self, VALUE flag)
17350 {
17351     struct parser_params *parser;
17352 
17353     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17354     yydebug = RTEST(flag);
17355     return flag;
17356 }
17357 
17358 #ifdef YYMALLOC
17359 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17360 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17361 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17362                            (n)->u3.cnt = (c), (p))
17363 
17364 void *
17365 rb_parser_malloc(struct parser_params *parser, size_t size)
17366 {
17367     size_t cnt = HEAPCNT(1, size);
17368     NODE *n = NEWHEAP();
17369     void *ptr = xmalloc(size);
17370 
17371     return ADD2HEAP(n, cnt, ptr);
17372 }
17373 
17374 void *
17375 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17376 {
17377     size_t cnt = HEAPCNT(nelem, size);
17378     NODE *n = NEWHEAP();
17379     void *ptr = xcalloc(nelem, size);
17380 
17381     return ADD2HEAP(n, cnt, ptr);
17382 }
17383 
17384 void *
17385 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17386 {
17387     NODE *n;
17388     size_t cnt = HEAPCNT(1, size);
17389 
17390     if (ptr && (n = parser->heap) != NULL) {
17391         do {
17392             if (n->u1.node == ptr) {
17393                 n->u1.node = ptr = xrealloc(ptr, size);
17394                 if (n->u3.cnt) n->u3.cnt = cnt;
17395                 return ptr;
17396             }
17397         } while ((n = n->u2.node) != NULL);
17398     }
17399     n = NEWHEAP();
17400     ptr = xrealloc(ptr, size);
17401     return ADD2HEAP(n, cnt, ptr);
17402 }
17403 
17404 void
17405 rb_parser_free(struct parser_params *parser, void *ptr)
17406 {
17407     NODE **prev = &parser->heap, *n;
17408 
17409     while ((n = *prev) != NULL) {
17410         if (n->u1.node == ptr) {
17411             *prev = n->u2.node;
17412             rb_gc_force_recycle((VALUE)n);
17413             break;
17414         }
17415         prev = &n->u2.node;
17416     }
17417     xfree(ptr);
17418 }
17419 #endif
17420 #endif
17421 
17422 #ifdef RIPPER
17423 #ifdef RIPPER_DEBUG
17424 extern int rb_is_pointer_to_heap(VALUE);
17425 
17426 /* :nodoc: */
17427 static VALUE
17428 ripper_validate_object(VALUE self, VALUE x)
17429 {
17430     if (x == Qfalse) return x;
17431     if (x == Qtrue) return x;
17432     if (x == Qnil) return x;
17433     if (x == Qundef)
17434         rb_raise(rb_eArgError, "Qundef given");
17435     if (FIXNUM_P(x)) return x;
17436     if (SYMBOL_P(x)) return x;
17437     if (!rb_is_pointer_to_heap(x))
17438         rb_raise(rb_eArgError, "invalid pointer: %p", x);
17439     switch (TYPE(x)) {
17440       case T_STRING:
17441       case T_OBJECT:
17442       case T_ARRAY:
17443       case T_BIGNUM:
17444       case T_FLOAT:
17445         return x;
17446       case T_NODE:
17447         if (nd_type(x) != NODE_LASGN) {
17448             rb_raise(rb_eArgError, "NODE given: %p", x);
17449         }
17450         return ((NODE *)x)->nd_rval;
17451       default:
17452         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17453                  x, rb_obj_classname(x));
17454     }
17455     return x;
17456 }
17457 #endif
17458 
17459 #define validate(x) ((x) = get_value(x))
17460 
17461 static VALUE
17462 ripper_dispatch0(struct parser_params *parser, ID mid)
17463 {
17464     return rb_funcall(parser->value, mid, 0);
17465 }
17466 
17467 static VALUE
17468 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17469 {
17470     validate(a);
17471     return rb_funcall(parser->value, mid, 1, a);
17472 }
17473 
17474 static VALUE
17475 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17476 {
17477     validate(a);
17478     validate(b);
17479     return rb_funcall(parser->value, mid, 2, a, b);
17480 }
17481 
17482 static VALUE
17483 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17484 {
17485     validate(a);
17486     validate(b);
17487     validate(c);
17488     return rb_funcall(parser->value, mid, 3, a, b, c);
17489 }
17490 
17491 static VALUE
17492 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17493 {
17494     validate(a);
17495     validate(b);
17496     validate(c);
17497     validate(d);
17498     return rb_funcall(parser->value, mid, 4, a, b, c, d);
17499 }
17500 
17501 static VALUE
17502 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17503 {
17504     validate(a);
17505     validate(b);
17506     validate(c);
17507     validate(d);
17508     validate(e);
17509     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17510 }
17511 
17512 static VALUE
17513 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17514 {
17515     validate(a);
17516     validate(b);
17517     validate(c);
17518     validate(d);
17519     validate(e);
17520     validate(f);
17521     validate(g);
17522     return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17523 }
17524 
17525 static const struct kw_assoc {
17526     ID id;
17527     const char *name;
17528 } keyword_to_name[] = {
17529     {keyword_class,     "class"},
17530     {keyword_module,    "module"},
17531     {keyword_def,       "def"},
17532     {keyword_undef,     "undef"},
17533     {keyword_begin,     "begin"},
17534     {keyword_rescue,    "rescue"},
17535     {keyword_ensure,    "ensure"},
17536     {keyword_end,       "end"},
17537     {keyword_if,        "if"},
17538     {keyword_unless,    "unless"},
17539     {keyword_then,      "then"},
17540     {keyword_elsif,     "elsif"},
17541     {keyword_else,      "else"},
17542     {keyword_case,      "case"},
17543     {keyword_when,      "when"},
17544     {keyword_while,     "while"},
17545     {keyword_until,     "until"},
17546     {keyword_for,       "for"},
17547     {keyword_break,     "break"},
17548     {keyword_next,      "next"},
17549     {keyword_redo,      "redo"},
17550     {keyword_retry,     "retry"},
17551     {keyword_in,        "in"},
17552     {keyword_do,        "do"},
17553     {keyword_do_cond,   "do"},
17554     {keyword_do_block,  "do"},
17555     {keyword_return,    "return"},
17556     {keyword_yield,     "yield"},
17557     {keyword_super,     "super"},
17558     {keyword_self,      "self"},
17559     {keyword_nil,       "nil"},
17560     {keyword_true,      "true"},
17561     {keyword_false,     "false"},
17562     {keyword_and,       "and"},
17563     {keyword_or,        "or"},
17564     {keyword_not,       "not"},
17565     {modifier_if,       "if"},
17566     {modifier_unless,   "unless"},
17567     {modifier_while,    "while"},
17568     {modifier_until,    "until"},
17569     {modifier_rescue,   "rescue"},
17570     {keyword_alias,     "alias"},
17571     {keyword_defined,   "defined?"},
17572     {keyword_BEGIN,     "BEGIN"},
17573     {keyword_END,       "END"},
17574     {keyword__LINE__,   "__LINE__"},
17575     {keyword__FILE__,   "__FILE__"},
17576     {keyword__ENCODING__, "__ENCODING__"},
17577     {0, NULL}
17578 };
17579 
17580 static const char*
17581 keyword_id_to_str(ID id)
17582 {
17583     const struct kw_assoc *a;
17584 
17585     for (a = keyword_to_name; a->id; a++) {
17586         if (a->id == id)
17587             return a->name;
17588     }
17589     return NULL;
17590 }
17591 
17592 #undef ripper_id2sym
17593 static VALUE
17594 ripper_id2sym(ID id)
17595 {
17596     const char *name;
17597     char buf[8];
17598 
17599     if (id <= 256) {
17600         buf[0] = (char)id;
17601         buf[1] = '\0';
17602         return ID2SYM(rb_intern2(buf, 1));
17603     }
17604     if ((name = keyword_id_to_str(id))) {
17605         return ID2SYM(rb_intern(name));
17606     }
17607     switch (id) {
17608       case tOROP:
17609         name = "||";
17610         break;
17611       case tANDOP:
17612         name = "&&";
17613         break;
17614       default:
17615         name = rb_id2name(id);
17616         if (!name) {
17617             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17618         }
17619         return ID2SYM(id);
17620     }
17621     return ID2SYM(rb_intern(name));
17622 }
17623 
17624 static ID
17625 ripper_get_id(VALUE v)
17626 {
17627     NODE *nd;
17628     if (!RB_TYPE_P(v, T_NODE)) return 0;
17629     nd = (NODE *)v;
17630     if (nd_type(nd) != NODE_LASGN) return 0;
17631     return nd->nd_vid;
17632 }
17633 
17634 static VALUE
17635 ripper_get_value(VALUE v)
17636 {
17637     NODE *nd;
17638     if (v == Qundef) return Qnil;
17639     if (!RB_TYPE_P(v, T_NODE)) return v;
17640     nd = (NODE *)v;
17641     if (nd_type(nd) != NODE_LASGN) return Qnil;
17642     return nd->nd_rval;
17643 }
17644 
17645 static void
17646 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17647 {
17648     VALUE str;
17649     va_list args;
17650 
17651     va_start(args, fmt);
17652     str = rb_vsprintf(fmt, args);
17653     va_end(args);
17654     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17655 }
17656 
17657 static void
17658 ripper_warn0(struct parser_params *parser, const char *fmt)
17659 {
17660     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17661 }
17662 
17663 static void
17664 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17665 {
17666     rb_funcall(parser->value, rb_intern("warn"), 2,
17667                STR_NEW2(fmt), INT2NUM(a));
17668 }
17669 
17670 static void
17671 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17672 {
17673     rb_funcall(parser->value, rb_intern("warn"), 2,
17674                STR_NEW2(fmt), STR_NEW2(str));
17675 }
17676 
17677 static void
17678 ripper_warning0(struct parser_params *parser, const char *fmt)
17679 {
17680     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17681 }
17682 
17683 static void
17684 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17685 {
17686     rb_funcall(parser->value, rb_intern("warning"), 2,
17687                STR_NEW2(fmt), STR_NEW2(str));
17688 }
17689 
17690 static VALUE
17691 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17692 {
17693     return rb_io_gets(src);
17694 }
17695 
17696 static VALUE
17697 ripper_s_allocate(VALUE klass)
17698 {
17699     struct parser_params *p;
17700     VALUE self;
17701 
17702     p = ALLOC_N(struct parser_params, 1);
17703     MEMZERO(p, struct parser_params, 1);
17704     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17705     p->value = self;
17706     return self;
17707 }
17708 
17709 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17710 
17711 /*
17712  *  call-seq:
17713  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17714  *
17715  *  Create a new Ripper object.
17716  *  _src_ must be a String, an IO, or an Object which has #gets method.
17717  *
17718  *  This method does not starts parsing.
17719  *  See also Ripper#parse and Ripper.parse.
17720  */
17721 static VALUE
17722 ripper_initialize(int argc, VALUE *argv, VALUE self)
17723 {
17724     struct parser_params *parser;
17725     VALUE src, fname, lineno;
17726 
17727     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17728     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17729     if (RB_TYPE_P(src, T_FILE)) {
17730         parser->parser_lex_gets = ripper_lex_get_generic;
17731     }
17732     else {
17733         StringValue(src);
17734         parser->parser_lex_gets = lex_get_str;
17735     }
17736     parser->parser_lex_input = src;
17737     parser->eofp = Qfalse;
17738     if (NIL_P(fname)) {
17739         fname = STR_NEW2("(ripper)");
17740     }
17741     else {
17742         StringValue(fname);
17743     }
17744     parser_initialize(parser);
17745 
17746     parser->parser_ruby_sourcefile_string = fname;
17747     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17748     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17749 
17750     return Qnil;
17751 }
17752 
17753 struct ripper_args {
17754     struct parser_params *parser;
17755     int argc;
17756     VALUE *argv;
17757 };
17758 
17759 static VALUE
17760 ripper_parse0(VALUE parser_v)
17761 {
17762     struct parser_params *parser;
17763 
17764     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17765     parser_prepare(parser);
17766     ripper_yyparse((void*)parser);
17767     return parser->result;
17768 }
17769 
17770 static VALUE
17771 ripper_ensure(VALUE parser_v)
17772 {
17773     struct parser_params *parser;
17774 
17775     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17776     parser->parsing_thread = Qnil;
17777     return Qnil;
17778 }
17779 
17780 /*
17781  *  call-seq:
17782  *    ripper#parse
17783  *
17784  *  Start parsing and returns the value of the root action.
17785  */
17786 static VALUE
17787 ripper_parse(VALUE self)
17788 {
17789     struct parser_params *parser;
17790 
17791     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17792     if (!ripper_initialized_p(parser)) {
17793         rb_raise(rb_eArgError, "method called for uninitialized object");
17794     }
17795     if (!NIL_P(parser->parsing_thread)) {
17796         if (parser->parsing_thread == rb_thread_current())
17797             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17798         else
17799             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17800     }
17801     parser->parsing_thread = rb_thread_current();
17802     rb_ensure(ripper_parse0, self, ripper_ensure, self);
17803 
17804     return parser->result;
17805 }
17806 
17807 /*
17808  *  call-seq:
17809  *    ripper#column   -> Integer
17810  *
17811  *  Return column number of current parsing line.
17812  *  This number starts from 0.
17813  */
17814 static VALUE
17815 ripper_column(VALUE self)
17816 {
17817     struct parser_params *parser;
17818     long col;
17819 
17820     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17821     if (!ripper_initialized_p(parser)) {
17822         rb_raise(rb_eArgError, "method called for uninitialized object");
17823     }
17824     if (NIL_P(parser->parsing_thread)) return Qnil;
17825     col = parser->tokp - parser->parser_lex_pbeg;
17826     return LONG2NUM(col);
17827 }
17828 
17829 /*
17830  *  call-seq:
17831  *    ripper#filename   -> String
17832  *
17833  *  Return current parsing filename.
17834  */
17835 static VALUE
17836 ripper_filename(VALUE self)
17837 {
17838     struct parser_params *parser;
17839 
17840     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17841     if (!ripper_initialized_p(parser)) {
17842         rb_raise(rb_eArgError, "method called for uninitialized object");
17843     }
17844     return parser->parser_ruby_sourcefile_string;
17845 }
17846 
17847 /*
17848  *  call-seq:
17849  *    ripper#lineno   -> Integer
17850  *
17851  *  Return line number of current parsing line.
17852  *  This number starts from 1.
17853  */
17854 static VALUE
17855 ripper_lineno(VALUE self)
17856 {
17857     struct parser_params *parser;
17858 
17859     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17860     if (!ripper_initialized_p(parser)) {
17861         rb_raise(rb_eArgError, "method called for uninitialized object");
17862     }
17863     if (NIL_P(parser->parsing_thread)) return Qnil;
17864     return INT2NUM(parser->parser_ruby_sourceline);
17865 }
17866 
17867 #ifdef RIPPER_DEBUG
17868 /* :nodoc: */
17869 static VALUE
17870 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17871 {
17872     StringValue(msg);
17873     if (obj == Qundef) {
17874         rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17875     }
17876     return Qnil;
17877 }
17878 
17879 /* :nodoc: */
17880 static VALUE
17881 ripper_value(VALUE self, VALUE obj)
17882 {
17883     return ULONG2NUM(obj);
17884 }
17885 #endif
17886 
17887 
17888 void
17889 Init_ripper(void)
17890 {
17891     parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17892 
17893     ripper_init_eventids1();
17894     ripper_init_eventids2();
17895     /* ensure existing in symbol table */
17896     (void)rb_intern("||");
17897     (void)rb_intern("&&");
17898 
17899     InitVM(ripper);
17900 }
17901 
17902 void
17903 InitVM_ripper(void)
17904 {
17905     VALUE Ripper;
17906 
17907     Ripper = rb_define_class("Ripper", rb_cObject);
17908     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17909     rb_define_alloc_func(Ripper, ripper_s_allocate);
17910     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17911     rb_define_method(Ripper, "parse", ripper_parse, 0);
17912     rb_define_method(Ripper, "column", ripper_column, 0);
17913     rb_define_method(Ripper, "filename", ripper_filename, 0);
17914     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17915     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17916     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17917     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17918     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17919 #ifdef RIPPER_DEBUG
17920     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17921     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17922     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17923 #endif
17924 
17925     ripper_init_eventids1_table(Ripper);
17926     ripper_init_eventids2_table(Ripper);
17927 
17928 # if 0
17929     /* Hack to let RDoc document SCRIPT_LINES__ */
17930 
17931     /*
17932      * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17933      * after the assignment will be added as an Array of lines with the file
17934      * name as the key.
17935      */
17936     rb_define_global_const("SCRIPT_LINES__", Qnil);
17937 #endif
17938 
17939 }
17940 #endif /* RIPPER */
17941 
17942