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 YYMALLOC(size)          rb_parser_malloc(parser, (size))
00093 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, (ptr), (size))
00094 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, (nelem), (size))
00095 #define YYFREE(ptr)             rb_parser_free(parser, (ptr))
00096 #define malloc  YYMALLOC
00097 #define realloc YYREALLOC
00098 #define calloc  YYCALLOC
00099 #define free    YYFREE
00100 
00101 #ifndef RIPPER
00102 static ID register_symid(ID, const char *, long, rb_encoding *);
00103 static ID register_symid_str(ID, VALUE);
00104 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
00105 #include "id.c"
00106 #endif
00107 
00108 #define is_notop_id(id) ((id)>tLAST_OP_ID)
00109 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00110 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00111 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00112 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00113 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00114 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00115 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00116 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
00117 
00118 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00119         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00120          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00121          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00122 
00123 enum lex_state_bits {
00124     EXPR_BEG_bit,               /* ignore newline, +/- is a sign. */
00125     EXPR_END_bit,               /* newline significant, +/- is an operator. */
00126     EXPR_ENDARG_bit,            /* ditto, and unbound braces. */
00127     EXPR_ENDFN_bit,             /* ditto, and unbound braces. */
00128     EXPR_ARG_bit,               /* newline significant, +/- is an operator. */
00129     EXPR_CMDARG_bit,            /* newline significant, +/- is an operator. */
00130     EXPR_MID_bit,               /* newline significant, +/- is an operator. */
00131     EXPR_FNAME_bit,             /* ignore newline, no reserved words. */
00132     EXPR_DOT_bit,               /* right after `.' or `::', no reserved words. */
00133     EXPR_CLASS_bit,             /* immediate after `class', no here document. */
00134     EXPR_VALUE_bit,             /* alike EXPR_BEG but label is disallowed. */
00135     EXPR_LABELARG_bit,          /* ignore significant, +/- is a sign. */
00136     EXPR_MAX_STATE
00137 };
00138 /* examine combinations */
00139 enum lex_state_e {
00140 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
00141     DEF_EXPR(BEG),
00142     DEF_EXPR(END),
00143     DEF_EXPR(ENDARG),
00144     DEF_EXPR(ENDFN),
00145     DEF_EXPR(ARG),
00146     DEF_EXPR(CMDARG),
00147     DEF_EXPR(MID),
00148     DEF_EXPR(FNAME),
00149     DEF_EXPR(DOT),
00150     DEF_EXPR(CLASS),
00151     DEF_EXPR(VALUE),
00152     DEF_EXPR(LABELARG),
00153     EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG),
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_kwarg;
00308     int parser_in_defined;
00309     char *parser_tokenbuf;
00310     int parser_tokidx;
00311     int parser_toksiz;
00312     int parser_tokline;
00313     VALUE parser_lex_input;
00314     VALUE parser_lex_lastline;
00315     VALUE parser_lex_nextline;
00316     const char *parser_lex_pbeg;
00317     const char *parser_lex_p;
00318     const char *parser_lex_pend;
00319     int parser_heredoc_end;
00320     int parser_command_start;
00321     NODE *parser_deferred_nodes;
00322     long parser_lex_gets_ptr;
00323     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00324     struct local_vars *parser_lvtbl;
00325     int parser_ruby__end__seen;
00326     int line_count;
00327     int has_shebang;
00328     char *parser_ruby_sourcefile; /* current source file */
00329     int parser_ruby_sourceline; /* current line no. */
00330     VALUE parser_ruby_sourcefile_string;
00331     rb_encoding *enc;
00332 
00333     int parser_yydebug;
00334 
00335     int last_cr_line;
00336 
00337 #ifndef RIPPER
00338     /* Ruby core only */
00339     NODE *parser_eval_tree_begin;
00340     NODE *parser_eval_tree;
00341     VALUE debug_lines;
00342     VALUE coverage;
00343     int nerr;
00344 
00345     int parser_token_info_enabled;
00346     token_info *parser_token_info;
00347 #else
00348     /* Ripper only */
00349     const char *tokp;
00350     VALUE delayed;
00351     int delayed_line;
00352     int delayed_col;
00353 
00354     VALUE value;
00355     VALUE result;
00356     VALUE parsing_thread;
00357     int toplevel_p;
00358 #endif
00359 };
00360 
00361 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
00362 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
00363 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
00364 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
00365 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00366 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
00367 
00368 static int parser_yyerror(struct parser_params*, const char*);
00369 #define yyerror(msg) parser_yyerror(parser, (msg))
00370 
00371 #define lex_strterm             (parser->parser_lex_strterm)
00372 #define lex_state               (parser->parser_lex_state)
00373 #define cond_stack              (parser->parser_cond_stack)
00374 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00375 #define class_nest              (parser->parser_class_nest)
00376 #define paren_nest              (parser->parser_paren_nest)
00377 #define lpar_beg                (parser->parser_lpar_beg)
00378 #define brace_nest              (parser->parser_brace_nest)
00379 #define in_single               (parser->parser_in_single)
00380 #define in_def                  (parser->parser_in_def)
00381 #define compile_for_eval        (parser->parser_compile_for_eval)
00382 #define cur_mid                 (parser->parser_cur_mid)
00383 #define in_defined              (parser->parser_in_defined)
00384 #define tokenbuf                (parser->parser_tokenbuf)
00385 #define tokidx                  (parser->parser_tokidx)
00386 #define toksiz                  (parser->parser_toksiz)
00387 #define tokline                 (parser->parser_tokline)
00388 #define lex_input               (parser->parser_lex_input)
00389 #define lex_lastline            (parser->parser_lex_lastline)
00390 #define lex_nextline            (parser->parser_lex_nextline)
00391 #define lex_pbeg                (parser->parser_lex_pbeg)
00392 #define lex_p                   (parser->parser_lex_p)
00393 #define lex_pend                (parser->parser_lex_pend)
00394 #define heredoc_end             (parser->parser_heredoc_end)
00395 #define command_start           (parser->parser_command_start)
00396 #define deferred_nodes          (parser->parser_deferred_nodes)
00397 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00398 #define lex_gets                (parser->parser_lex_gets)
00399 #define lvtbl                   (parser->parser_lvtbl)
00400 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00401 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00402 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00403 #define ruby_sourcefile_string  (parser->parser_ruby_sourcefile_string)
00404 #define current_enc             (parser->enc)
00405 #define yydebug                 (parser->parser_yydebug)
00406 #ifdef RIPPER
00407 #else
00408 #define ruby_eval_tree          (parser->parser_eval_tree)
00409 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00410 #define ruby_debug_lines        (parser->debug_lines)
00411 #define ruby_coverage           (parser->coverage)
00412 #endif
00413 
00414 #if YYPURE
00415 static int yylex(void*, void*);
00416 #else
00417 static int yylex(void*);
00418 #endif
00419 
00420 #ifndef RIPPER
00421 #define yyparse ruby_yyparse
00422 
00423 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00424 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
00425 
00426 static NODE *cond_gen(struct parser_params*,NODE*);
00427 #define cond(node) cond_gen(parser, (node))
00428 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00429 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
00430 
00431 static NODE *newline_node(NODE*);
00432 static void fixpos(NODE*,NODE*);
00433 
00434 static int value_expr_gen(struct parser_params*,NODE*);
00435 static void void_expr_gen(struct parser_params*,NODE*);
00436 static NODE *remove_begin(NODE*);
00437 static NODE *remove_begin_all(NODE*);
00438 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00439 #define void_expr0(node) void_expr_gen(parser, (node))
00440 #define void_expr(node) void_expr0((node) = remove_begin(node))
00441 static void void_stmts_gen(struct parser_params*,NODE*);
00442 #define void_stmts(node) void_stmts_gen(parser, (node))
00443 static void reduce_nodes_gen(struct parser_params*,NODE**);
00444 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
00445 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00446 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
00447 
00448 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00449 #define block_append(h,t) block_append_gen(parser,(h),(t))
00450 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00451 #define list_append(l,i) list_append_gen(parser,(l),(i))
00452 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00453 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
00454 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00455 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
00456 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00457 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
00458 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00459 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
00460 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00461 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00462 #define new_evstr(n) new_evstr_gen(parser,(n))
00463 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00464 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
00465 static NODE *splat_array(NODE*);
00466 
00467 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00468 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
00469 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00470 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
00471 
00472 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
00473 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00474 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
00475 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00476 
00477 static NODE *negate_lit(NODE*);
00478 static NODE *ret_args_gen(struct parser_params*,NODE*);
00479 #define ret_args(node) ret_args_gen(parser, (node))
00480 static NODE *arg_blk_pass(NODE*,NODE*);
00481 static NODE *new_yield_gen(struct parser_params*,NODE*);
00482 #define new_yield(node) new_yield_gen(parser, (node))
00483 static NODE *dsym_node_gen(struct parser_params*,NODE*);
00484 #define dsym_node(node) dsym_node_gen(parser, (node))
00485 
00486 static NODE *gettable_gen(struct parser_params*,ID);
00487 #define gettable(id) gettable_gen(parser,(id))
00488 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00489 #define assignable(id,node) assignable_gen(parser, (id), (node))
00490 
00491 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00492 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
00493 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00494 #define attrset(node,id) attrset_gen(parser, (node), (id))
00495 
00496 static void rb_backref_error_gen(struct parser_params*,NODE*);
00497 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
00498 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00499 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
00500 
00501 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00502 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
00503 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
00504 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00505 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
00506 
00507 #define new_defined(expr) NEW_DEFINED(remove_begin_all(expr))
00508 
00509 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00510 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
00511 
00512 static ID  *local_tbl_gen(struct parser_params*);
00513 #define local_tbl() local_tbl_gen(parser)
00514 
00515 static void fixup_nodes(NODE **);
00516 
00517 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00518 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
00519 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00520 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
00521 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00522 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
00523 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00524 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
00525 
00526 #define get_id(id) (id)
00527 #define get_value(val) (val)
00528 #else
00529 #define value_expr(node) ((void)(node))
00530 #define remove_begin(node) (node)
00531 #define rb_dvar_defined(id) 0
00532 #define rb_local_defined(id) 0
00533 static ID ripper_get_id(VALUE);
00534 #define get_id(id) ripper_get_id(id)
00535 static VALUE ripper_get_value(VALUE);
00536 #define get_value(val) ripper_get_value(val)
00537 static VALUE assignable_gen(struct parser_params*,VALUE);
00538 #define assignable(lhs,node) assignable_gen(parser, (lhs))
00539 static int id_is_var_gen(struct parser_params *parser, ID id);
00540 #define id_is_var(id) id_is_var_gen(parser, (id))
00541 
00542 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
00543 
00544 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
00545 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
00546 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
00547 
00548 #endif /* !RIPPER */
00549 
00550 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
00551 
00552 static ID formal_argument_gen(struct parser_params*, ID);
00553 #define formal_argument(id) formal_argument_gen(parser, (id))
00554 static ID shadowing_lvar_gen(struct parser_params*,ID);
00555 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
00556 static void new_bv_gen(struct parser_params*,ID);
00557 #define new_bv(id) new_bv_gen(parser, (id))
00558 
00559 static void local_push_gen(struct parser_params*,int);
00560 #define local_push(top) local_push_gen(parser,(top))
00561 static void local_pop_gen(struct parser_params*);
00562 #define local_pop() local_pop_gen(parser)
00563 static int local_var_gen(struct parser_params*, ID);
00564 #define local_var(id) local_var_gen(parser, (id))
00565 static int arg_var_gen(struct parser_params*, ID);
00566 #define arg_var(id) arg_var_gen(parser, (id))
00567 static int  local_id_gen(struct parser_params*, ID);
00568 #define local_id(id) local_id_gen(parser, (id))
00569 static ID   internal_id_gen(struct parser_params*);
00570 #define internal_id() internal_id_gen(parser)
00571 
00572 static const struct vtable *dyna_push_gen(struct parser_params *);
00573 #define dyna_push() dyna_push_gen(parser)
00574 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00575 #define dyna_pop(node) dyna_pop_gen(parser, (node))
00576 static int dyna_in_block_gen(struct parser_params*);
00577 #define dyna_in_block() dyna_in_block_gen(parser)
00578 #define dyna_var(id) local_var(id)
00579 static int dvar_defined_gen(struct parser_params*,ID,int);
00580 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
00581 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
00582 static int dvar_curr_gen(struct parser_params*,ID);
00583 #define dvar_curr(id) dvar_curr_gen(parser, (id))
00584 
00585 static int lvar_defined_gen(struct parser_params*, ID);
00586 #define lvar_defined(id) lvar_defined_gen(parser, (id))
00587 
00588 #define RE_OPTION_ONCE (1<<16)
00589 #define RE_OPTION_ENCODING_SHIFT 8
00590 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00591 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00592 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00593 #define RE_OPTION_MASK  0xff
00594 #define RE_OPTION_ARG_ENCODING_NONE 32
00595 
00596 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00597 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00598 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00599 #define nd_func u1.id
00600 #if SIZEOF_SHORT == 2
00601 #define nd_term(node) ((signed short)(node)->u2.id)
00602 #else
00603 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00604 #endif
00605 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00606 #define nd_nest u3.cnt
00607 
00608 /****** Ripper *******/
00609 
00610 #ifdef RIPPER
00611 #define RIPPER_VERSION "0.1.0"
00612 
00613 #include "eventids1.c"
00614 #include "eventids2.c"
00615 
00616 static VALUE ripper_dispatch0(struct parser_params*,ID);
00617 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00618 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00619 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00620 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00621 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00622 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
00623 
00624 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00625 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
00626 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
00627 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
00628 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
00629 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
00630 #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))
00631 
00632 #define yyparse ripper_yyparse
00633 
00634 #define ripper_intern(s) ID2SYM(rb_intern(s))
00635 static VALUE ripper_id2sym(ID);
00636 #ifdef __GNUC__
00637 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00638                            ID2SYM(id) : ripper_id2sym(id))
00639 #endif
00640 
00641 #define arg_new() dispatch0(args_new)
00642 #define arg_add(l,a) dispatch2(args_add, (l), (a))
00643 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
00644 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
00645 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
00646 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
00647 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
00648 
00649 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
00650 #define mrhs_new() dispatch0(mrhs_new)
00651 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
00652 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
00653 
00654 #define mlhs_new() dispatch0(mlhs_new)
00655 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
00656 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
00657 
00658 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
00659         dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
00660 
00661 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
00662 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
00663 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
00664 
00665 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
00666 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
00667 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
00668 
00669 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00670 
00671 static inline VALUE
00672 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
00673 {
00674     NODE *t = (NODE *)tail;
00675     VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
00676     return params_new(f, o, r, p, k, kr, escape_Qundef(b));
00677 }
00678 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00679 
00680 static inline VALUE
00681 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
00682 {
00683     return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
00684 }
00685 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00686 
00687 #define new_defined(expr) dispatch1(defined, (expr))
00688 
00689 #define FIXME 0
00690 
00691 #endif /* RIPPER */
00692 
00693 #ifndef RIPPER
00694 # define Qnone 0
00695 # define ifndef_ripper(x) (x)
00696 #else
00697 # define Qnone Qnil
00698 # define ifndef_ripper(x)
00699 #endif
00700 
00701 #ifndef RIPPER
00702 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
00703 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00704 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00705 # define rb_warn4S(file,line,fmt,a)  rb_compile_warn((file), (line), (fmt), (a))
00706 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
00707 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00708 #else
00709 # define rb_warn0(fmt)    ripper_warn0(parser, (fmt))
00710 # define rb_warnI(fmt,a)  ripper_warnI(parser, (fmt), (a))
00711 # define rb_warnS(fmt,a)  ripper_warnS(parser, (fmt), (a))
00712 # define rb_warn4S(file,line,fmt,a)  ripper_warnS(parser, (fmt), (a))
00713 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
00714 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
00715 static void ripper_warn0(struct parser_params*, const char*);
00716 static void ripper_warnI(struct parser_params*, const char*, int);
00717 static void ripper_warnS(struct parser_params*, const char*, const char*);
00718 static void ripper_warning0(struct parser_params*, const char*);
00719 static void ripper_warningS(struct parser_params*, const char*, const char*);
00720 #endif
00721 
00722 #ifdef RIPPER
00723 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00724 # define rb_compile_error ripper_compile_error
00725 # define compile_error ripper_compile_error
00726 # define PARSER_ARG parser,
00727 #else
00728 # define rb_compile_error rb_compile_error_with_enc
00729 # define compile_error parser->nerr++,rb_compile_error_with_enc
00730 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
00731 #endif
00732 
00733 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00734    for instance).  This is too low for Ruby to parse some files, such as
00735    date/format.rb, therefore bump the value up to at least Bison's default. */
00736 #ifdef OLD_YACC
00737 #ifndef YYMAXDEPTH
00738 #define YYMAXDEPTH 10000
00739 #endif
00740 #endif
00741 
00742 #ifndef RIPPER
00743 static void token_info_push(struct parser_params*, const char *token);
00744 static void token_info_pop(struct parser_params*, const char *token);
00745 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
00746 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
00747 #else
00748 #define token_info_push(token) /* nothing */
00749 #define token_info_pop(token) /* nothing */
00750 #endif
00751 
00752 
00753 /* Line 268 of yacc.c  */
00754 #line 755 "parse.c"
00755 
00756 /* Enabling traces.  */
00757 #ifndef YYDEBUG
00758 # define YYDEBUG 0
00759 #endif
00760 
00761 /* Enabling verbose error messages.  */
00762 #ifdef YYERROR_VERBOSE
00763 # undef YYERROR_VERBOSE
00764 # define YYERROR_VERBOSE 1
00765 #else
00766 # define YYERROR_VERBOSE 0
00767 #endif
00768 
00769 /* Enabling the token table.  */
00770 #ifndef YYTOKEN_TABLE
00771 # define YYTOKEN_TABLE 0
00772 #endif
00773 
00774 
00775 /* Tokens.  */
00776 #ifndef YYTOKENTYPE
00777 # define YYTOKENTYPE
00778    /* Put the tokens into the symbol table, so that GDB and other debuggers
00779       know about them.  */
00780    enum yytokentype {
00781      END_OF_INPUT = 0,
00782      keyword_class = 258,
00783      keyword_module = 259,
00784      keyword_def = 260,
00785      keyword_undef = 261,
00786      keyword_begin = 262,
00787      keyword_rescue = 263,
00788      keyword_ensure = 264,
00789      keyword_end = 265,
00790      keyword_if = 266,
00791      keyword_unless = 267,
00792      keyword_then = 268,
00793      keyword_elsif = 269,
00794      keyword_else = 270,
00795      keyword_case = 271,
00796      keyword_when = 272,
00797      keyword_while = 273,
00798      keyword_until = 274,
00799      keyword_for = 275,
00800      keyword_break = 276,
00801      keyword_next = 277,
00802      keyword_redo = 278,
00803      keyword_retry = 279,
00804      keyword_in = 280,
00805      keyword_do = 281,
00806      keyword_do_cond = 282,
00807      keyword_do_block = 283,
00808      keyword_do_LAMBDA = 284,
00809      keyword_return = 285,
00810      keyword_yield = 286,
00811      keyword_super = 287,
00812      keyword_self = 288,
00813      keyword_nil = 289,
00814      keyword_true = 290,
00815      keyword_false = 291,
00816      keyword_and = 292,
00817      keyword_or = 293,
00818      keyword_not = 294,
00819      modifier_if = 295,
00820      modifier_unless = 296,
00821      modifier_while = 297,
00822      modifier_until = 298,
00823      modifier_rescue = 299,
00824      keyword_alias = 300,
00825      keyword_defined = 301,
00826      keyword_BEGIN = 302,
00827      keyword_END = 303,
00828      keyword__LINE__ = 304,
00829      keyword__FILE__ = 305,
00830      keyword__ENCODING__ = 306,
00831      tIDENTIFIER = 307,
00832      tFID = 308,
00833      tGVAR = 309,
00834      tIVAR = 310,
00835      tCONSTANT = 311,
00836      tCVAR = 312,
00837      tLABEL = 313,
00838      tINTEGER = 314,
00839      tFLOAT = 315,
00840      tRATIONAL = 316,
00841      tIMAGINARY = 317,
00842      tSTRING_CONTENT = 318,
00843      tCHAR = 319,
00844      tNTH_REF = 320,
00845      tBACK_REF = 321,
00846      tREGEXP_END = 322,
00847      tUPLUS = 130,
00848      tUMINUS = 131,
00849      tPOW = 132,
00850      tCMP = 134,
00851      tEQ = 139,
00852      tEQQ = 140,
00853      tNEQ = 141,
00854      tGEQ = 138,
00855      tLEQ = 137,
00856      tANDOP = 323,
00857      tOROP = 324,
00858      tMATCH = 142,
00859      tNMATCH = 143,
00860      tDOT2 = 128,
00861      tDOT3 = 129,
00862      tAREF = 144,
00863      tASET = 145,
00864      tLSHFT = 135,
00865      tRSHFT = 136,
00866      tCOLON2 = 325,
00867      tCOLON3 = 326,
00868      tOP_ASGN = 327,
00869      tASSOC = 328,
00870      tLPAREN = 329,
00871      tLPAREN_ARG = 330,
00872      tRPAREN = 331,
00873      tLBRACK = 332,
00874      tLBRACE = 333,
00875      tLBRACE_ARG = 334,
00876      tSTAR = 335,
00877      tDSTAR = 336,
00878      tAMPER = 337,
00879      tLAMBDA = 338,
00880      tSYMBEG = 339,
00881      tSTRING_BEG = 340,
00882      tXSTRING_BEG = 341,
00883      tREGEXP_BEG = 342,
00884      tWORDS_BEG = 343,
00885      tQWORDS_BEG = 344,
00886      tSYMBOLS_BEG = 345,
00887      tQSYMBOLS_BEG = 346,
00888      tSTRING_DBEG = 347,
00889      tSTRING_DEND = 348,
00890      tSTRING_DVAR = 349,
00891      tSTRING_END = 350,
00892      tLAMBEG = 351,
00893      tLOWEST = 352,
00894      tUMINUS_NUM = 353,
00895      tLAST_TOKEN = 354
00896    };
00897 #endif
00898 
00899 
00900 
00901 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00902 typedef union YYSTYPE
00903 {
00904 
00905 /* Line 293 of yacc.c  */
00906 #line 699 "parse.y"
00907 
00908     VALUE val;
00909     NODE *node;
00910     ID id;
00911     int num;
00912     const struct vtable *vars;
00913 
00914 
00915 
00916 /* Line 293 of yacc.c  */
00917 #line 918 "parse.c"
00918 } YYSTYPE;
00919 # define YYSTYPE_IS_TRIVIAL 1
00920 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00921 # define YYSTYPE_IS_DECLARED 1
00922 #endif
00923 
00924 
00925 /* Copy the second part of user declarations.  */
00926 
00927 
00928 /* Line 343 of yacc.c  */
00929 #line 930 "parse.c"
00930 
00931 #ifdef short
00932 # undef short
00933 #endif
00934 
00935 #ifdef YYTYPE_UINT8
00936 typedef YYTYPE_UINT8 yytype_uint8;
00937 #else
00938 typedef unsigned char yytype_uint8;
00939 #endif
00940 
00941 #ifdef YYTYPE_INT8
00942 typedef YYTYPE_INT8 yytype_int8;
00943 #elif (defined __STDC__ || defined __C99__FUNC__ \
00944      || defined __cplusplus || defined _MSC_VER)
00945 typedef signed char yytype_int8;
00946 #else
00947 typedef short int yytype_int8;
00948 #endif
00949 
00950 #ifdef YYTYPE_UINT16
00951 typedef YYTYPE_UINT16 yytype_uint16;
00952 #else
00953 typedef unsigned short int yytype_uint16;
00954 #endif
00955 
00956 #ifdef YYTYPE_INT16
00957 typedef YYTYPE_INT16 yytype_int16;
00958 #else
00959 typedef short int yytype_int16;
00960 #endif
00961 
00962 #ifndef YYSIZE_T
00963 # ifdef __SIZE_TYPE__
00964 #  define YYSIZE_T __SIZE_TYPE__
00965 # elif defined size_t
00966 #  define YYSIZE_T size_t
00967 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00968      || defined __cplusplus || defined _MSC_VER)
00969 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00970 #  define YYSIZE_T size_t
00971 # else
00972 #  define YYSIZE_T unsigned int
00973 # endif
00974 #endif
00975 
00976 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00977 
00978 #ifndef YY_
00979 # if defined YYENABLE_NLS && YYENABLE_NLS
00980 #  if ENABLE_NLS
00981 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00982 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00983 #  endif
00984 # endif
00985 # ifndef YY_
00986 #  define YY_(msgid) msgid
00987 # endif
00988 #endif
00989 
00990 /* Suppress unused-variable warnings by "using" E.  */
00991 #if ! defined lint || defined __GNUC__
00992 # define YYUSE(e) ((void) (e))
00993 #else
00994 # define YYUSE(e) /* empty */
00995 #endif
00996 
00997 /* Identity function, used to suppress warnings about constant conditions.  */
00998 #ifndef lint
00999 # define YYID(n) (n)
01000 #else
01001 #if (defined __STDC__ || defined __C99__FUNC__ \
01002      || defined __cplusplus || defined _MSC_VER)
01003 static int
01004 YYID (int yyi)
01005 #else
01006 static int
01007 YYID (yyi)
01008     int yyi;
01009 #endif
01010 {
01011   return yyi;
01012 }
01013 #endif
01014 
01015 #if ! defined yyoverflow || YYERROR_VERBOSE
01016 
01017 /* The parser invokes alloca or malloc; define the necessary symbols.  */
01018 
01019 # ifdef YYSTACK_USE_ALLOCA
01020 #  if YYSTACK_USE_ALLOCA
01021 #   ifdef __GNUC__
01022 #    define YYSTACK_ALLOC __builtin_alloca
01023 #   elif defined __BUILTIN_VA_ARG_INCR
01024 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
01025 #   elif defined _AIX
01026 #    define YYSTACK_ALLOC __alloca
01027 #   elif defined _MSC_VER
01028 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
01029 #    define alloca _alloca
01030 #   else
01031 #    define YYSTACK_ALLOC alloca
01032 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01033      || defined __cplusplus || defined _MSC_VER)
01034 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01035 #     ifndef EXIT_SUCCESS
01036 #      define EXIT_SUCCESS 0
01037 #     endif
01038 #    endif
01039 #   endif
01040 #  endif
01041 # endif
01042 
01043 # ifdef YYSTACK_ALLOC
01044    /* Pacify GCC's `empty if-body' warning.  */
01045 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
01046 #  ifndef YYSTACK_ALLOC_MAXIMUM
01047     /* The OS might guarantee only one guard page at the bottom of the stack,
01048        and a page size can be as small as 4096 bytes.  So we cannot safely
01049        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01050        to allow for a few compiler-allocated temporary stack slots.  */
01051 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01052 #  endif
01053 # else
01054 #  define YYSTACK_ALLOC YYMALLOC
01055 #  define YYSTACK_FREE YYFREE
01056 #  ifndef YYSTACK_ALLOC_MAXIMUM
01057 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01058 #  endif
01059 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
01060        && ! ((defined YYMALLOC || defined malloc) \
01061              && (defined YYFREE || defined free)))
01062 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01063 #   ifndef EXIT_SUCCESS
01064 #    define EXIT_SUCCESS 0
01065 #   endif
01066 #  endif
01067 #  ifndef YYMALLOC
01068 #   define YYMALLOC malloc
01069 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01070      || defined __cplusplus || defined _MSC_VER)
01071 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01072 #   endif
01073 #  endif
01074 #  ifndef YYFREE
01075 #   define YYFREE free
01076 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01077      || defined __cplusplus || defined _MSC_VER)
01078 void free (void *); /* INFRINGES ON USER NAME SPACE */
01079 #   endif
01080 #  endif
01081 # endif
01082 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01083 
01084 
01085 #if (! defined yyoverflow \
01086      && (! defined __cplusplus \
01087          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01088 
01089 /* A type that is properly aligned for any stack member.  */
01090 union yyalloc
01091 {
01092   yytype_int16 yyss_alloc;
01093   YYSTYPE yyvs_alloc;
01094 };
01095 
01096 /* The size of the maximum gap between one aligned stack and the next.  */
01097 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01098 
01099 /* The size of an array large to enough to hold all stacks, each with
01100    N elements.  */
01101 # define YYSTACK_BYTES(N) \
01102      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01103       + YYSTACK_GAP_MAXIMUM)
01104 
01105 # define YYCOPY_NEEDED 1
01106 
01107 /* Relocate STACK from its old location to the new one.  The
01108    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01109    elements in the stack, and YYPTR gives the new location of the
01110    stack.  Advance YYPTR to a properly aligned location for the next
01111    stack.  */
01112 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01113     do                                                                  \
01114       {                                                                 \
01115         YYSIZE_T yynewbytes;                                            \
01116         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01117         Stack = &yyptr->Stack_alloc;                                    \
01118         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01119         yyptr += yynewbytes / sizeof (*yyptr);                          \
01120       }                                                                 \
01121     while (YYID (0))
01122 
01123 #endif
01124 
01125 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
01126 /* Copy COUNT objects from FROM to TO.  The source and destination do
01127    not overlap.  */
01128 # ifndef YYCOPY
01129 #  if defined __GNUC__ && 1 < __GNUC__
01130 #   define YYCOPY(To, From, Count) \
01131       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01132 #  else
01133 #   define YYCOPY(To, From, Count)              \
01134       do                                        \
01135         {                                       \
01136           YYSIZE_T yyi;                         \
01137           for (yyi = 0; yyi < (Count); yyi++)   \
01138             (To)[yyi] = (From)[yyi];            \
01139         }                                       \
01140       while (YYID (0))
01141 #  endif
01142 # endif
01143 #endif /* !YYCOPY_NEEDED */
01144 
01145 /* YYFINAL -- State number of the termination state.  */
01146 #define YYFINAL  3
01147 /* YYLAST -- Last index in YYTABLE.  */
01148 #define YYLAST   11083
01149 
01150 /* YYNTOKENS -- Number of terminals.  */
01151 #define YYNTOKENS  144
01152 /* YYNNTS -- Number of nonterminals.  */
01153 #define YYNNTS  204
01154 /* YYNRULES -- Number of rules.  */
01155 #define YYNRULES  627
01156 /* YYNRULES -- Number of states.  */
01157 #define YYNSTATES  1060
01158 
01159 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01160 #define YYUNDEFTOK  2
01161 #define YYMAXUTOK   354
01162 
01163 #define YYTRANSLATE(YYX)                                                \
01164   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01165 
01166 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01167 static const yytype_uint8 yytranslate[] =
01168 {
01169        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01170      143,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01171        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01172        2,     2,   142,   129,     2,     2,     2,   127,   122,     2,
01173      138,   139,   125,   123,   136,   124,   135,   126,     2,     2,
01174        2,     2,     2,     2,     2,     2,     2,     2,   117,   141,
01175      119,   115,   118,   116,     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,   134,     2,   140,   121,     2,   137,     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,   132,   120,   133,   130,     2,    81,    82,
01182       68,    69,    70,     2,    71,    85,    86,    76,    75,    72,
01183       73,    74,    79,    80,    83,    84,     2,     2,     2,     2,
01184        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01185        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01186        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01187        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01188        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01189        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01190        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01191        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01192        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01193        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01194        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01195        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01196       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01197       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01198       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01199       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01200       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01201       65,    66,    67,    77,    78,    87,    88,    89,    90,    91,
01202       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
01203      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
01204      112,   113,   114,   128,   131
01205 };
01206 
01207 #if YYDEBUG
01208 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01209    YYRHS.  */
01210 static const yytype_uint16 yyprhs[] =
01211 {
01212        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01213       23,    24,    30,    35,    38,    40,    42,    46,    49,    51,
01214       52,    58,    59,    64,    68,    72,    76,    79,    83,    87,
01215       91,    95,    99,   104,   106,   110,   114,   121,   127,   133,
01216      139,   145,   149,   153,   157,   159,   163,   167,   169,   173,
01217      177,   181,   184,   186,   188,   190,   192,   194,   199,   200,
01218      206,   208,   211,   215,   220,   226,   231,   237,   240,   243,
01219      246,   249,   252,   254,   258,   260,   264,   266,   269,   273,
01220      279,   282,   287,   290,   295,   297,   301,   303,   307,   310,
01221      314,   316,   320,   322,   324,   329,   333,   337,   341,   345,
01222      348,   350,   352,   354,   359,   363,   367,   371,   375,   378,
01223      380,   382,   384,   387,   389,   393,   395,   397,   399,   401,
01224      403,   405,   407,   409,   411,   413,   414,   419,   421,   423,
01225      425,   427,   429,   431,   433,   435,   437,   439,   441,   443,
01226      445,   447,   449,   451,   453,   455,   457,   459,   461,   463,
01227      465,   467,   469,   471,   473,   475,   477,   479,   481,   483,
01228      485,   487,   489,   491,   493,   495,   497,   499,   501,   503,
01229      505,   507,   509,   511,   513,   515,   517,   519,   521,   523,
01230      525,   527,   529,   531,   533,   535,   537,   539,   541,   543,
01231      545,   547,   549,   551,   553,   555,   557,   559,   561,   565,
01232      571,   575,   581,   588,   594,   600,   606,   612,   617,   621,
01233      625,   629,   633,   637,   641,   645,   649,   653,   658,   661,
01234      664,   668,   672,   676,   680,   684,   688,   692,   696,   700,
01235      704,   708,   712,   716,   719,   722,   726,   730,   734,   738,
01236      739,   744,   751,   753,   755,   757,   760,   765,   768,   772,
01237      774,   776,   778,   780,   783,   788,   791,   793,   796,   799,
01238      804,   806,   807,   810,   813,   816,   818,   820,   823,   827,
01239      832,   834,   836,   840,   845,   848,   850,   852,   854,   856,
01240      858,   860,   862,   864,   866,   868,   870,   871,   876,   877,
01241      881,   882,   883,   889,   893,   897,   900,   904,   908,   910,
01242      915,   919,   921,   922,   929,   934,   938,   941,   943,   946,
01243      949,   956,   963,   964,   965,   973,   974,   975,   983,   989,
01244      994,   995,   996,  1006,  1007,  1014,  1015,  1016,  1025,  1026,
01245     1032,  1033,  1040,  1041,  1042,  1052,  1054,  1056,  1058,  1060,
01246     1062,  1064,  1066,  1068,  1070,  1072,  1074,  1076,  1078,  1080,
01247     1082,  1084,  1086,  1088,  1091,  1093,  1095,  1097,  1103,  1105,
01248     1108,  1110,  1112,  1114,  1118,  1120,  1124,  1126,  1131,  1138,
01249     1142,  1148,  1151,  1156,  1158,  1162,  1167,  1170,  1173,  1175,
01250     1178,  1179,  1186,  1195,  1200,  1207,  1212,  1215,  1222,  1225,
01251     1230,  1237,  1240,  1245,  1248,  1253,  1255,  1257,  1259,  1263,
01252     1265,  1270,  1272,  1277,  1279,  1283,  1285,  1287,  1288,  1289,
01253     1290,  1291,  1298,  1303,  1305,  1309,  1313,  1314,  1320,  1323,
01254     1328,  1334,  1340,  1343,  1344,  1350,  1351,  1357,  1361,  1362,
01255     1367,  1368,  1373,  1376,  1378,  1383,  1384,  1390,  1391,  1397,
01256     1403,  1405,  1407,  1414,  1416,  1418,  1420,  1422,  1425,  1427,
01257     1430,  1432,  1434,  1436,  1438,  1440,  1442,  1444,  1447,  1451,
01258     1455,  1459,  1463,  1467,  1468,  1472,  1474,  1477,  1481,  1485,
01259     1486,  1490,  1494,  1498,  1502,  1506,  1507,  1511,  1512,  1516,
01260     1517,  1520,  1521,  1524,  1525,  1528,  1530,  1531,  1535,  1536,
01261     1537,  1538,  1545,  1547,  1549,  1551,  1553,  1556,  1558,  1560,
01262     1562,  1564,  1568,  1570,  1573,  1575,  1577,  1579,  1581,  1583,
01263     1585,  1587,  1589,  1591,  1593,  1595,  1597,  1599,  1601,  1603,
01264     1605,  1607,  1609,  1611,  1613,  1615,  1617,  1619,  1620,  1625,
01265     1628,  1632,  1633,  1637,  1642,  1645,  1648,  1650,  1653,  1654,
01266     1661,  1670,  1675,  1682,  1687,  1694,  1697,  1702,  1709,  1712,
01267     1717,  1720,  1725,  1727,  1728,  1730,  1732,  1734,  1736,  1738,
01268     1740,  1742,  1746,  1748,  1752,  1754,  1757,  1759,  1762,  1764,
01269     1766,  1770,  1772,  1776,  1778,  1780,  1783,  1785,  1789,  1793,
01270     1795,  1799,  1801,  1805,  1807,  1809,  1812,  1814,  1816,  1818,
01271     1821,  1824,  1826,  1828,  1829,  1834,  1836,  1839,  1841,  1845,
01272     1849,  1852,  1855,  1857,  1859,  1861,  1863,  1865,  1867,  1869,
01273     1871,  1873,  1875,  1877,  1879,  1880,  1882,  1883,  1885,  1888,
01274     1891,  1892,  1894,  1896,  1898,  1900,  1902,  1905
01275 };
01276 
01277 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01278 static const yytype_int16 yyrhs[] =
01279 {
01280      145,     0,    -1,    -1,   146,   147,    -1,   148,   340,    -1,
01281      347,    -1,   149,    -1,   148,   346,   149,    -1,     1,   149,
01282       -1,   156,    -1,    -1,    47,   150,   132,   147,   133,    -1,
01283      152,   266,   233,   269,    -1,   153,   340,    -1,   347,    -1,
01284      154,    -1,   153,   346,   154,    -1,     1,   156,    -1,   156,
01285       -1,    -1,    47,   155,   132,   147,   133,    -1,    -1,    45,
01286      179,   157,   179,    -1,    45,    54,    54,    -1,    45,    54,
01287       66,    -1,    45,    54,    65,    -1,     6,   180,    -1,   156,
01288       40,   160,    -1,   156,    41,   160,    -1,   156,    42,   160,
01289       -1,   156,    43,   160,    -1,   156,    44,   156,    -1,    48,
01290      132,   152,   133,    -1,   158,    -1,   167,   115,   161,    -1,
01291      302,    89,   161,    -1,   218,   134,   190,   343,    89,   161,
01292       -1,   218,   135,    52,    89,   161,    -1,   218,   135,    56,
01293       89,   161,    -1,   218,    87,    56,    89,   161,    -1,   218,
01294       87,    52,    89,   161,    -1,   303,    89,   161,    -1,   174,
01295      115,   198,    -1,   167,   115,   197,    -1,   159,    -1,   174,
01296      115,   161,    -1,   174,   115,   158,    -1,   161,    -1,   159,
01297       37,   159,    -1,   159,    38,   159,    -1,    39,   341,   159,
01298       -1,   129,   161,    -1,   184,    -1,   159,    -1,   166,    -1,
01299      162,    -1,   255,    -1,   255,   339,   337,   192,    -1,    -1,
01300       96,   164,   241,   152,   133,    -1,   336,    -1,   165,   192,
01301       -1,   165,   192,   163,    -1,   218,   135,   337,   192,    -1,
01302      218,   135,   337,   192,   163,    -1,   218,    87,   337,   192,
01303       -1,   218,    87,   337,   192,   163,    -1,    32,   192,    -1,
01304       31,   192,    -1,    30,   191,    -1,    21,   191,    -1,    22,
01305      191,    -1,   169,    -1,    91,   168,   342,    -1,   169,    -1,
01306       91,   168,   342,    -1,   171,    -1,   171,   170,    -1,   171,
01307       97,   173,    -1,   171,    97,   173,   136,   172,    -1,   171,
01308       97,    -1,   171,    97,   136,   172,    -1,    97,   173,    -1,
01309       97,   173,   136,   172,    -1,    97,    -1,    97,   136,   172,
01310       -1,   173,    -1,    91,   168,   342,    -1,   170,   136,    -1,
01311      171,   170,   136,    -1,   170,    -1,   172,   136,   170,    -1,
01312      299,    -1,   300,    -1,   218,   134,   190,   343,    -1,   218,
01313      135,    52,    -1,   218,    87,    52,    -1,   218,   135,    56,
01314       -1,   218,    87,    56,    -1,    88,    56,    -1,   303,    -1,
01315      299,    -1,   300,    -1,   218,   134,   190,   343,    -1,   218,
01316      135,    52,    -1,   218,    87,    52,    -1,   218,   135,    56,
01317       -1,   218,    87,    56,    -1,    88,    56,    -1,   303,    -1,
01318       52,    -1,    56,    -1,    88,   175,    -1,   175,    -1,   218,
01319       87,   175,    -1,    52,    -1,    56,    -1,    53,    -1,   182,
01320       -1,   183,    -1,   177,    -1,   294,    -1,   178,    -1,   296,
01321       -1,   179,    -1,    -1,   180,   136,   181,   179,    -1,   120,
01322       -1,   121,    -1,   122,    -1,    71,    -1,    72,    -1,    73,
01323       -1,    79,    -1,    80,    -1,   118,    -1,    75,    -1,   119,
01324       -1,    76,    -1,    74,    -1,    85,    -1,    86,    -1,   123,
01325       -1,   124,    -1,   125,    -1,    97,    -1,   126,    -1,   127,
01326       -1,    70,    -1,    98,    -1,   129,    -1,   130,    -1,    68,
01327       -1,    69,    -1,    83,    -1,    84,    -1,   137,    -1,    49,
01328       -1,    50,    -1,    51,    -1,    47,    -1,    48,    -1,    45,
01329       -1,    37,    -1,     7,    -1,    21,    -1,    16,    -1,     3,
01330       -1,     5,    -1,    46,    -1,    26,    -1,    15,    -1,    14,
01331       -1,    10,    -1,     9,    -1,    36,    -1,    20,    -1,    25,
01332       -1,     4,    -1,    22,    -1,    34,    -1,    39,    -1,    38,
01333       -1,    23,    -1,     8,    -1,    24,    -1,    30,    -1,    33,
01334       -1,    32,    -1,    13,    -1,    35,    -1,     6,    -1,    17,
01335       -1,    31,    -1,    11,    -1,    12,    -1,    18,    -1,    19,
01336       -1,   174,   115,   184,    -1,   174,   115,   184,    44,   184,
01337       -1,   302,    89,   184,    -1,   302,    89,   184,    44,   184,
01338       -1,   218,   134,   190,   343,    89,   184,    -1,   218,   135,
01339       52,    89,   184,    -1,   218,   135,    56,    89,   184,    -1,
01340      218,    87,    52,    89,   184,    -1,   218,    87,    56,    89,
01341      184,    -1,    88,    56,    89,   184,    -1,   303,    89,   184,
01342       -1,   184,    81,   184,    -1,   184,    82,   184,    -1,   184,
01343      123,   184,    -1,   184,   124,   184,    -1,   184,   125,   184,
01344       -1,   184,   126,   184,    -1,   184,   127,   184,    -1,   184,
01345       70,   184,    -1,   128,   298,    70,   184,    -1,    68,   184,
01346       -1,    69,   184,    -1,   184,   120,   184,    -1,   184,   121,
01347      184,    -1,   184,   122,   184,    -1,   184,    71,   184,    -1,
01348      184,   118,   184,    -1,   184,    75,   184,    -1,   184,   119,
01349      184,    -1,   184,    76,   184,    -1,   184,    72,   184,    -1,
01350      184,    73,   184,    -1,   184,    74,   184,    -1,   184,    79,
01351      184,    -1,   184,    80,   184,    -1,   129,   184,    -1,   130,
01352      184,    -1,   184,    85,   184,    -1,   184,    86,   184,    -1,
01353      184,    77,   184,    -1,   184,    78,   184,    -1,    -1,    46,
01354      341,   185,   184,    -1,   184,   116,   184,   341,   117,   184,
01355       -1,   199,    -1,   184,    -1,   347,    -1,   196,   344,    -1,
01356      196,   136,   334,   344,    -1,   334,   344,    -1,   138,   190,
01357      342,    -1,   347,    -1,   188,    -1,   347,    -1,   191,    -1,
01358      196,   136,    -1,   196,   136,   334,   136,    -1,   334,   136,
01359       -1,   166,    -1,   196,   195,    -1,   334,   195,    -1,   196,
01360      136,   334,   195,    -1,   194,    -1,    -1,   193,   191,    -1,
01361       99,   186,    -1,   136,   194,    -1,   347,    -1,   186,    -1,
01362       97,   186,    -1,   196,   136,   186,    -1,   196,   136,    97,
01363      186,    -1,   198,    -1,   186,    -1,   196,   136,   186,    -1,
01364      196,   136,    97,   186,    -1,    97,   186,    -1,   270,    -1,
01365      271,    -1,   274,    -1,   275,    -1,   276,    -1,   281,    -1,
01366      279,    -1,   282,    -1,   301,    -1,   303,    -1,    53,    -1,
01367       -1,   219,   200,   151,   229,    -1,    -1,    92,   201,   342,
01368       -1,    -1,    -1,    92,   202,   159,   203,   342,    -1,    91,
01369      152,   139,    -1,   218,    87,    56,    -1,    88,    56,    -1,
01370       94,   187,   140,    -1,    95,   333,   133,    -1,    30,    -1,
01371       31,   138,   191,   342,    -1,    31,   138,   342,    -1,    31,
01372       -1,    -1,    46,   341,   138,   204,   159,   342,    -1,    39,
01373      138,   159,   342,    -1,    39,   138,   342,    -1,   165,   261,
01374       -1,   256,    -1,   256,   261,    -1,   100,   246,    -1,   220,
01375      160,   230,   152,   232,   229,    -1,   221,   160,   230,   152,
01376      233,   229,    -1,    -1,    -1,   222,   205,   160,   231,   206,
01377      152,   229,    -1,    -1,    -1,   223,   207,   160,   231,   208,
01378      152,   229,    -1,   224,   160,   340,   264,   229,    -1,   224,
01379      340,   264,   229,    -1,    -1,    -1,   225,   234,    25,   209,
01380      160,   231,   210,   152,   229,    -1,    -1,   226,   176,   304,
01381      211,   151,   229,    -1,    -1,    -1,   226,    85,   159,   212,
01382      345,   213,   151,   229,    -1,    -1,   227,   176,   214,   151,
01383      229,    -1,    -1,   228,   177,   215,   306,   151,   229,    -1,
01384       -1,    -1,   228,   331,   339,   216,   177,   217,   306,   151,
01385      229,    -1,    21,    -1,    22,    -1,    23,    -1,    24,    -1,
01386      199,    -1,     7,    -1,    11,    -1,    12,    -1,    18,    -1,
01387       19,    -1,    16,    -1,    20,    -1,     3,    -1,     4,    -1,
01388        5,    -1,    10,    -1,   345,    -1,    13,    -1,   345,    13,
01389       -1,   345,    -1,    27,    -1,   233,    -1,    14,   160,   230,
01390      152,   232,    -1,   347,    -1,    15,   152,    -1,   174,    -1,
01391      167,    -1,   312,    -1,    91,   237,   342,    -1,   235,    -1,
01392      236,   136,   235,    -1,   236,    -1,   236,   136,    97,   312,
01393       -1,   236,   136,    97,   312,   136,   236,    -1,   236,   136,
01394       97,    -1,   236,   136,    97,   136,   236,    -1,    97,   312,
01395       -1,    97,   312,   136,   236,    -1,    97,    -1,    97,   136,
01396      236,    -1,   318,   136,   321,   330,    -1,   318,   330,    -1,
01397      321,   330,    -1,   329,    -1,   136,   238,    -1,    -1,   314,
01398      136,   324,   136,   327,   239,    -1,   314,   136,   324,   136,
01399      327,   136,   314,   239,    -1,   314,   136,   324,   239,    -1,
01400      314,   136,   324,   136,   314,   239,    -1,   314,   136,   327,
01401      239,    -1,   314,   136,    -1,   314,   136,   327,   136,   314,
01402      239,    -1,   314,   239,    -1,   324,   136,   327,   239,    -1,
01403      324,   136,   327,   136,   314,   239,    -1,   324,   239,    -1,
01404      324,   136,   314,   239,    -1,   327,   239,    -1,   327,   136,
01405      314,   239,    -1,   238,    -1,   347,    -1,   242,    -1,   120,
01406      243,   120,    -1,    78,    -1,   120,   240,   243,   120,    -1,
01407      341,    -1,   341,   141,   244,   341,    -1,   245,    -1,   244,
01408      136,   245,    -1,    52,    -1,   311,    -1,    -1,    -1,    -1,
01409       -1,   247,   248,   251,   249,   250,   252,    -1,   138,   310,
01410      243,   139,    -1,   310,    -1,   113,   152,   133,    -1,    29,
01411      152,    10,    -1,    -1,    28,   254,   241,   152,    10,    -1,
01412      166,   253,    -1,   255,   339,   337,   189,    -1,   255,   339,
01413      337,   189,   261,    -1,   255,   339,   337,   192,   253,    -1,
01414      165,   188,    -1,    -1,   218,   135,   337,   257,   189,    -1,
01415       -1,   218,    87,   337,   258,   188,    -1,   218,    87,   338,
01416       -1,    -1,   218,   135,   259,   188,    -1,    -1,   218,    87,
01417      260,   188,    -1,    32,   188,    -1,    32,    -1,   218,   134,
01418      190,   343,    -1,    -1,   132,   262,   241,   152,   133,    -1,
01419       -1,    26,   263,   241,   152,    10,    -1,    17,   196,   230,
01420      152,   265,    -1,   233,    -1,   264,    -1,     8,   267,   268,
01421      230,   152,   266,    -1,   347,    -1,   186,    -1,   198,    -1,
01422      347,    -1,    90,   174,    -1,   347,    -1,     9,   152,    -1,
01423      347,    -1,   297,    -1,   294,    -1,   296,    -1,   272,    -1,
01424       64,    -1,   273,    -1,   272,   273,    -1,   102,   285,   112,
01425       -1,   103,   286,   112,    -1,   104,   287,    67,    -1,   105,
01426      142,   112,    -1,   105,   277,   112,    -1,    -1,   277,   278,
01427      142,    -1,   288,    -1,   278,   288,    -1,   107,   142,   112,
01428       -1,   107,   280,   112,    -1,    -1,   280,   278,   142,    -1,
01429      106,   142,   112,    -1,   106,   283,   112,    -1,   108,   142,
01430      112,    -1,   108,   284,   112,    -1,    -1,   283,    63,   142,
01431       -1,    -1,   284,    63,   142,    -1,    -1,   285,   288,    -1,
01432       -1,   286,   288,    -1,    -1,   287,   288,    -1,    63,    -1,
01433       -1,   111,   289,   293,    -1,    -1,    -1,    -1,   109,   290,
01434      291,   292,   152,   110,    -1,    54,    -1,    55,    -1,    57,
01435       -1,   303,    -1,   101,   295,    -1,   177,    -1,    55,    -1,
01436       54,    -1,    57,    -1,   101,   286,   112,    -1,   298,    -1,
01437      128,   298,    -1,    59,    -1,    60,    -1,    61,    -1,    62,
01438       -1,    52,    -1,    55,    -1,    54,    -1,    56,    -1,    57,
01439       -1,    34,    -1,    33,    -1,    35,    -1,    36,    -1,    50,
01440       -1,    49,    -1,    51,    -1,   299,    -1,   300,    -1,   299,
01441       -1,   300,    -1,    65,    -1,    66,    -1,   345,    -1,    -1,
01442      119,   305,   160,   345,    -1,     1,   345,    -1,   138,   310,
01443      342,    -1,    -1,   307,   310,   345,    -1,   319,   136,   321,
01444      330,    -1,   319,   330,    -1,   321,   330,    -1,   329,    -1,
01445      136,   308,    -1,    -1,   314,   136,   325,   136,   327,   309,
01446       -1,   314,   136,   325,   136,   327,   136,   314,   309,    -1,
01447      314,   136,   325,   309,    -1,   314,   136,   325,   136,   314,
01448      309,    -1,   314,   136,   327,   309,    -1,   314,   136,   327,
01449      136,   314,   309,    -1,   314,   309,    -1,   325,   136,   327,
01450      309,    -1,   325,   136,   327,   136,   314,   309,    -1,   325,
01451      309,    -1,   325,   136,   314,   309,    -1,   327,   309,    -1,
01452      327,   136,   314,   309,    -1,   308,    -1,    -1,    56,    -1,
01453       55,    -1,    54,    -1,    57,    -1,   311,    -1,    52,    -1,
01454      312,    -1,    91,   237,   342,    -1,   313,    -1,   314,   136,
01455      313,    -1,    58,    -1,   315,   186,    -1,   315,    -1,   315,
01456      218,    -1,   315,    -1,   317,    -1,   318,   136,   317,    -1,
01457      316,    -1,   319,   136,   316,    -1,    70,    -1,    98,    -1,
01458      320,    52,    -1,   320,    -1,   312,   115,   186,    -1,   312,
01459      115,   218,    -1,   323,    -1,   324,   136,   323,    -1,   322,
01460       -1,   325,   136,   322,    -1,   125,    -1,    97,    -1,   326,
01461       52,    -1,   326,    -1,   122,    -1,    99,    -1,   328,    52,
01462       -1,   136,   329,    -1,   347,    -1,   301,    -1,    -1,   138,
01463      332,   159,   342,    -1,   347,    -1,   334,   344,    -1,   335,
01464       -1,   334,   136,   335,    -1,   186,    90,   186,    -1,    58,
01465      186,    -1,    98,   186,    -1,    52,    -1,    56,    -1,    53,
01466       -1,    52,    -1,    56,    -1,    53,    -1,   182,    -1,    52,
01467       -1,    53,    -1,   182,    -1,   135,    -1,    87,    -1,    -1,
01468      346,    -1,    -1,   143,    -1,   341,   139,    -1,   341,   140,
01469       -1,    -1,   143,    -1,   136,    -1,   141,    -1,   143,    -1,
01470      345,    -1,   346,   141,    -1,    -1
01471 };
01472 
01473 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01474 static const yytype_uint16 yyrline[] =
01475 {
01476        0,   863,   863,   863,   894,   905,   914,   922,   930,   936,
01477      938,   937,   958,   991,  1002,  1011,  1019,  1027,  1033,  1038,
01478     1037,  1058,  1058,  1066,  1074,  1085,  1095,  1103,  1112,  1121,
01479     1134,  1147,  1156,  1168,  1169,  1179,  1184,  1205,  1210,  1215,
01480     1225,  1230,  1240,  1249,  1258,  1261,  1270,  1282,  1283,  1291,
01481     1299,  1307,  1315,  1318,  1330,  1331,  1334,  1335,  1347,  1346,
01482     1368,  1378,  1387,  1400,  1409,  1421,  1430,  1442,  1451,  1460,
01483     1468,  1476,  1486,  1487,  1497,  1498,  1508,  1516,  1524,  1532,
01484     1541,  1549,  1558,  1566,  1575,  1583,  1594,  1595,  1605,  1613,
01485     1623,  1631,  1641,  1645,  1649,  1657,  1665,  1673,  1681,  1693,
01486     1703,  1715,  1724,  1733,  1741,  1749,  1757,  1765,  1778,  1791,
01487     1802,  1810,  1813,  1821,  1829,  1839,  1840,  1841,  1842,  1847,
01488     1858,  1859,  1862,  1870,  1873,  1881,  1881,  1891,  1892,  1893,
01489     1894,  1895,  1896,  1897,  1898,  1899,  1900,  1901,  1902,  1903,
01490     1904,  1905,  1906,  1907,  1908,  1909,  1910,  1911,  1912,  1913,
01491     1914,  1915,  1916,  1917,  1918,  1919,  1920,  1923,  1923,  1923,
01492     1924,  1924,  1925,  1925,  1925,  1926,  1926,  1926,  1926,  1927,
01493     1927,  1927,  1927,  1928,  1928,  1928,  1929,  1929,  1929,  1929,
01494     1930,  1930,  1930,  1930,  1931,  1931,  1931,  1931,  1932,  1932,
01495     1932,  1932,  1933,  1933,  1933,  1933,  1934,  1934,  1937,  1946,
01496     1956,  1961,  1971,  1997,  2002,  2007,  2012,  2022,  2032,  2043,
01497     2057,  2071,  2079,  2087,  2095,  2103,  2111,  2119,  2128,  2136,
01498     2144,  2152,  2160,  2168,  2176,  2184,  2192,  2200,  2208,  2216,
01499     2224,  2232,  2243,  2251,  2259,  2267,  2275,  2283,  2291,  2299,
01500     2299,  2309,  2319,  2325,  2337,  2338,  2342,  2350,  2360,  2370,
01501     2371,  2374,  2375,  2376,  2380,  2388,  2398,  2407,  2415,  2425,
01502     2434,  2443,  2443,  2455,  2465,  2469,  2475,  2483,  2491,  2505,
01503     2521,  2522,  2525,  2539,  2554,  2564,  2565,  2566,  2567,  2568,
01504     2569,  2570,  2571,  2572,  2573,  2574,  2583,  2582,  2610,  2610,
01505     2619,  2623,  2618,  2632,  2640,  2648,  2656,  2669,  2677,  2685,
01506     2693,  2701,  2709,  2709,  2719,  2727,  2735,  2745,  2746,  2756,
01507     2760,  2772,  2784,  2784,  2784,  2795,  2795,  2795,  2806,  2817,
01508     2826,  2828,  2825,  2892,  2891,  2913,  2918,  2912,  2937,  2936,
01509     2958,  2957,  2980,  2981,  2980,  3001,  3009,  3017,  3025,  3035,
01510     3047,  3053,  3059,  3065,  3071,  3077,  3083,  3089,  3095,  3101,
01511     3111,  3117,  3122,  3123,  3130,  3135,  3138,  3139,  3152,  3153,
01512     3163,  3164,  3167,  3175,  3185,  3193,  3203,  3211,  3220,  3229,
01513     3237,  3245,  3254,  3266,  3274,  3285,  3289,  3293,  3297,  3303,
01514     3308,  3313,  3317,  3321,  3325,  3329,  3333,  3341,  3345,  3349,
01515     3353,  3357,  3361,  3365,  3369,  3373,  3379,  3380,  3386,  3395,
01516     3404,  3415,  3419,  3429,  3436,  3445,  3453,  3459,  3462,  3467,
01517     3470,  3459,  3489,  3497,  3503,  3507,  3514,  3513,  3534,  3550,
01518     3559,  3571,  3585,  3595,  3594,  3611,  3610,  3626,  3635,  3634,
01519     3652,  3651,  3668,  3676,  3684,  3699,  3698,  3718,  3717,  3738,
01520     3750,  3751,  3754,  3773,  3776,  3784,  3792,  3795,  3799,  3802,
01521     3810,  3813,  3814,  3822,  3825,  3842,  3843,  3844,  3854,  3864,
01522     3891,  3956,  3965,  3976,  3983,  3993,  4001,  4011,  4020,  4031,
01523     4038,  4056,  4065,  4075,  4084,  4095,  4102,  4113,  4120,  4135,
01524     4142,  4153,  4160,  4171,  4178,  4207,  4209,  4208,  4225,  4231,
01525     4236,  4224,  4255,  4263,  4271,  4279,  4282,  4293,  4294,  4295,
01526     4296,  4299,  4310,  4311,  4321,  4322,  4323,  4324,  4327,  4328,
01527     4329,  4330,  4331,  4334,  4335,  4336,  4337,  4338,  4339,  4340,
01528     4343,  4356,  4366,  4374,  4384,  4385,  4388,  4397,  4396,  4405,
01529     4417,  4427,  4427,  4440,  4444,  4448,  4452,  4458,  4463,  4468,
01530     4472,  4476,  4480,  4484,  4488,  4492,  4496,  4500,  4504,  4508,
01531     4512,  4516,  4520,  4525,  4531,  4540,  4549,  4558,  4569,  4570,
01532     4577,  4586,  4605,  4612,  4626,  4633,  4642,  4653,  4662,  4673,
01533     4681,  4698,  4706,  4722,  4723,  4726,  4731,  4737,  4749,  4761,
01534     4769,  4785,  4793,  4809,  4810,  4813,  4826,  4837,  4838,  4841,
01535     4858,  4862,  4872,  4882,  4882,  4911,  4912,  4922,  4929,  4939,
01536     4951,  4959,  4971,  4972,  4973,  4976,  4977,  4978,  4979,  4982,
01537     4983,  4984,  4987,  4992,  4999,  5000,  5003,  5004,  5007,  5010,
01538     5013,  5014,  5015,  5018,  5019,  5022,  5023,  5027
01539 };
01540 #endif
01541 
01542 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01543 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01544    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01545 static const char *const yytname[] =
01546 {
01547   "\"end-of-input\"", "error", "$undefined", "keyword_class",
01548   "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
01549   "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
01550   "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
01551   "keyword_case", "keyword_when", "keyword_while", "keyword_until",
01552   "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
01553   "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
01554   "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
01555   "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
01556   "keyword_true", "keyword_false", "keyword_and", "keyword_or",
01557   "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
01558   "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
01559   "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
01560   "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
01561   "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tRATIONAL",
01562   "tIMAGINARY", "tSTRING_CONTENT", "tCHAR", "tNTH_REF", "tBACK_REF",
01563   "tREGEXP_END", "\"unary+\"", "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"",
01564   "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"",
01565   "\"!~\"", "\"..\"", "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"",
01566   "\"::\"", "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"",
01567   "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"",
01568   "\"**arg\"", "\"&\"", "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG",
01569   "tREGEXP_BEG", "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG",
01570   "tQSYMBOLS_BEG", "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR",
01571   "tSTRING_END", "tLAMBEG", "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'",
01572   "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM",
01573   "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','", "'`'",
01574   "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program", "$@1",
01575   "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt", "compstmt",
01576   "stmts", "stmt_or_begin", "$@3", "stmt", "$@4", "command_asgn", "expr",
01577   "expr_value", "command_call", "block_command", "cmd_brace_block", "@5",
01578   "fcall", "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item",
01579   "mlhs_head", "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname",
01580   "fsym", "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
01581   "arg_value", "aref_args", "paren_args", "opt_paren_args",
01582   "opt_call_args", "call_args", "command_args", "@8", "block_arg",
01583   "opt_block_arg", "args", "mrhs_arg", "mrhs", "primary", "@9", "$@10",
01584   "$@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19",
01585   "@20", "@21", "@22", "@23", "@24", "$@25", "$@26", "primary_value",
01586   "k_begin", "k_if", "k_unless", "k_while", "k_until", "k_case", "k_for",
01587   "k_class", "k_module", "k_def", "k_end", "then", "do", "if_tail",
01588   "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
01589   "block_args_tail", "opt_block_args_tail", "block_param",
01590   "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar",
01591   "lambda", "@27", "@28", "@29", "@30", "f_larglist", "lambda_body",
01592   "do_block", "@31", "block_call", "method_call", "@32", "@33", "@34",
01593   "@35", "brace_block", "@36", "@37", "case_body", "cases", "opt_rescue",
01594   "exc_list", "exc_var", "opt_ensure", "literal", "strings", "string",
01595   "string1", "xstring", "regexp", "words", "word_list", "word", "symbols",
01596   "symbol_list", "qwords", "qsymbols", "qword_list", "qsym_list",
01597   "string_contents", "xstring_contents", "regexp_contents",
01598   "string_content", "@38", "@39", "@40", "@41", "string_dvar", "symbol",
01599   "sym", "dsym", "numeric", "simple_numeric", "user_variable",
01600   "keyword_variable", "var_ref", "var_lhs", "backref", "superclass",
01601   "$@42", "f_arglist", "@43", "args_tail", "opt_args_tail", "f_args",
01602   "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_label", "f_kw",
01603   "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
01604   "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
01605   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
01606   "singleton", "$@44", "assoc_list", "assocs", "assoc", "operation",
01607   "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
01608   "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01609 };
01610 #endif
01611 
01612 # ifdef YYPRINT
01613 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01614    token YYLEX-NUM.  */
01615 static const yytype_uint16 yytoknum[] =
01616 {
01617        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01618      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01619      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01620      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01621      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01622      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01623      315,   316,   317,   318,   319,   320,   321,   322,   130,   131,
01624      132,   134,   139,   140,   141,   138,   137,   323,   324,   142,
01625      143,   128,   129,   144,   145,   135,   136,   325,   326,   327,
01626      328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
01627      338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
01628      348,   349,   350,   351,   352,    61,    63,    58,    62,    60,
01629      124,    94,    38,    43,    45,    42,    47,    37,   353,    33,
01630      126,   354,   123,   125,    91,    46,    44,    96,    40,    41,
01631       93,    59,    32,    10
01632 };
01633 # endif
01634 
01635 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01636 static const yytype_uint16 yyr1[] =
01637 {
01638        0,   144,   146,   145,   147,   148,   148,   148,   148,   149,
01639      150,   149,   151,   152,   153,   153,   153,   153,   154,   155,
01640      154,   157,   156,   156,   156,   156,   156,   156,   156,   156,
01641      156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
01642      156,   156,   156,   156,   156,   158,   158,   159,   159,   159,
01643      159,   159,   159,   160,   161,   161,   162,   162,   164,   163,
01644      165,   166,   166,   166,   166,   166,   166,   166,   166,   166,
01645      166,   166,   167,   167,   168,   168,   169,   169,   169,   169,
01646      169,   169,   169,   169,   169,   169,   170,   170,   171,   171,
01647      172,   172,   173,   173,   173,   173,   173,   173,   173,   173,
01648      173,   174,   174,   174,   174,   174,   174,   174,   174,   174,
01649      175,   175,   176,   176,   176,   177,   177,   177,   177,   177,
01650      178,   178,   179,   179,   180,   181,   180,   182,   182,   182,
01651      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01652      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01653      182,   182,   182,   182,   182,   182,   182,   183,   183,   183,
01654      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01655      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01656      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01657      183,   183,   183,   183,   183,   183,   183,   183,   184,   184,
01658      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01659      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01660      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01661      184,   184,   184,   184,   184,   184,   184,   184,   184,   185,
01662      184,   184,   184,   186,   187,   187,   187,   187,   188,   189,
01663      189,   190,   190,   190,   190,   190,   191,   191,   191,   191,
01664      191,   193,   192,   194,   195,   195,   196,   196,   196,   196,
01665      197,   197,   198,   198,   198,   199,   199,   199,   199,   199,
01666      199,   199,   199,   199,   199,   199,   200,   199,   201,   199,
01667      202,   203,   199,   199,   199,   199,   199,   199,   199,   199,
01668      199,   199,   204,   199,   199,   199,   199,   199,   199,   199,
01669      199,   199,   205,   206,   199,   207,   208,   199,   199,   199,
01670      209,   210,   199,   211,   199,   212,   213,   199,   214,   199,
01671      215,   199,   216,   217,   199,   199,   199,   199,   199,   218,
01672      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
01673      229,   230,   230,   230,   231,   231,   232,   232,   233,   233,
01674      234,   234,   235,   235,   236,   236,   237,   237,   237,   237,
01675      237,   237,   237,   237,   237,   238,   238,   238,   238,   239,
01676      239,   240,   240,   240,   240,   240,   240,   240,   240,   240,
01677      240,   240,   240,   240,   240,   240,   241,   241,   242,   242,
01678      242,   243,   243,   244,   244,   245,   245,   247,   248,   249,
01679      250,   246,   251,   251,   252,   252,   254,   253,   255,   255,
01680      255,   255,   256,   257,   256,   258,   256,   256,   259,   256,
01681      260,   256,   256,   256,   256,   262,   261,   263,   261,   264,
01682      265,   265,   266,   266,   267,   267,   267,   268,   268,   269,
01683      269,   270,   270,   270,   271,   272,   272,   272,   273,   274,
01684      275,   276,   276,   277,   277,   278,   278,   279,   279,   280,
01685      280,   281,   281,   282,   282,   283,   283,   284,   284,   285,
01686      285,   286,   286,   287,   287,   288,   289,   288,   290,   291,
01687      292,   288,   293,   293,   293,   293,   294,   295,   295,   295,
01688      295,   296,   297,   297,   298,   298,   298,   298,   299,   299,
01689      299,   299,   299,   300,   300,   300,   300,   300,   300,   300,
01690      301,   301,   302,   302,   303,   303,   304,   305,   304,   304,
01691      306,   307,   306,   308,   308,   308,   308,   309,   309,   310,
01692      310,   310,   310,   310,   310,   310,   310,   310,   310,   310,
01693      310,   310,   310,   310,   311,   311,   311,   311,   312,   312,
01694      313,   313,   314,   314,   315,   316,   316,   317,   317,   318,
01695      318,   319,   319,   320,   320,   321,   321,   322,   323,   324,
01696      324,   325,   325,   326,   326,   327,   327,   328,   328,   329,
01697      330,   330,   331,   332,   331,   333,   333,   334,   334,   335,
01698      335,   335,   336,   336,   336,   337,   337,   337,   337,   338,
01699      338,   338,   339,   339,   340,   340,   341,   341,   342,   343,
01700      344,   344,   344,   345,   345,   346,   346,   347
01701 };
01702 
01703 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01704 static const yytype_uint8 yyr2[] =
01705 {
01706        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01707        0,     5,     4,     2,     1,     1,     3,     2,     1,     0,
01708        5,     0,     4,     3,     3,     3,     2,     3,     3,     3,
01709        3,     3,     4,     1,     3,     3,     6,     5,     5,     5,
01710        5,     3,     3,     3,     1,     3,     3,     1,     3,     3,
01711        3,     2,     1,     1,     1,     1,     1,     4,     0,     5,
01712        1,     2,     3,     4,     5,     4,     5,     2,     2,     2,
01713        2,     2,     1,     3,     1,     3,     1,     2,     3,     5,
01714        2,     4,     2,     4,     1,     3,     1,     3,     2,     3,
01715        1,     3,     1,     1,     4,     3,     3,     3,     3,     2,
01716        1,     1,     1,     4,     3,     3,     3,     3,     2,     1,
01717        1,     1,     2,     1,     3,     1,     1,     1,     1,     1,
01718        1,     1,     1,     1,     1,     0,     4,     1,     1,     1,
01719        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01720        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01721        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01722        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01723        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01724        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01725        1,     1,     1,     1,     1,     1,     1,     1,     3,     5,
01726        3,     5,     6,     5,     5,     5,     5,     4,     3,     3,
01727        3,     3,     3,     3,     3,     3,     3,     4,     2,     2,
01728        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
01729        3,     3,     3,     2,     2,     3,     3,     3,     3,     0,
01730        4,     6,     1,     1,     1,     2,     4,     2,     3,     1,
01731        1,     1,     1,     2,     4,     2,     1,     2,     2,     4,
01732        1,     0,     2,     2,     2,     1,     1,     2,     3,     4,
01733        1,     1,     3,     4,     2,     1,     1,     1,     1,     1,
01734        1,     1,     1,     1,     1,     1,     0,     4,     0,     3,
01735        0,     0,     5,     3,     3,     2,     3,     3,     1,     4,
01736        3,     1,     0,     6,     4,     3,     2,     1,     2,     2,
01737        6,     6,     0,     0,     7,     0,     0,     7,     5,     4,
01738        0,     0,     9,     0,     6,     0,     0,     8,     0,     5,
01739        0,     6,     0,     0,     9,     1,     1,     1,     1,     1,
01740        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01741        1,     1,     1,     2,     1,     1,     1,     5,     1,     2,
01742        1,     1,     1,     3,     1,     3,     1,     4,     6,     3,
01743        5,     2,     4,     1,     3,     4,     2,     2,     1,     2,
01744        0,     6,     8,     4,     6,     4,     2,     6,     2,     4,
01745        6,     2,     4,     2,     4,     1,     1,     1,     3,     1,
01746        4,     1,     4,     1,     3,     1,     1,     0,     0,     0,
01747        0,     6,     4,     1,     3,     3,     0,     5,     2,     4,
01748        5,     5,     2,     0,     5,     0,     5,     3,     0,     4,
01749        0,     4,     2,     1,     4,     0,     5,     0,     5,     5,
01750        1,     1,     6,     1,     1,     1,     1,     2,     1,     2,
01751        1,     1,     1,     1,     1,     1,     1,     2,     3,     3,
01752        3,     3,     3,     0,     3,     1,     2,     3,     3,     0,
01753        3,     3,     3,     3,     3,     0,     3,     0,     3,     0,
01754        2,     0,     2,     0,     2,     1,     0,     3,     0,     0,
01755        0,     6,     1,     1,     1,     1,     2,     1,     1,     1,
01756        1,     3,     1,     2,     1,     1,     1,     1,     1,     1,
01757        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01758        1,     1,     1,     1,     1,     1,     1,     0,     4,     2,
01759        3,     0,     3,     4,     2,     2,     1,     2,     0,     6,
01760        8,     4,     6,     4,     6,     2,     4,     6,     2,     4,
01761        2,     4,     1,     0,     1,     1,     1,     1,     1,     1,
01762        1,     3,     1,     3,     1,     2,     1,     2,     1,     1,
01763        3,     1,     3,     1,     1,     2,     1,     3,     3,     1,
01764        3,     1,     3,     1,     1,     2,     1,     1,     1,     2,
01765        2,     1,     1,     0,     4,     1,     2,     1,     3,     3,
01766        2,     2,     1,     1,     1,     1,     1,     1,     1,     1,
01767        1,     1,     1,     1,     0,     1,     0,     1,     2,     2,
01768        0,     1,     1,     1,     1,     1,     2,     0
01769 };
01770 
01771 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
01772    Performed when YYTABLE doesn't specify something else to do.  Zero
01773    means the default is an error.  */
01774 static const yytype_uint16 yydefact[] =
01775 {
01776        2,     0,     0,     1,     0,   347,   348,   349,     0,   340,
01777      341,   342,   345,   343,   344,   346,   335,   336,   337,   338,
01778      298,   261,   261,   514,   513,   515,   516,   616,     0,   616,
01779       10,     0,   518,   517,   519,   602,   604,   510,   509,   603,
01780      512,   504,   505,   506,   507,   455,   524,   525,     0,     0,
01781        0,     0,   290,   627,   627,    84,   407,   481,   479,   481,
01782      483,   463,   475,   469,   477,     0,     0,     0,     3,   614,
01783        6,     9,    33,    44,    47,    55,   261,    54,     0,    72,
01784        0,    76,    86,     0,    52,   242,     0,   286,     0,     0,
01785      312,   315,   614,     0,     0,     0,     0,    56,   307,   275,
01786      276,   454,   456,   277,   278,   279,   281,   280,   282,   452,
01787      453,   451,   502,   520,   521,   283,     0,   284,    60,     5,
01788        8,   167,   178,   168,   191,   164,   184,   174,   173,   194,
01789      195,   189,   172,   171,   166,   192,   196,   197,   176,   165,
01790      179,   183,   185,   177,   170,   186,   193,   188,   187,   180,
01791      190,   175,   163,   182,   181,   162,   169,   160,   161,   157,
01792      158,   159,   115,   117,   116,   152,   153,   148,   130,   131,
01793      132,   139,   136,   138,   133,   134,   154,   155,   140,   141,
01794      145,   149,   135,   137,   127,   128,   129,   142,   143,   144,
01795      146,   147,   150,   151,   156,   120,   122,   124,    26,   118,
01796      119,   121,   123,     0,     0,     0,     0,     0,     0,     0,
01797        0,   256,     0,   243,   266,    70,   260,   627,     0,   520,
01798      521,     0,   284,   627,   597,    71,    69,   616,    68,     0,
01799      627,   432,    67,   616,   617,     0,     0,    21,   239,     0,
01800        0,   335,   336,   298,   301,   433,     0,   218,     0,   219,
01801      295,     0,    19,     0,     0,   614,    15,    18,   616,    74,
01802       14,   616,     0,     0,   620,   620,   244,     0,     0,   620,
01803      595,   616,     0,     0,     0,    82,   339,     0,    92,    93,
01804      100,   309,   408,   499,   498,   500,   497,     0,   496,     0,
01805        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01806      503,    51,   233,   234,   623,   624,     4,   625,   615,     0,
01807        0,     0,     0,     0,     0,     0,   437,   435,   422,    61,
01808      306,   416,   418,     0,    88,     0,    80,    77,     0,     0,
01809        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01810        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01811        0,     0,     0,     0,     0,   430,   627,   428,     0,    53,
01812        0,     0,     0,     0,   614,     0,   615,     0,   361,   360,
01813        0,     0,   520,   521,   284,   110,   111,     0,     0,   113,
01814        0,     0,   520,   521,   284,   328,   187,   180,   190,   175,
01815      157,   158,   159,   115,   116,   593,   330,   592,     0,   613,
01816      612,     0,   308,   457,     0,     0,   125,   600,   295,   267,
01817      601,   263,     0,     0,     0,   257,   265,   430,   627,   428,
01818        0,     0,     0,   258,   616,     0,   300,   262,   616,   252,
01819      627,   627,   251,   616,   305,    50,    23,    25,    24,     0,
01820      302,     0,     0,     0,   430,   428,     0,    17,     0,   616,
01821      293,    13,   615,    73,   289,   291,   296,   622,   621,   245,
01822      622,   247,   297,   596,     0,    99,   503,    90,    85,     0,
01823      430,   627,   428,   553,   485,   488,   486,   501,   482,   458,
01824      480,   459,   460,   484,   461,   462,     0,   465,   471,     0,
01825      472,   467,   468,     0,   473,     0,   474,     0,   626,     7,
01826       27,    28,    29,    30,    31,    48,    49,   627,   627,    58,
01827       62,   627,     0,    34,   271,     0,    43,   270,   616,     0,
01828       78,    89,    46,    45,     0,   198,   266,    42,   216,   223,
01829      228,   229,   230,   225,   227,   237,   238,   231,   232,   209,
01830      210,   235,   236,   616,   224,   226,   220,   221,   222,   211,
01831      212,   213,   214,   215,   605,   607,   606,   608,     0,   261,
01832      427,   616,   605,   607,   606,   608,     0,   261,     0,   627,
01833      352,     0,   351,     0,     0,     0,     0,     0,     0,   295,
01834      430,   627,   428,   320,   325,   110,   111,   112,     0,   527,
01835      323,   526,   430,   627,   428,     0,     0,   531,   332,   605,
01836      606,   261,    35,   200,    41,   208,     0,   198,   599,     0,
01837      268,   264,   627,   605,   606,   616,   605,   606,   598,   299,
01838      618,   248,   253,   255,   304,    22,     0,   240,     0,    32,
01839      425,   423,   207,     0,    75,    16,   616,   620,     0,    83,
01840       96,    98,   616,   605,   606,   559,   556,   555,   554,   557,
01841      564,   573,     0,   584,   574,   588,   587,   583,   553,   409,
01842      552,   413,   558,   560,   562,   538,   566,   571,   627,   576,
01843      627,   581,   538,   586,   538,     0,   536,   489,     0,   464,
01844      466,   476,   470,   478,   217,   399,   616,     0,   397,   396,
01845        0,   627,     0,   274,     0,    87,    81,     0,     0,     0,
01846        0,     0,     0,   431,    65,     0,     0,   434,     0,     0,
01847      429,    63,   627,   350,   287,   627,   627,   443,   627,   353,
01848      627,   355,   313,   354,   316,     0,     0,   319,   609,   294,
01849      616,   605,   606,     0,     0,   529,     0,     0,   110,   111,
01850      114,   616,     0,   616,   553,     0,   553,     0,   250,   419,
01851       57,   249,     0,   126,   269,   259,     0,     0,   434,     0,
01852        0,   627,   616,    11,     0,   292,   246,    91,    94,     0,
01853      373,   364,   366,   616,   362,   616,   410,     0,     0,   545,
01854      565,     0,   534,   591,   575,     0,   535,     0,   548,   585,
01855        0,   550,   589,   490,   492,   493,   494,   487,   495,   395,
01856      616,     0,   560,   380,   568,   569,   627,   627,   579,   380,
01857      380,   378,   401,     0,     0,     0,     0,     0,   272,    79,
01858      199,     0,    40,   205,    39,   206,    66,   426,   619,     0,
01859       37,   203,    38,   204,    64,   424,   444,   445,   627,   446,
01860        0,   627,   358,     0,     0,   356,     0,     0,     0,   318,
01861        0,     0,   434,     0,   326,     0,     0,   434,   329,   594,
01862      616,     0,     0,   333,   420,   421,   201,     0,   254,   303,
01863       20,   616,     0,   371,     0,   561,     0,     0,   577,   537,
01864      563,   538,   538,   572,   627,   590,   538,   582,   538,   560,
01865      538,     0,     0,   398,     0,   386,   388,     0,   567,     0,
01866      376,   377,     0,   391,     0,   393,     0,   438,   436,     0,
01867      417,   273,   241,    36,   202,     0,     0,   448,   359,     0,
01868       12,   450,     0,   310,   311,     0,     0,   268,   627,   321,
01869        0,   528,   324,   530,   331,   532,   531,   363,   374,     0,
01870      369,   365,   412,     0,     0,   411,     0,   541,     0,   543,
01871      533,     0,   549,     0,   546,   551,     0,   400,   578,   379,
01872      380,   380,   295,   430,   570,   627,   380,   580,   380,   380,
01873      405,   616,   403,   406,    59,     0,   447,     0,   101,   102,
01874      109,     0,   449,     0,   314,   317,   440,   441,   439,     0,
01875        0,     0,     0,   372,     0,   367,     0,     0,   538,   538,
01876      538,   538,   491,     0,   383,     0,   385,   609,   294,   375,
01877        0,   392,     0,   389,   394,     0,   402,   108,   430,   627,
01878      428,   627,   627,     0,   327,     0,   370,     0,   415,   414,
01879      542,     0,   539,   544,   547,   380,   380,   380,   380,   404,
01880      609,   107,   616,   605,   606,   442,   357,   322,   334,   368,
01881      538,   384,     0,   381,   387,   390,   434,   540,   380,   382
01882 };
01883 
01884 /* YYDEFGOTO[NTERM-NUM].  */
01885 static const yytype_int16 yydefgoto[] =
01886 {
01887       -1,     1,     2,    68,    69,    70,   239,   568,   569,   255,
01888      256,   448,   257,   439,    72,    73,   360,    74,    75,   510,
01889      691,   246,    77,    78,   258,    79,    80,    81,   468,    82,
01890      212,   379,   380,   195,   196,   197,   198,   606,   557,   200,
01891       84,   441,   214,   263,   231,   749,   428,   429,   228,   229,
01892      216,   415,   430,   516,   517,    85,   358,   261,   262,   636,
01893      626,   362,   847,   363,   848,   733,   989,   737,   734,   930,
01894      595,   597,   747,   936,   248,    87,    88,    89,    90,    91,
01895       92,    93,    94,    95,    96,   714,   571,   722,   844,   845,
01896      371,   771,   772,   773,   959,   896,   800,   687,   688,   801,
01897      971,   972,   281,   282,   473,   776,   877,   659,   945,   322,
01898      511,    97,    98,   712,   705,   566,   558,   320,   508,   507,
01899      578,   988,   716,   838,   916,   920,    99,   100,   101,   102,
01900      103,   104,   105,   293,   486,   106,   297,   107,   108,   295,
01901      299,   289,   287,   291,   478,   678,   677,   793,   891,   797,
01902      109,   288,   110,   111,   112,   219,   220,   115,   221,   222,
01903      590,   736,   745,   746,   879,   779,   661,   662,   889,   664,
01904      665,   666,   667,   805,   806,   668,   669,   670,   671,   808,
01905      809,   672,   673,   674,   675,   676,   782,   398,   596,   268,
01906      431,   224,   118,   630,   560,   401,   306,   425,   426,   707,
01907      459,   572,   366,   260
01908 };
01909 
01910 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01911    STATE-NUM.  */
01912 #define YYPACT_NINF -813
01913 static const yytype_int16 yypact[] =
01914 {
01915     -813,   111,  2847,  -813,  7396,  -813,  -813,  -813,  6911,  -813,
01916     -813,  -813,  -813,  -813,  -813,  -813,  7511,  7511,  -813,  -813,
01917     7511,  4052,  3641,  -813,  -813,  -813,  -813,   -21,  6776,   -35,
01918     -813,   -12,  -813,  -813,  -813,  2956,  3778,  -813,  -813,  3093,
01919     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  8891,  8891,
01920       72,  5120,    30,  7856,  8201,  7174,  -813,  6641,  -813,  -813,
01921     -813,    41,    84,    95,   136,  1005,  9006,  8891,  -813,   230,
01922     -813,  1060,  -813,   324,  -813,  -813,   142,   104,   168,  -813,
01923      192,  9236,  -813,   201,  3209,    40,   271,  -813,  9121,  9121,
01924     -813,  -813,  6021,  9347,  9458,  9569,  6505,    22,    97,  -813,
01925     -813,    56,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01926     -813,  -813,  -813,    27,   472,  -813,   243,   651,  -813,  -813,
01927     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01928     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01929     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01930     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01931     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01932     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01933     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01934     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,   207,  -813,
01935     -813,  -813,  -813,   219,  8891,   330,  5261,  8891,  8891,  8891,
01936     8891,  -813,   285,  3209,   343,  -813,  -813,   278,   301,    14,
01937      233,   348,   244,   284,  -813,  -813,  -813,  5906,  -813,  7511,
01938     7511,  -813,  -813,  6136,  -813,  9121,   775,  -813,   314,   354,
01939     5402,  -813,  -813,  -813,   342,   364,   142,  -813,   435,   422,
01940      687,  7626,  -813,  5120,   369,   230,  -813,  1060,   -35,   408,
01941     -813,   -35,  9121,   403,   329,   331,  -813,   343,   420,   331,
01942     -813,   -35,   510,  1005,  9680,   432,  -813,   520,   565,   590,
01943      604,  -813,  -813,  -813,  -813,  -813,  -813,   502,  -813,   513,
01944      523,   416,   465,   658,   469,    33,   476,   685,   488,    44,
01945      514,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  6251,  9121,
01946     9121,  9121,  9121,  7626,  9121,  9121,  -813,  -813,  -813,   522,
01947     -813,  -813,  -813,  8316,  -813,  5120,  7285,   528,  8316,  8891,
01948     8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,
01949     8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,
01950     8891,  8891,  8891,  8891,  8891,  9963,  7511, 10042,  4467,   324,
01951      112,   112,  9121,  9121,   230,   642,   530,   618,  -813,  -813,
01952      620,   655,    94,   108,   121,   312,   495,  9121,   139,  -813,
01953      212,   644,  -813,  -813,  -813,  -813,    26,   292,   384,   458,
01954      467,   532,   562,   570,   582,  -813,  -813,  -813,    22,  -813,
01955     -813, 10121,  -813,  -813,  9006,  9006,  -813,  -813,   286,  -813,
01956     -813,  -813,  8891,  8891,  7741,  -813,  -813, 10200,  7511, 10279,
01957     8891,  8891,  7971,  -813,   -35,   544,  -813,  -813,   -35,  -813,
01958      550,   551,  -813,    93,  -813,  -813,  -813,  -813,  -813,  6911,
01959     -813,  8891,  5535,   576, 10200, 10279,  8891,  1060,   558,   -35,
01960     -813,  -813,  6366,   559,  -813,   324,  -813,  8086,  -813,  -813,
01961     8201,  -813,  -813,  -813,   314,   648,  -813,  -813,   597,  9680,
01962    10358,  7511, 10437,  1164,  -813,  -813,  -813,  -813,  -813,  -813,
01963     -813,  -813,  -813,  -813,  -813,  -813,   346,  -813,  -813,   556,
01964     -813,  -813,  -813,   347,  -813,   584,  -813,  8891,  -813,  -813,
01965     -813,  -813,  -813,  -813,  -813,  -813,  -813,    19,    19,  -813,
01966     -813,    19,  8891,  -813,   607,   608,  -813,  -813,   -35,  9680,
01967      610,  -813,  -813,  -813,   636,  2008,  -813,  -813,   422,  2309,
01968     2309,  2309,  2309,  1315,  1315,  2621,  1681,  2309,  2309,  3346,
01969     3346,   425,   425, 10940,  1315,  1315,   795,   795,   887,   337,
01970      337,   422,   422,   422,  4189,  3230,  4326,  3367,   364,   623,
01971     -813,   -35,   688,  -813,   706,  -813,   364,  3915,   755,   763,
01972     -813,  4608,   771,  4890,    65,    65,   642,  8431,   755,   135,
01973    10516,  7511, 10595,  -813,   324,  -813,   648,  -813,   230,  -813,
01974     -813,  -813, 10674,  7511, 10121,  4467,  9121,   647,  -813,  -813,
01975     -813,  1256,  -813,  2935,  -813,  3209,  6911,  3072,  -813,  8891,
01976      343,  -813,   284,  2529,  3504,   -35,   381,   526,  -813,  -813,
01977     -813,  -813,  7741,  7971,  -813,  -813,  9121,  3209,   657,  -813,
01978     -813,  -813,  3209,  5535,   262,  -813,   -35,   331,  9680,   597,
01979      505,   394,   -35,   276,   351,  -813,  -813,  -813,  -813,  -813,
01980     -813,  -813,   950,  -813,  -813,  -813,  -813,  -813,  1220,  -813,
01981     -813,  -813,  -813,   678,  -813,   674,  8891,  -813,   676,   768,
01982      692,  -813,   701,   786,   707,   800,  -813,  -813,   885,  -813,
01983     -813,  -813,  -813,  -813,   422,  -813,  1115,  5676,  -813,  -813,
01984     5402,    19,  5676,   718,  8546,  -813,   597,  9680,  9006,  8891,
01985      739,  9006,  9006,  -813,   522,   364,   721,   717,  9006,  9006,
01986     -813,   522,   364,  -813,  -813,  8661,   842,  -813,   664,  -813,
01987      842,  -813,  -813,  -813,  -813,   755,    71,  -813,    66,    80,
01988      -35,   141,   162,  9121,   230,  -813,  9121,  4467,   505,   394,
01989     -813,   -35,   755,    93,  1220,  4467,  1220,  7046,  -813,    97,
01990      104,  -813,  8891,  -813,  -813,  -813,  8891,  8891,   557,  8891,
01991     8891,   728,    93,  -813,   733,  -813,  -813,  -813,   366,   950,
01992      459,  -813,   732,   -35,  -813,   -35,  -813,  8891,  1220,  -813,
01993     -813,   586,  -813,  -813,  -813,    42,  -813,  1220,  -813,  -813,
01994     1307,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01995      -35,   751,   757,   737,  9791,  -813,   740,   692,  -813,   742,
01996      747,  -813,   734,   877,   758,  5402,   878,  8891,   761,   597,
01997     3209,  8891,  -813,  3209,  -813,  3209,  -813,  -813,  -813,  9006,
01998     -813,  3209,  -813,  3209,  -813,  -813,   607,  -813,   804,  -813,
01999     5005,   890,  -813,  9121,   755,  -813,   755,  5676,  5676,  -813,
02000     8776,  4749,   288,    65,  -813,   230,   755,  -813,  -813,  -813,
02001      -35,   755,   230,  -813,  -813,  -813,  3209,  8891,  7971,  -813,
02002     -813,   -35,   873,   769,  1000,  -813,   765,    73,  -813,  -813,
02003     -813,   772,   773,  -813,   692,  -813,   776,  -813,   777,  -813,
02004      776,  5791,   787,  -813,  9791,  1220,  -813,   855,   673,   586,
02005     -813,  -813,  1220,  -813,  1307,  -813,  1016,  -813,  -813,   783,
02006     -813,   788,  3209,  -813,  3209,  9902,   112,  -813,  -813,  5676,
02007     -813,  -813,   112,  -813,  -813,   755,   755,  -813,   542,  -813,
02008     4467,  -813,  -813,  -813,  -813,  -813,   647,  -813,   796,   873,
02009      484,  -813,  -813,  5676,  5402,  -813,  1220,  -813,  1307,  -813,
02010     -813,  1307,  -813,  1307,  -813,  -813,   813,  -813,   673,  -813,
02011      799,   801,  -813, 10753,  -813,   692,   802,  -813,   808,   802,
02012     -813,   367,  -813,  -813,  -813,   875,  -813,   681,   565,   590,
02013      604,  4467,  -813,  4608,  -813,  -813,  -813,  -813,  -813,  5676,
02014      755,  4467,   873,   796,   873,   811,   923,   815,   776,   817,
02015      776,   776,  -813,  1220,  -813,  1307,  -813,   818,   820,  -813,
02016     1307,  -813,  1307,  -813,  -813,  1016,  -813,   648, 10832,  7511,
02017    10911,   763,   664,   755,  -813,   755,   796,   873,  -813,  -813,
02018     -813,  1307,  -813,  -813,  -813,   802,   819,   802,   802,  -813,
02019      169,   394,   -35,   127,   146,  -813,  -813,  -813,  -813,   796,
02020      776,  -813,  1307,  -813,  -813,  -813,   180,  -813,   802,  -813
02021 };
02022 
02023 /* YYPGOTO[NTERM-NUM].  */
02024 static const yytype_int16 yypgoto[] =
02025 {
02026     -813,  -813,  -813,  -361,  -813,    29,  -813,  -540,   -29,  -813,
02027      515,  -813,    43,  -813,  -301,   -63,   -71,    21,  -813,  -174,
02028     -813,   797,   -10,   869,  -158,    16,   -76,  -813,  -395,     8,
02029     1783,  -325,   870,   -53,  -813,    -5,  -813,  -813,     3,  -813,
02030     1127,  -813,   -19,  -813,   -67,   257,  -317,   118,    -3,  -813,
02031     -390,  -181,    -4,  -813,  -313,   -15,  -813,  -813,  -813,  -813,
02032     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
02033     -813,  -813,  -813,  -813,    55,  -813,  -813,  -813,  -813,  -813,
02034     -813,  -813,  -813,  -813,  -813,  -541,  -344,  -527,   -45,  -631,
02035     -813,  -770,  -784,   210,   290,   172,  -813,  -425,  -813,  -663,
02036     -813,   -31,  -813,  -813,  -813,  -813,  -813,  -813,  -813,   236,
02037     -813,  -813,  -813,  -813,  -813,  -813,  -813,   -96,  -813,  -813,
02038     -556,  -813,   -34,  -813,  -813,  -813,  -813,  -813,  -813,   889,
02039     -813,  -813,  -813,  -813,   691,  -813,  -813,  -813,  -813,  -813,
02040     -813,  -813,   933,  -813,   -97,  -813,  -813,  -813,  -813,  -813,
02041        0,  -813,     6,  -813,   -11,  1321,  1524,   897,  1945,  1604,
02042     -813,  -813,    58,  -813,  -404,  -154,  -323,  -812,   123,  -717,
02043       87,    76,   215,   101,  -813,  -813,  -813,   -69,  -711,  -629,
02044      106,   237,  -813,  -616,  -813,   -44,  -626,  -813,  -813,  -813,
02045       98,  -392,  -813,  -319,  -813,   624,   -46,   -26,  -168,  -565,
02046     -207,   -28,   -13,    -2
02047 };
02048 
02049 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
02050    positive, shift that token.  If negative, reduce the rule which
02051    number is the opposite.  If YYTABLE_NINF, syntax error.  */
02052 #define YYTABLE_NINF -628
02053 static const yytype_int16 yytable[] =
02054 {
02055      119,   235,   402,   238,   286,   327,   211,   211,   201,   318,
02056      211,   199,   217,   217,   202,   527,   217,   573,   361,   232,
02057      725,   364,   254,   237,   611,   359,   359,   522,   201,   359,
02058      618,   199,   611,   120,   202,   267,   559,   727,   567,   561,
02059      276,   307,   423,   396,   786,    71,   365,    71,   724,   264,
02060      758,   266,   270,   587,   300,   742,   308,    86,   461,    86,
02061      199,   880,   463,   275,   307,   434,   276,   259,   618,   660,
02062      810,   218,   218,   319,   639,   218,   887,   768,   276,   276,
02063      276,   628,   601,   690,   570,   841,   692,   301,   938,   846,
02064      453,  -105,   721,   454,   973,   449,   489,   685,   559,   199,
02065      567,   615,   943,  -522,   941,  -107,    86,   495,   234,   399,
02066      277,     3,   876,  -514,   223,   223,  -522,   233,   223,  -101,
02067      240,   218,   234,   316,   696,   570,   631,  -339,   250,  -101,
02068      314,   315,   321,  -102,   215,   225,   277,   892,   226,   686,
02069     -104,   655,  -101,   218,   218,   490,  -109,   218,   370,   381,
02070      381,   265,   269,   631,   642,   993,   496,   400,    58,  -106,
02071     -108,  -514,   882,   -92,   656,   852,  -104,   518,   316,  -288,
02072      433,   888,   435,  -288,  -339,  -339,   857,   254,   880,   318,
02073      900,   901,  -105,   292,   849,   407,   944,  -106,   409,   410,
02074      411,   585,   480,  -103,   483,   586,   487,   856,   467,   455,
02075      487,   858,   -96,   973,  -605,   861,   304,   850,   305,   451,
02076     1026,   443,   304,   588,   305,   416,   -98,   211,  -606,   211,
02077      211,   416,   941,   217,   254,   217,   294,   307,   432,   317,
02078      -92,   618,   611,   611,   880,   887,   234,   296,   500,   501,
02079      502,   503,   452,  1049,   -93,   464,   359,   359,   359,   359,
02080      423,   505,   506,   304,   660,   305,   619,  -100,   950,   276,
02081      621,    86,   466,   631,   730,   624,   815,   740,  -104,   259,
02082     -104,   -99,   764,   967,   317,   631,   741,   -95,   298,   961,
02083      230,   634,   218,   323,   218,   218,   968,  -106,   218,  -106,
02084      218,   574,   575,   880,   447,    86,   254,   986,   -97,   359,
02085      359,   -95,   819,   923,   514,   924,    86,  -605,    86,   526,
02086     -105,   276,  -105,  -103,   584,   932,   328,   218,   576,   515,
02087      934,  -103,  -523,  -103,   515,   223,   929,   223,   324,   277,
02088      999,   589,   404,   421,   520,   775,   307,   499,  -602,  1009,
02089      660,   259,   660,   406,   513,   424,   211,   427,  -102,   523,
02090      695,    71,   591,   304,   432,   305,   504,   233,   355,  -109,
02091      565,   314,   315,    86,   218,   218,   218,   218,    86,   218,
02092      218,   304,   987,   305,   967,   446,   -97,   -73,   218,  -513,
02093       86,   277,   851,   218,   984,   985,   408,  1036,   417,   680,
02094      990,   -95,  -434,   467,   608,   610,   680,   522,   -87,  -508,
02095      412,  -108,   837,   267,   565,   356,   357,   329,   211,   474,
02096      474,   218,   -95,    86,   414,   -95,   432,   218,   218,   -95,
02097      422,   860,   565,   862,   -94,   602,   604,  -513,   416,   416,
02098      766,   755,   218,   413,   625,   418,   419,   420,   610,   201,
02099      119,   267,   199,   467,  -602,   202,  -508,  -508,   565,  1024,
02100     -602,  1025,   440,  -434,   276,   475,   475,   476,   476,   218,
02101      218,   211,   352,   353,   354,   457,   -97,   460,   765,   432,
02102      759,  -515,   458,   218,   458,   565,   618,  1056,   611,   474,
02103      227,  -294,  1047,   482,  1048,    71,   442,   -97,   679,   682,
02104      -97,   703,   329,   693,   -97,   329,  -104,    86,  -434,   710,
02105     -434,  -434,   230,  1015,   276,   689,   689,    86,   450,   689,
02106      234,   645,   612,   646,   647,   648,   649,   700,   788,  -515,
02107      791,  -603,   444,   -72,   277,   475,   218,   476,  -294,  -294,
02108      826,  -609,  -606,   743,   748,   706,   645,   834,   646,   647,
02109      648,   649,   718,   456,   720,  -516,   723,   723,   350,   351,
02110      352,   353,   354,   462,  -518,   637,   704,   840,   526,   577,
02111      735,  -523,   767,   762,   711,   474,   465,   717,   469,   418,
02112      445,   211,   981,   726,   277,   859,   474,   484,   983,   432,
02113      755,   488,  -511,   211,   497,   565,   474,  -102,   491,   706,
02114      754,   432,  -609,  -516,   869,   872,   663,   565,   750,   751,
02115      494,   753,  -518,   610,   267,   875,   201,   470,   -93,   199,
02116      416,   475,   202,   476,   477,   760,   706,   807,   509,  -517,
02117      994,   467,   475,   276,   476,   479,    86,  -603,    86,  -511,
02118     -511,   119,   475,  -603,   476,   481,   218,  -609,   827,  -609,
02119     -609,  -106,   811,  -605,   650,   748,   867,   780,   218,  -519,
02120       86,   218,  -520,   864,   471,   472,   651,  -508,   813,   577,
02121      812,   814,   853,   816,   521,   855,   783,  -517,   783,  -511,
02122      359,   498,  -103,   359,   579,   818,    71,  -521,   843,   840,
02123      583,   218,   276,   620,   654,   655,   622,   623,    86,   689,
02124      633,  -284,   933,   277,   863,   -87,   836,  -519,   681,  -520,
02125     -520,   631,  1042,   937,   706,  -508,   854,   580,   656,   629,
02126      751,   515,   884,   839,   842,   706,   842,  -511,   842,   523,
02127      761,   474,   822,   824,  -521,  -521,   683,   947,   949,   830,
02128      832,   592,   952,   638,   954,  -295,   955,   885,  -284,  -284,
02129      405,   885,    86,  -266,   694,    86,   697,    86,   474,   812,
02130      199,   698,   277,   218,   581,   582,   218,   218,   878,   416,
02131      963,  -425,   804,   218,   218,   713,  -109,   475,  1018,   476,
02132      485,   715,   922,   803,   812,   774,   446,   708,   593,   594,
02133      359,   663,  -295,  -295,   719,   744,   909,  -100,   218,   276,
02134      763,   218,    86,   777,   475,   709,   476,   492,   911,    76,
02135       86,    76,  -108,  -104,   783,   783,   829,   593,   594,   802,
02136      778,   918,   781,    76,    76,  1019,  1020,    76,   925,   926,
02137      784,  -106,   928,   -99,   -95,   723,   807,   931,   785,   436,
02138      965,   927,  -103,   807,   935,   807,   917,   787,   789,   921,
02139      437,   438,   -97,   790,  1030,  1032,  1033,  1034,    76,   267,
02140      913,   811,   792,   -94,  -267,   885,   821,   840,   811,   898,
02141      811,   828,   956,    76,   868,   329,   870,   663,   874,   663,
02142       86,   893,   894,   895,   886,   906,   899,   890,   902,   276,
02143      342,   343,   783,   904,   218,    76,    76,   907,   910,    76,
02144      982,   908,   774,   873,   915,    86,  1057,  -268,   218,   919,
02145      276,   663,    86,    86,   942,   939,    86,   957,   946,   948,
02146      663,   962,   951,   953,   996,   997,   974,   349,   350,   351,
02147      352,   353,   354,  1002,  -269,   645,   842,   646,   647,   648,
02148      649,  1017,   992,  1028,   807,  1003,   807,  1005,  1010,   794,
02149      795,   807,   796,   807,  1012,  1016,    86,  1027,  1029,   958,
02150       46,    47,  1021,  1031,  1022,  1052,  -605,   329,  -606,   811,
02151     1023,   811,   368,   783,   769,   385,   811,   635,   811,   835,
02152      977,   804,   342,   343,    86,   804,   799,  1046,   804,   871,
02153      804,   903,   905,   807,  1039,    86,   865,  1045,   493,   966,
02154      403,   969,   290,   397,   991,   774,   883,   774,    86,    86,
02155      964,   960,   645,    76,   646,   647,   648,   649,   811,   211,
02156      350,   351,   352,   353,   354,   881,   706,   432,   802,   717,
02157      842,     0,   598,   565,    76,   802,    76,    76,     0,     0,
02158       76,     0,    76,   998,     0,  1000,    86,    76,    86,     0,
02159     1001,   769,     0,     0,    86,     0,    86,   770,    76,     0,
02160       76,     0,   645,     0,   646,   647,   648,   649,     0,    76,
02161        0,     0,   774,   995,    41,    42,    43,    44,   970,   663,
02162      646,   647,   648,   649,   218,     0,     0,     0,     0,   804,
02163        0,   804,     0,     0,     0,     0,   804,     0,   804,     0,
02164     1035,   769,  1037,     0,     0,     0,     0,   940,     0,  1038,
02165      309,   310,   311,   312,   313,    76,    76,    76,    76,    76,
02166       76,    76,    76,     0,     0,   774,     0,   774,  1050,     0,
02167       76,     0,    76,     0,     0,    76,   802,     0,   804,     0,
02168        0,     0,  1004,  1006,     0,     0,     0,     0,  1011,  1058,
02169     1013,  1014,     0,   213,   213,     0,     0,   213,     0,     0,
02170      774,     0,     0,    76,     0,    76,     0,     0,     0,    76,
02171       76,     0,     0,     0,     0,     0,     0,   645,     0,   646,
02172      647,   648,   649,   650,    76,   247,   249,     0,     0,     0,
02173      213,   213,     0,     0,     0,   651,     0,     0,     0,     0,
02174        0,     0,     0,   302,   303,     0,     0,     0,     0,     0,
02175        0,    76,    76,     0,     0,     0,   652,  1051,  1053,  1054,
02176     1055,     0,   653,   654,   655,    76,   645,     0,   646,   647,
02177      648,   649,   650,     0,     0,     0,     0,     0,     0,     0,
02178     1059,     0,     0,     0,   651,     0,     0,   656,     0,    76,
02179      657,     0,     0,     0,     0,     0,     0,     0,     0,    76,
02180        0,     0,     0,     0,     0,   652,  -627,     0,   234,     0,
02181        0,   653,   654,   655,  -627,  -627,  -627,     0,    76,  -627,
02182     -627,  -627,   645,  -627,   646,   647,   648,   649,   650,     0,
02183        0,     0,  -627,  -627,     0,     0,   656,     0,     0,   657,
02184      651,     0,     0,  -627,  -627,     0,  -627,  -627,  -627,  -627,
02185     -627,     0,   658,     0,     0,     0,     0,     0,     0,     0,
02186        0,   652,     0,     0,     0,     0,     0,   653,   654,   655,
02187        0,     0,     0,   113,     0,   113,     0,     0,     0,     0,
02188        0,   213,     0,     0,   213,   213,   213,   302,     0,     0,
02189        0,     0,   656,  -627,     0,   657,     0,     0,     0,     0,
02190        0,     0,     0,     0,   213,     0,   213,   213,     0,   645,
02191        0,   646,   647,   648,   649,   650,  -627,     0,    76,     0,
02192       76,     0,   113,     0,     0,     0,   278,   651,    76,     0,
02193        0,     0,     0,     0,     0,   329,     0,     0,  -627,  -627,
02194       76,  -627,    76,    76,   230,  -627,     0,  -627,   652,  -627,
02195      342,   343,   278,     0,     0,   654,   655,     0,     0,     0,
02196        0,     0,     0,     0,   372,   382,   382,   382,     0,     0,
02197        0,     0,     0,    76,     0,     0,     0,     0,     0,   656,
02198       76,     0,     0,     0,     0,   347,   348,   349,   350,   351,
02199      352,   353,   354,     0,     0,     0,     0,     0,     0,     0,
02200      213,     0,     0,     0,     0,   525,   528,   529,   530,   531,
02201      532,   533,   534,   535,   536,   537,   538,   539,   540,   541,
02202      542,   543,   544,   545,   546,   547,   548,   549,   550,   551,
02203      552,   553,     0,   213,    76,     0,     0,    76,     0,    76,
02204        0,     0,     0,     0,     0,    76,     0,     0,    76,    76,
02205        0,     0,     0,     0,     0,    76,    76,     0,     0,     0,
02206        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02207        0,     0,     0,     0,     0,     0,   114,   113,   114,     0,
02208       76,   603,   605,    76,    76,     0,     0,     0,     0,   607,
02209      213,   213,    76,     0,     0,   213,     0,   603,   605,   213,
02210        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02211        0,   113,     0,     0,     0,     0,     0,     0,   627,     0,
02212        0,     0,   113,   632,   113,   114,     0,     0,     0,   279,
02213        0,     0,     0,     0,   213,     0,     0,   213,     0,     0,
02214        0,     0,     0,     0,     0,   278,     0,     0,   213,     0,
02215        0,     0,     0,     0,     0,   279,   117,     0,   117,     0,
02216        0,     0,    76,     0,     0,     0,     0,   373,   383,   383,
02217      383,     0,     0,     0,   684,     0,    76,     0,     0,   113,
02218        0,     0,     0,     0,   113,     0,     0,    76,     0,   213,
02219       76,     0,     0,     0,    76,    76,   113,   278,    76,     0,
02220        0,     0,     0,     0,     0,   117,     0,     0,     0,   280,
02221        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02222        0,     0,     0,     0,     0,     0,     0,     0,     0,   113,
02223        0,     0,     0,     0,     0,   280,     0,     0,    76,     0,
02224        0,     0,     0,     0,     0,     0,     0,   374,   384,   384,
02225        0,     0,     0,     0,   213,     0,     0,     0,   213,     0,
02226        0,     0,     0,     0,     0,     0,    76,     0,     0,     0,
02227      213,     0,     0,     0,     0,     0,     0,    76,     0,     0,
02228      114,     0,     0,     0,     0,     0,   213,     0,     0,     0,
02229       76,    76,     0,     0,     0,     0,     0,     0,     0,   213,
02230      213,   329,   330,   331,   332,   333,   334,   335,   336,     0,
02231      338,   339,     0,   113,   114,     0,   342,   343,     0,     0,
02232        0,     0,     0,   113,     0,   114,     0,   114,    76,     0,
02233       76,     0,     0,     0,     0,    83,    76,    83,    76,     0,
02234      278,     0,     0,   213,     0,     0,     0,     0,   279,   345,
02235      346,   347,   348,   349,   350,   351,   352,   353,   354,     0,
02236      117,     0,     0,     0,     0,     0,    76,     0,     0,     0,
02237        0,   213,     0,     0,     0,   607,   820,     0,   823,   825,
02238        0,     0,   114,     0,    83,   831,   833,   114,     0,     0,
02239      278,     0,   213,     0,   117,     0,     0,     0,     0,   114,
02240      279,     0,     0,     0,     0,   117,     0,   117,     0,     0,
02241        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02242        0,     0,     0,     0,     0,     0,   369,     0,   280,   866,
02243        0,     0,   114,   823,   825,     0,   831,   833,     0,     0,
02244        0,     0,   113,     0,   113,     0,     0,     0,     0,     0,
02245        0,     0,     0,     0,   213,     0,     0,     0,     0,     0,
02246        0,     0,   117,     0,     0,     0,   113,   117,     0,     0,
02247        0,     0,     0,     0,     0,     0,     0,     0,     0,   117,
02248      280,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02249        0,     0,     0,     0,   213,     0,     0,   116,   912,   116,
02250        0,     0,     0,     0,   113,     0,   914,     0,     0,   278,
02251        0,     0,   117,     0,     0,     0,   114,     0,     0,     0,
02252        0,     0,     0,     0,     0,     0,   114,   213,     0,     0,
02253        0,     0,     0,     0,     0,     0,     0,     0,     0,    83,
02254        0,     0,     0,   279,   914,   213,   116,     0,     0,     0,
02255        0,     0,     0,     0,     0,     0,     0,     0,   113,     0,
02256        0,   113,     0,   113,     0,     0,     0,     0,   278,     0,
02257        0,     0,     0,    83,     0,     0,     0,     0,     0,     0,
02258        0,     0,     0,     0,    83,     0,    83,     0,     0,     0,
02259        0,     0,     0,   279,     0,     0,   117,     0,     0,     0,
02260        0,     0,   699,     0,     0,     0,   117,     0,   113,     0,
02261        0,     0,     0,     0,     0,     0,   113,     0,     0,     0,
02262        0,     0,     0,   280,     0,     0,     0,     0,   329,   330,
02263      331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
02264      341,    83,     0,   342,   343,   114,    83,   114,     0,     0,
02265        0,     0,     0,     0,     0,     0,     0,     0,    83,     0,
02266        0,   524,     0,     0,     0,     0,     0,     0,     0,   114,
02267        0,     0,     0,   280,   344,   382,   345,   346,   347,   348,
02268      349,   350,   351,   352,   353,   354,   113,     0,     0,     0,
02269        0,    83,     0,     0,  -243,     0,   213,     0,     0,     0,
02270        0,   116,     0,     0,     0,     0,     0,   114,     0,     0,
02271        0,   113,   279,     0,     0,     0,     0,     0,   113,   113,
02272        0,     0,   113,     0,     0,   117,     0,   117,     0,     0,
02273        0,     0,     0,     0,     0,   116,     0,     0,     0,     0,
02274        0,     0,     0,     0,     0,     0,   116,     0,   116,   117,
02275        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02276        0,   114,   113,     0,   114,   382,   114,     0,     0,     0,
02277        0,   279,     0,     0,     0,    83,     0,     0,     0,     0,
02278        0,     0,     0,     0,     0,    83,   978,   117,     0,     0,
02279      113,     0,   280,     0,     0,     0,     0,     0,     0,     0,
02280        0,   113,     0,   116,     0,     0,     0,     0,   116,     0,
02281        0,   114,     0,     0,   113,   113,     0,     0,     0,   114,
02282      116,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02283        0,     0,   798,     0,     0,     0,     0,     0,     0,     0,
02284        0,   117,     0,     0,   117,     0,   117,     0,     0,     0,
02285        0,   280,   113,   116,   113,     0,     0,     0,     0,     0,
02286      113,     0,   113,     0,     0,     0,     0,     0,     0,     0,
02287        0,     0,     0,     0,     0,     0,     0,     0,   383,     0,
02288        0,     0,     0,     0,     0,     0,     0,     0,     0,   114,
02289        0,   117,     0,     0,     0,     0,     0,     0,     0,   117,
02290        0,     0,     0,     0,    83,     0,    83,     0,     0,     0,
02291        0,     0,     0,     0,   114,     0,     0,     0,     0,     0,
02292        0,   114,   114,     0,     0,   114,     0,     0,    83,   329,
02293     -628,  -628,  -628,  -628,   334,   335,     0,   116,  -628,  -628,
02294        0,     0,     0,     0,   342,   343,     0,   116,     0,     0,
02295        0,     0,     0,     0,     0,     0,     0,     0,   384,     0,
02296        0,     0,     0,     0,     0,   114,    83,     0,   383,   117,
02297        0,     0,     0,     0,     0,     0,     0,   345,   346,   347,
02298      348,   349,   350,   351,   352,   353,   354,     0,     0,   979,
02299        0,     0,     0,   114,   117,     0,     0,     0,     0,     0,
02300        0,   117,   117,     0,   114,   117,     0,     0,     0,     0,
02301        0,     0,     0,     0,     0,     0,     0,   114,   114,     0,
02302       83,     0,     0,    83,     0,    83,     0,     0,     0,     0,
02303        0,   524,     0,     0,     0,     0,     0,     0,     0,     0,
02304        0,     0,     0,     0,     0,   117,     0,     0,   384,     0,
02305        0,     0,     0,     0,     0,   114,     0,   114,     0,     0,
02306        0,     0,     0,   114,     0,   114,   116,     0,   116,   980,
02307       83,     0,     0,   117,     0,     0,     0,     0,    83,  -609,
02308        0,     0,     0,     0,   117,     0,     0,  -609,  -609,  -609,
02309      116,     0,  -609,  -609,  -609,     0,  -609,   117,   117,     0,
02310        0,     0,     0,     0,     0,  -609,  -609,  -609,  -609,     0,
02311        0,     0,     0,     0,     0,     0,  -609,  -609,     0,  -609,
02312     -609,  -609,  -609,  -609,     0,     0,     0,     0,   116,     0,
02313        0,     0,     0,     0,     0,   117,     0,   117,     0,     0,
02314        0,     0,     0,   117,     0,   117,     0,     0,    83,  -609,
02315     -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,
02316     -609,  -609,     0,     0,  -609,  -609,  -609,     0,   756,  -609,
02317        0,     0,     0,    83,     0,  -609,     0,     0,     0,     0,
02318       83,    83,   116,     0,    83,   116,     0,   116,     0,  -609,
02319        0,     0,  -609,     0,  -105,  -609,  -609,  -609,  -609,  -609,
02320     -609,  -609,  -609,  -609,  -609,  -609,  -609,     0,     0,     0,
02321        0,  -609,  -609,  -609,  -609,  -609,     0,     0,  -609,  -609,
02322     -609,     0,  -609,     0,    83,     0,     0,     0,     0,     0,
02323        0,     0,   116,     0,     0,     0,     0,     0,     0,     0,
02324      116,   329,   330,   331,   332,   333,   334,   335,   976,     0,
02325      338,   339,    83,     0,     0,     0,   342,   343,     0,     0,
02326        0,     0,     0,    83,     0,     0,     0,     0,     0,     0,
02327        0,     0,     0,     0,     0,     0,    83,    83,     0,     0,
02328        0,     0,     0,     0,     0,     0,     0,     0,     0,   345,
02329      346,   347,   348,   349,   350,   351,   352,   353,   354,     0,
02330        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02331      116,     0,     0,     0,    83,     0,    83,     0,     0,     0,
02332        0,     0,    83,     0,    83,     0,     0,     0,     0,     0,
02333        0,     0,     0,     0,     0,   116,     0,     0,     0,     0,
02334        0,     0,   116,   116,     0,     0,   116,     0,     0,     0,
02335        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02336        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02337        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02338        0,     0,     0,     0,     0,     0,   116,     0,     0,     0,
02339        0,     0,     0,     0,     0,     0,     0,  -627,     4,     0,
02340        5,     6,     7,     8,     9,     0,     0,     0,    10,    11,
02341        0,     0,     0,    12,   116,    13,    14,    15,    16,    17,
02342       18,    19,     0,     0,     0,   116,     0,    20,    21,    22,
02343       23,    24,    25,    26,     0,     0,    27,     0,   116,   116,
02344        0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
02345       36,    37,    38,    39,    40,     0,    41,    42,    43,    44,
02346        0,    45,    46,    47,     0,    48,    49,     0,     0,     0,
02347        0,     0,     0,     0,     0,     0,   116,     0,   116,     0,
02348        0,     0,     0,     0,   116,    50,   116,     0,    51,    52,
02349        0,    53,    54,     0,    55,     0,     0,    56,    57,    58,
02350       59,    60,    61,    62,    63,    64,  -508,     0,     0,     0,
02351        0,     0,     0,     0,  -508,  -508,  -508,     0,     0,  -508,
02352     -508,  -508,     0,  -508,     0,    65,    66,    67,     0,   752,
02353        0,  -508,     0,  -508,  -508,  -508,     0,     0,  -627,     0,
02354     -627,     0,     0,  -508,  -508,     0,  -508,  -508,  -508,  -508,
02355     -508,     0,     0,     0,     0,   329,   330,   331,   332,   333,
02356      334,   335,   336,   337,   338,   339,   340,   341,     0,     0,
02357      342,   343,     0,     0,     0,     0,  -508,  -508,  -508,  -508,
02358     -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,     0,
02359        0,  -508,  -508,  -508,     0,  -508,  -508,     0,     0,     0,
02360        0,   344,  -508,   345,   346,   347,   348,   349,   350,   351,
02361      352,   353,   354,     0,     0,     0,  -508,     0,     0,  -508,
02362        0,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
02363     -508,  -508,  -508,  -508,     0,     0,     0,     0,     0,  -508,
02364     -508,  -508,  -508,  -511,     0,  -508,  -508,  -508,     0,  -508,
02365        0,  -511,  -511,  -511,     0,     0,  -511,  -511,  -511,     0,
02366     -511,     0,     0,     0,     0,     0,   699,     0,  -511,     0,
02367     -511,  -511,  -511,     0,     0,     0,     0,     0,     0,     0,
02368     -511,  -511,     0,  -511,  -511,  -511,  -511,  -511,     0,     0,
02369        0,     0,   329,   330,   331,   332,   333,   334,   335,   336,
02370      337,   338,   339,   340,   341,     0,     0,   342,   343,     0,
02371        0,     0,     0,  -511,  -511,  -511,  -511,  -511,  -511,  -511,
02372     -511,  -511,  -511,  -511,  -511,  -511,     0,     0,  -511,  -511,
02373     -511,     0,  -511,  -511,     0,     0,     0,     0,   344,  -511,
02374      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
02375        0,     0,     0,  -511,     0,     0,  -511,     0,  -511,  -511,
02376     -511,  -511,  -511,  -511,  -511,  -511,  -511,  -511,  -511,  -511,
02377     -511,     0,     0,     0,     0,     0,  -511,  -511,  -511,  -511,
02378     -610,     0,  -511,  -511,  -511,     0,  -511,     0,  -610,  -610,
02379     -610,     0,     0,  -610,  -610,  -610,     0,  -610,     0,     0,
02380        0,     0,     0,     0,     0,     0,  -610,  -610,  -610,  -610,
02381        0,     0,     0,     0,     0,     0,     0,  -610,  -610,     0,
02382     -610,  -610,  -610,  -610,  -610,     0,     0,     0,     0,   329,
02383      330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
02384      340,   341,     0,     0,   342,   343,     0,     0,     0,     0,
02385     -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,
02386     -610,  -610,  -610,     0,     0,  -610,  -610,  -610,     0,     0,
02387     -610,     0,     0,     0,     0,   344,  -610,   345,   346,   347,
02388      348,   349,   350,   351,   352,   353,   354,     0,     0,     0,
02389     -610,     0,     0,  -610,     0,     0,  -610,  -610,  -610,  -610,
02390     -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,     0,     0,
02391        0,     0,  -610,  -610,  -610,  -610,  -610,  -611,     0,  -610,
02392     -610,  -610,     0,  -610,     0,  -611,  -611,  -611,     0,     0,
02393     -611,  -611,  -611,     0,  -611,     0,     0,     0,     0,     0,
02394        0,     0,     0,  -611,  -611,  -611,  -611,     0,     0,     0,
02395        0,     0,     0,     0,  -611,  -611,     0,  -611,  -611,  -611,
02396     -611,  -611,     0,     0,     0,     0,   329,   330,   331,   332,
02397      333,   334,   335,   336,   337,   338,   339,  -628,  -628,     0,
02398        0,   342,   343,     0,     0,     0,     0,  -611,  -611,  -611,
02399     -611,  -611,  -611,  -611,  -611,  -611,  -611,  -611,  -611,  -611,
02400        0,     0,  -611,  -611,  -611,     0,     0,  -611,     0,     0,
02401        0,     0,     0,  -611,   345,   346,   347,   348,   349,   350,
02402      351,   352,   353,   354,     0,     0,     0,  -611,     0,     0,
02403     -611,     0,     0,  -611,  -611,  -611,  -611,  -611,  -611,  -611,
02404     -611,  -611,  -611,  -611,  -611,     0,     0,     0,     0,  -611,
02405     -611,  -611,  -611,  -611,  -294,     0,  -611,  -611,  -611,     0,
02406     -611,     0,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02407        0,  -294,     0,     0,     0,     0,     0,     0,     0,     0,
02408        0,  -294,  -294,  -294,     0,     0,     0,     0,     0,     0,
02409        0,  -294,  -294,     0,  -294,  -294,  -294,  -294,  -294,     0,
02410        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02411        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02412        0,     0,     0,     0,  -294,  -294,  -294,  -294,  -294,  -294,
02413     -294,  -294,  -294,  -294,  -294,  -294,  -294,     0,     0,  -294,
02414     -294,  -294,     0,   757,  -294,     0,     0,     0,     0,     0,
02415     -294,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02416        0,     0,     0,     0,  -294,     0,     0,  -294,     0,  -107,
02417     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02418     -294,  -294,     0,     0,     0,     0,     0,  -294,  -294,  -294,
02419     -294,  -433,     0,  -294,  -294,  -294,     0,  -294,     0,  -433,
02420     -433,  -433,     0,     0,  -433,  -433,  -433,     0,  -433,     0,
02421        0,     0,     0,     0,     0,     0,     0,  -433,  -433,  -433,
02422        0,     0,     0,     0,     0,     0,     0,     0,  -433,  -433,
02423        0,  -433,  -433,  -433,  -433,  -433,     0,     0,     0,     0,
02424        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02425        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02426        0,  -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,
02427     -433,  -433,  -433,  -433,     0,     0,  -433,  -433,  -433,     0,
02428        0,  -433,     0,     0,     0,     0,     0,  -433,     0,     0,
02429        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02430        0,  -433,     0,     0,     0,     0,     0,  -433,     0,  -433,
02431     -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,     0,
02432        0,     0,     0,  -433,  -433,  -433,  -433,  -433,  -285,   230,
02433     -433,  -433,  -433,     0,  -433,     0,  -285,  -285,  -285,     0,
02434        0,  -285,  -285,  -285,     0,  -285,     0,     0,     0,     0,
02435        0,     0,     0,     0,     0,  -285,  -285,  -285,     0,     0,
02436        0,     0,     0,     0,     0,  -285,  -285,     0,  -285,  -285,
02437     -285,  -285,  -285,     0,     0,     0,     0,     0,     0,     0,
02438        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02439        0,     0,     0,     0,     0,     0,     0,     0,  -285,  -285,
02440     -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02441     -285,     0,     0,  -285,  -285,  -285,     0,     0,  -285,     0,
02442        0,     0,     0,     0,  -285,     0,     0,     0,     0,     0,
02443        0,     0,     0,     0,     0,     0,     0,     0,  -285,     0,
02444        0,  -285,     0,     0,  -285,  -285,  -285,  -285,  -285,  -285,
02445     -285,  -285,  -285,  -285,  -285,  -285,     0,     0,     0,     0,
02446        0,  -285,  -285,  -285,  -285,  -423,     0,  -285,  -285,  -285,
02447        0,  -285,     0,  -423,  -423,  -423,     0,     0,  -423,  -423,
02448     -423,     0,  -423,     0,     0,     0,     0,     0,     0,     0,
02449        0,  -423,  -423,  -423,     0,     0,     0,     0,     0,     0,
02450        0,     0,  -423,  -423,     0,  -423,  -423,  -423,  -423,  -423,
02451        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02452        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02453        0,     0,     0,     0,     0,  -423,  -423,  -423,  -423,  -423,
02454     -423,  -423,  -423,  -423,  -423,  -423,  -423,  -423,     0,     0,
02455     -423,  -423,  -423,     0,     0,  -423,     0,     0,     0,     0,
02456        0,  -423,     0,     0,     0,     0,     0,     0,     0,     0,
02457        0,     0,     0,     0,     0,  -423,     0,     0,     0,     0,
02458        0,  -423,     0,  -423,  -423,  -423,  -423,  -423,  -423,  -423,
02459     -423,  -423,  -423,     0,     0,     0,     0,  -423,  -423,  -423,
02460     -423,  -423,  -301,  -423,  -423,  -423,  -423,     0,  -423,     0,
02461     -301,  -301,  -301,     0,     0,  -301,  -301,  -301,     0,  -301,
02462        0,     0,     0,     0,     0,     0,     0,     0,     0,  -301,
02463     -301,     0,     0,     0,     0,     0,     0,     0,     0,  -301,
02464     -301,     0,  -301,  -301,  -301,  -301,  -301,     0,     0,     0,
02465        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02466        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02467        0,     0,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02468     -301,  -301,  -301,  -301,  -301,     0,     0,  -301,  -301,  -301,
02469        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02470        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02471        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02472     -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02473        0,     0,     0,     0,     0,  -301,  -301,  -301,  -301,  -609,
02474      227,  -301,  -301,  -301,     0,  -301,     0,  -609,  -609,  -609,
02475        0,     0,     0,  -609,  -609,     0,  -609,     0,     0,     0,
02476        0,     0,     0,     0,     0,  -609,     0,     0,     0,     0,
02477        0,     0,     0,     0,     0,     0,  -609,  -609,     0,  -609,
02478     -609,  -609,  -609,  -609,     0,     0,     0,     0,     0,     0,
02479        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02480        0,     0,     0,     0,     0,     0,     0,     0,     0,  -609,
02481     -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,
02482     -609,  -609,     0,     0,  -609,  -609,  -609,     0,   701,     0,
02483        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02484        0,     0,     0,     0,     0,     0,     0,     0,     0,  -609,
02485        0,     0,     0,     0,  -105,  -609,     0,  -609,  -609,  -609,
02486     -609,  -609,  -609,  -609,  -609,  -609,  -609,     0,     0,     0,
02487        0,  -609,  -609,  -609,  -609,   -96,  -294,     0,  -609,     0,
02488     -609,     0,  -609,     0,  -294,  -294,  -294,     0,     0,     0,
02489     -294,  -294,     0,  -294,     0,     0,     0,     0,     0,     0,
02490        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02491        0,     0,     0,  -294,  -294,     0,  -294,  -294,  -294,  -294,
02492     -294,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02493        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02494        0,     0,     0,     0,     0,     0,  -294,  -294,  -294,  -294,
02495     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,     0,
02496        0,  -294,  -294,  -294,     0,   702,     0,     0,     0,     0,
02497        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02498        0,     0,     0,     0,     0,     0,  -294,     0,     0,     0,
02499        0,  -107,  -294,     0,  -294,  -294,  -294,  -294,  -294,  -294,
02500     -294,  -294,  -294,  -294,     0,     0,     0,     0,     0,  -294,
02501     -294,  -294,   -98,     0,     0,  -294,     0,  -294,   251,  -294,
02502        5,     6,     7,     8,     9,  -627,  -627,  -627,    10,    11,
02503        0,     0,  -627,    12,     0,    13,    14,    15,    16,    17,
02504       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02505       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02506        0,     0,    28,    29,   252,    31,    32,    33,    34,    35,
02507       36,    37,    38,    39,    40,     0,    41,    42,    43,    44,
02508        0,    45,    46,    47,     0,    48,    49,     0,     0,     0,
02509        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02510        0,     0,     0,     0,     0,    50,     0,     0,    51,    52,
02511        0,    53,    54,     0,    55,     0,     0,    56,    57,    58,
02512       59,    60,    61,    62,    63,    64,     0,     0,     0,     0,
02513        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02514        0,     0,     0,     0,     0,    65,    66,    67,     0,     0,
02515        0,     0,     0,     0,     0,     0,     0,     0,  -627,   251,
02516     -627,     5,     6,     7,     8,     9,     0,     0,  -627,    10,
02517       11,     0,  -627,  -627,    12,     0,    13,    14,    15,    16,
02518       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02519       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02520        0,     0,     0,    28,    29,   252,    31,    32,    33,    34,
02521       35,    36,    37,    38,    39,    40,     0,    41,    42,    43,
02522       44,     0,    45,    46,    47,     0,    48,    49,     0,     0,
02523        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02524        0,     0,     0,     0,     0,     0,    50,     0,     0,    51,
02525       52,     0,    53,    54,     0,    55,     0,     0,    56,    57,
02526       58,    59,    60,    61,    62,    63,    64,     0,     0,     0,
02527        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02528        0,     0,     0,     0,     0,     0,    65,    66,    67,     0,
02529        0,     0,     0,     0,     0,     0,     0,     0,     0,  -627,
02530      251,  -627,     5,     6,     7,     8,     9,     0,     0,  -627,
02531       10,    11,     0,     0,  -627,    12,  -627,    13,    14,    15,
02532       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02533       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02534        0,     0,     0,     0,    28,    29,   252,    31,    32,    33,
02535       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02536       43,    44,     0,    45,    46,    47,     0,    48,    49,     0,
02537        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02538        0,     0,     0,     0,     0,     0,     0,    50,     0,     0,
02539       51,    52,     0,    53,    54,     0,    55,     0,     0,    56,
02540       57,    58,    59,    60,    61,    62,    63,    64,     0,     0,
02541        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02542        0,     0,     0,     0,     0,     0,     0,    65,    66,    67,
02543        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02544     -627,   251,  -627,     5,     6,     7,     8,     9,     0,     0,
02545     -627,    10,    11,     0,     0,  -627,    12,     0,    13,    14,
02546       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02547       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02548        0,     0,     0,     0,     0,    28,    29,   252,    31,    32,
02549       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02550       42,    43,    44,     0,    45,    46,    47,     0,    48,    49,
02551        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02552        0,     0,     0,     0,     0,     0,     0,     0,    50,     0,
02553        0,    51,    52,     0,    53,    54,     0,    55,     0,     0,
02554       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
02555        0,     0,     0,     0,     0,     0,   251,     0,     5,     6,
02556        7,     8,     9,     0,  -627,  -627,    10,    11,    65,    66,
02557       67,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02558        0,  -627,     0,  -627,     0,    20,    21,    22,    23,    24,
02559       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02560       28,    29,   252,    31,    32,    33,    34,    35,    36,    37,
02561       38,    39,    40,     0,    41,    42,    43,    44,     0,    45,
02562       46,    47,     0,    48,    49,     0,     0,     0,     0,     0,
02563        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02564        0,     0,     0,    50,     0,     0,    51,    52,     0,    53,
02565       54,     0,    55,     0,     0,    56,    57,    58,    59,    60,
02566       61,    62,    63,    64,     0,     0,     0,     0,     0,     0,
02567        0,   251,     0,     5,     6,     7,     8,     9,     0,     0,
02568        0,    10,    11,    65,    66,    67,    12,     0,    13,    14,
02569       15,    16,    17,    18,    19,     0,  -627,     0,  -627,     0,
02570       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02571        0,     0,     0,     0,     0,    28,    29,   252,    31,    32,
02572       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02573       42,    43,    44,     0,    45,    46,    47,     0,    48,    49,
02574        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02575        0,     0,     0,     0,     0,     0,     0,     0,    50,     0,
02576        0,   253,    52,     0,    53,    54,     0,    55,     0,     0,
02577       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
02578        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02579        0,     0,     0,     0,     0,     0,     0,     0,    65,    66,
02580       67,     0,     0,     0,     0,     0,     0,     0,     0,  -627,
02581        0,  -627,   251,  -627,     5,     6,     7,     8,     9,     0,
02582        0,     0,    10,    11,     0,     0,     0,    12,     0,    13,
02583       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02584        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02585       27,     0,     0,     0,     0,     0,    28,    29,   252,    31,
02586       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02587       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02588       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02589        0,     0,     0,     0,     0,     0,     0,     0,     0,    50,
02590        0,     0,    51,    52,     0,    53,    54,     0,    55,     0,
02591        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02592        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02593        0,     0,     0,     0,     0,     0,     0,     0,     0,    65,
02594       66,    67,     0,     0,     0,     0,     0,     0,     0,     0,
02595     -627,     0,  -627,   251,  -627,     5,     6,     7,     8,     9,
02596        0,     0,     0,    10,    11,     0,     0,     0,    12,     0,
02597       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02598        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02599        0,    27,     0,     0,     0,     0,     0,    28,    29,   252,
02600       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02601        0,    41,    42,    43,    44,     0,    45,    46,    47,     0,
02602       48,    49,     0,     0,     0,     0,     0,     0,     0,     0,
02603        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02604       50,     0,     0,    51,    52,     0,    53,    54,     0,    55,
02605        0,     0,    56,    57,    58,    59,    60,    61,    62,    63,
02606       64,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02607        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02608       65,    66,    67,     0,     0,  -627,     4,     0,     5,     6,
02609        7,     8,     9,  -627,     0,  -627,    10,    11,     0,     0,
02610        0,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02611        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02612       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02613       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02614       38,    39,    40,     0,    41,    42,    43,    44,     0,    45,
02615       46,    47,     0,    48,    49,     0,     0,     0,     0,     0,
02616        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02617        0,     0,     0,    50,     0,     0,    51,    52,     0,    53,
02618       54,     0,    55,     0,     0,    56,    57,    58,    59,    60,
02619       61,    62,    63,    64,     0,     0,     0,     0,     0,     0,
02620        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02621        0,     0,     0,    65,    66,    67,     0,     0,  -627,     0,
02622        0,     0,     0,     0,     0,     0,  -627,   251,  -627,     5,
02623        6,     7,     8,     9,     0,     0,  -627,    10,    11,     0,
02624        0,     0,    12,     0,    13,    14,    15,    16,    17,    18,
02625       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02626       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02627        0,    28,    29,   252,    31,    32,    33,    34,    35,    36,
02628       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02629       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02630        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02631        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02632       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02633       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02634        0,     0,   251,     0,     5,     6,     7,     8,     9,     0,
02635        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02636       14,    15,    16,    17,    18,    19,     0,  -627,     0,  -627,
02637        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02638       27,     0,     0,     0,     0,     0,    28,    29,   252,    31,
02639       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02640       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02641       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02642        0,     0,     0,     0,     0,     0,     0,     0,     0,    50,
02643        0,     0,    51,    52,     0,    53,    54,     0,    55,     0,
02644        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02645        0,  -627,     0,     0,     0,     0,     0,     0,     0,     5,
02646        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02647       66,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02648       19,     0,  -627,     0,  -627,     0,    20,    21,    22,    23,
02649       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02650        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02651       37,    38,    39,    40,   204,    41,    42,    43,    44,     0,
02652       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02653        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02654        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02655       53,    54,     0,   207,   208,   209,    56,    57,    58,    59,
02656       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02657        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02658        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02659       14,    15,    16,    17,    18,    19,     0,     0,     0,   234,
02660        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02661       27,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02662       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02663       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02664       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02665        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02666        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
02667        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02668        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02669        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02670       66,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02671       19,     0,   304,     0,   305,     0,    20,    21,    22,    23,
02672       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02673        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02674       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02675       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02676        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02677        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02678       53,    54,     0,     0,     0,     0,    56,    57,    58,    59,
02679       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02680        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02681        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02682       14,    15,    16,    17,    18,    19,     0,     0,     0,   234,
02683        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02684       27,     0,     0,     0,     0,     0,    28,    29,    30,    31,
02685       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02686       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02687       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02688        0,     0,     0,     0,     0,     0,     0,     0,     0,    50,
02689        0,     0,    51,    52,     0,    53,    54,     0,    55,     0,
02690        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02691        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02692        6,     7,     8,     9,     0,     0,     0,    10,    11,    65,
02693       66,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02694       19,     0,   498,     0,     0,     0,    20,    21,    22,    23,
02695       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02696        0,    28,    29,   252,    31,    32,    33,    34,    35,    36,
02697       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02698       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02699        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02700        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02701       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02702       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02703        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02704        0,     0,     0,     0,    65,    66,    67,     0,     0,     0,
02705        0,     0,     0,     0,     0,     0,     0,   498,   121,   122,
02706      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02707      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
02708      143,   144,     0,     0,     0,   145,   146,   147,   386,   387,
02709      388,   389,   152,   153,   154,     0,     0,     0,     0,     0,
02710      155,   156,   157,   158,   390,   391,   392,   393,   163,    37,
02711       38,   394,    40,     0,     0,     0,     0,     0,     0,     0,
02712        0,     0,     0,   165,   166,   167,   168,   169,   170,   171,
02713      172,   173,     0,     0,   174,   175,     0,     0,   176,   177,
02714      178,   179,     0,     0,     0,     0,     0,     0,     0,     0,
02715        0,     0,   180,   181,     0,     0,     0,     0,     0,     0,
02716        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02717        0,     0,     0,   182,   183,   184,   185,   186,   187,   188,
02718      189,   190,   191,     0,   192,   193,     0,     0,     0,     0,
02719        0,     0,   194,   395,   121,   122,   123,   124,   125,   126,
02720      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02721      137,   138,   139,   140,   141,   142,   143,   144,     0,     0,
02722        0,   145,   146,   147,   148,   149,   150,   151,   152,   153,
02723      154,     0,     0,     0,     0,     0,   155,   156,   157,   158,
02724      159,   160,   161,   162,   163,   283,   284,   164,   285,     0,
02725        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
02726      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
02727      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
02728        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
02729        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02730        0,     0,     0,     0,     0,     0,     0,     0,     0,   182,
02731      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
02732      192,   193,     0,     0,     0,     0,     0,     0,   194,   121,
02733      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02734      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
02735      142,   143,   144,     0,     0,     0,   145,   146,   147,   148,
02736      149,   150,   151,   152,   153,   154,     0,     0,     0,     0,
02737        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02738      236,     0,   164,     0,     0,     0,     0,     0,     0,     0,
02739        0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
02740      171,   172,   173,     0,     0,   174,   175,     0,     0,   176,
02741      177,   178,   179,     0,     0,     0,     0,     0,     0,     0,
02742        0,     0,     0,   180,   181,     0,     0,    57,     0,     0,
02743        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02744        0,     0,     0,     0,   182,   183,   184,   185,   186,   187,
02745      188,   189,   190,   191,     0,   192,   193,     0,     0,     0,
02746        0,     0,     0,   194,   121,   122,   123,   124,   125,   126,
02747      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02748      137,   138,   139,   140,   141,   142,   143,   144,     0,     0,
02749        0,   145,   146,   147,   148,   149,   150,   151,   152,   153,
02750      154,     0,     0,     0,     0,     0,   155,   156,   157,   158,
02751      159,   160,   161,   162,   163,     0,     0,   164,     0,     0,
02752        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
02753      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
02754      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
02755        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
02756        0,     0,    57,     0,     0,     0,     0,     0,     0,     0,
02757        0,     0,     0,     0,     0,     0,     0,     0,     0,   182,
02758      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
02759      192,   193,     0,     0,     0,     0,     0,     0,   194,   121,
02760      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02761      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
02762      142,   143,   144,     0,     0,     0,   145,   146,   147,   148,
02763      149,   150,   151,   152,   153,   154,     0,     0,     0,     0,
02764        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02765        0,     0,   164,     0,     0,     0,     0,     0,     0,     0,
02766        0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
02767      171,   172,   173,     0,     0,   174,   175,     0,     0,   176,
02768      177,   178,   179,     0,     0,     0,     0,     0,     0,     0,
02769        0,     0,     0,   180,   181,     0,     0,     0,     0,     0,
02770        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02771        0,     0,     0,     0,   182,   183,   184,   185,   186,   187,
02772      188,   189,   190,   191,     0,   192,   193,     5,     6,     7,
02773        0,     9,     0,   194,     0,    10,    11,     0,     0,     0,
02774       12,     0,    13,    14,    15,   241,   242,    18,    19,     0,
02775        0,     0,     0,     0,   243,   244,   245,    23,    24,    25,
02776       26,     0,     0,   203,     0,     0,     0,     0,     0,     0,
02777      271,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02778       39,    40,     0,    41,    42,    43,    44,     0,    45,    46,
02779       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02780        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02781        0,     0,   272,     0,     0,   206,    52,     0,    53,    54,
02782        0,     0,     0,     0,    56,    57,    58,    59,    60,    61,
02783       62,    63,    64,     0,     0,     0,     0,     0,     5,     6,
02784        7,     0,     9,     0,     0,     0,    10,    11,     0,     0,
02785        0,    12,   273,    13,    14,    15,   241,   242,    18,    19,
02786      274,     0,     0,     0,     0,   243,   244,   245,    23,    24,
02787       25,    26,     0,     0,   203,     0,     0,     0,     0,     0,
02788        0,   271,     0,     0,    32,    33,    34,    35,    36,    37,
02789       38,    39,    40,     0,    41,    42,    43,    44,     0,    45,
02790       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02791        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02792        0,     0,     0,   272,     0,     0,   206,    52,     0,    53,
02793       54,     0,     0,     0,     0,    56,    57,    58,    59,    60,
02794       61,    62,    63,    64,     0,     0,     0,     0,     0,     5,
02795        6,     7,     8,     9,     0,     0,     0,    10,    11,     0,
02796        0,     0,    12,   273,    13,    14,    15,    16,    17,    18,
02797       19,   519,     0,     0,     0,     0,    20,    21,    22,    23,
02798       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02799        0,    28,    29,    30,    31,    32,    33,    34,    35,    36,
02800       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02801       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02802        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02803        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02804       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02805       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02806        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02807        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02808       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02809        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02810      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02811       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02812       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02813       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02814        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02815        0,     0,   206,    52,     0,    53,    54,     0,   207,   208,
02816      209,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02817        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02818        6,     7,     8,     9,     0,     0,     0,    10,    11,    65,
02819      210,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02820       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02821       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02822        0,    28,    29,     0,    31,    32,    33,    34,    35,    36,
02823       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02824       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02825        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02826        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02827       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02828       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02829        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02830        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02831       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02832        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02833      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02834       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02835       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02836       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02837        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02838        0,     0,   206,    52,     0,    53,    54,     0,   609,   208,
02839      209,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02840        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02841        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02842      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02843       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02844       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02845        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02846       37,    38,    39,    40,   204,    41,    42,    43,    44,     0,
02847       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02848        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02849        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02850       53,    54,     0,   207,   208,     0,    56,    57,    58,    59,
02851       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02852        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02853        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02854       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02855        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02856      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02857       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02858       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02859       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02860        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02861        0,     0,   206,    52,     0,    53,    54,     0,     0,   208,
02862      209,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02863        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02864        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02865      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02866       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02867       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02868        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02869       37,    38,    39,    40,   204,    41,    42,    43,    44,     0,
02870       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02871        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02872        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02873       53,    54,     0,   609,   208,     0,    56,    57,    58,    59,
02874       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02875        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02876        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02877       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02878        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02879      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02880       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02881       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02882       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02883        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02884        0,     0,   206,    52,     0,    53,    54,     0,     0,   208,
02885        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02886        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02887        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02888      210,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02889       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02890       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02891        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02892       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02893       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02894        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02895        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02896       53,    54,     0,   512,     0,     0,    56,    57,    58,    59,
02897       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02898        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02899        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02900       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02901        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02902      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02903       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02904       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02905       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02906        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02907        0,     0,   206,    52,     0,    53,    54,     0,   207,     0,
02908        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02909        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02910        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02911      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02912       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02913       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02914        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02915       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02916       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02917        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02918        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02919       53,    54,     0,   817,     0,     0,    56,    57,    58,    59,
02920       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02921        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02922        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02923       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02924        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02925      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02926       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02927       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02928       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02929        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02930        0,     0,   206,    52,     0,    53,    54,     0,   512,     0,
02931        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02932        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02933        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02934      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02935       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02936       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02937        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02938       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02939       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02940        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02941        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02942       53,    54,     0,   609,     0,     0,    56,    57,    58,    59,
02943       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02944        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02945        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02946       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02947        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02948      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02949       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02950       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02951       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02952        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02953        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
02954        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02955        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02956        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02957      210,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02958       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02959       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02960        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02961       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02962       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02963        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02964        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02965       53,    54,     0,     0,     0,     0,    56,    57,    58,    59,
02966       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02967        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02968        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02969       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02970        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02971       27,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02972       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02973       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02974       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02975        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02976        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
02977        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02978        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02979        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02980       66,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02981       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02982       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02983        0,     0,   271,     0,     0,    32,    33,    34,    35,    36,
02984       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02985       45,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02986        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02987        0,     0,     0,     0,   272,     0,     0,   325,    52,     0,
02988       53,    54,     0,   326,     0,     0,    56,    57,    58,    59,
02989       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02990        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02991        0,     0,     0,    12,   273,    13,    14,    15,   241,   242,
02992       18,    19,     0,     0,     0,     0,     0,   243,   244,   245,
02993       23,    24,    25,    26,     0,     0,   203,     0,     0,     0,
02994        0,     0,     0,   271,     0,     0,    32,    33,    34,    35,
02995       36,    37,    38,    39,    40,     0,    41,    42,    43,    44,
02996        0,    45,    46,    47,     0,     0,     0,     0,     0,     0,
02997        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02998        0,     0,     0,     0,     0,   367,     0,     0,    51,    52,
02999        0,    53,    54,     0,    55,     0,     0,    56,    57,    58,
03000       59,    60,    61,    62,    63,    64,     0,     0,     0,     0,
03001        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
03002       11,     0,     0,     0,    12,   273,    13,    14,    15,   241,
03003      242,    18,    19,     0,     0,     0,     0,     0,   243,   244,
03004      245,    23,    24,    25,    26,     0,     0,   203,     0,     0,
03005        0,     0,     0,     0,   271,     0,     0,    32,    33,    34,
03006      375,    36,    37,    38,   376,    40,     0,    41,    42,    43,
03007       44,     0,    45,    46,    47,     0,     0,     0,     0,     0,
03008        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03009        0,     0,     0,   377,     0,     0,   378,     0,     0,   206,
03010       52,     0,    53,    54,     0,     0,     0,     0,    56,    57,
03011       58,    59,    60,    61,    62,    63,    64,     0,     0,     0,
03012        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
03013       10,    11,     0,     0,     0,    12,   273,    13,    14,    15,
03014      241,   242,    18,    19,     0,     0,     0,     0,     0,   243,
03015      244,   245,    23,    24,    25,    26,     0,     0,   203,     0,
03016        0,     0,     0,     0,     0,   271,     0,     0,    32,    33,
03017       34,   375,    36,    37,    38,   376,    40,     0,    41,    42,
03018       43,    44,     0,    45,    46,    47,     0,     0,     0,     0,
03019        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03020        0,     0,     0,     0,     0,     0,     0,   378,     0,     0,
03021      206,    52,     0,    53,    54,     0,     0,     0,     0,    56,
03022       57,    58,    59,    60,    61,    62,    63,    64,     0,     0,
03023        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
03024        0,    10,    11,     0,     0,     0,    12,   273,    13,    14,
03025       15,   241,   242,    18,    19,     0,     0,     0,     0,     0,
03026      243,   244,   245,    23,    24,    25,    26,     0,     0,   203,
03027        0,     0,     0,     0,     0,     0,   271,     0,     0,    32,
03028       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
03029       42,    43,    44,     0,    45,    46,    47,     0,     0,     0,
03030        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03031        0,     0,     0,     0,     0,     0,     0,     0,   272,     0,
03032        0,   325,    52,     0,    53,    54,     0,     0,     0,     0,
03033       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
03034        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
03035        0,     0,    10,    11,     0,     0,     0,    12,   273,    13,
03036       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
03037        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
03038      203,     0,     0,     0,     0,     0,     0,   271,     0,     0,
03039       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
03040       41,    42,    43,    44,     0,    45,    46,    47,     0,     0,
03041        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03042        0,     0,     0,     0,     0,     0,     0,     0,     0,   897,
03043        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
03044        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
03045        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
03046        0,     0,     0,    10,    11,     0,     0,     0,    12,   273,
03047       13,    14,    15,   241,   242,    18,    19,     0,     0,     0,
03048        0,     0,   243,   244,   245,    23,    24,    25,    26,     0,
03049        0,   203,     0,     0,     0,     0,     0,     0,   271,     0,
03050        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
03051        0,    41,    42,    43,    44,     0,    45,    46,    47,     0,
03052        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03053        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03054      975,     0,     0,   206,    52,     0,    53,    54,     0,     0,
03055        0,     0,    56,    57,    58,    59,    60,    61,    62,    63,
03056       64,     0,     0,     0,     0,   554,   555,     0,     0,   556,
03057        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03058      273,   165,   166,   167,   168,   169,   170,   171,   172,   173,
03059        0,     0,   174,   175,     0,     0,   176,   177,   178,   179,
03060        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03061      180,   181,     0,     0,     0,     0,     0,     0,     0,     0,
03062        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03063        0,   182,   183,   184,   185,   186,   187,   188,   189,   190,
03064      191,     0,   192,   193,   562,   563,     0,     0,   564,     0,
03065      194,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03066      165,   166,   167,   168,   169,   170,   171,   172,   173,     0,
03067        0,   174,   175,     0,     0,   176,   177,   178,   179,     0,
03068        0,     0,     0,     0,     0,     0,     0,     0,     0,   180,
03069      181,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03070        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03071      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
03072        0,   192,   193,   599,   563,     0,     0,   600,     0,   194,
03073        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
03074      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
03075      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
03076        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
03077        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03078        0,     0,     0,     0,     0,     0,     0,     0,     0,   182,
03079      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
03080      192,   193,   613,   555,     0,     0,   614,     0,   194,     0,
03081        0,     0,     0,     0,     0,     0,     0,     0,   165,   166,
03082      167,   168,   169,   170,   171,   172,   173,     0,     0,   174,
03083      175,     0,     0,   176,   177,   178,   179,     0,     0,     0,
03084        0,     0,     0,     0,     0,     0,     0,   180,   181,     0,
03085        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03086        0,     0,     0,     0,     0,     0,     0,     0,   182,   183,
03087      184,   185,   186,   187,   188,   189,   190,   191,     0,   192,
03088      193,   616,   563,     0,     0,   617,     0,   194,     0,     0,
03089        0,     0,     0,     0,     0,     0,     0,   165,   166,   167,
03090      168,   169,   170,   171,   172,   173,     0,     0,   174,   175,
03091        0,     0,   176,   177,   178,   179,     0,     0,     0,     0,
03092        0,     0,     0,     0,     0,     0,   180,   181,     0,     0,
03093        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03094        0,     0,     0,     0,     0,     0,     0,   182,   183,   184,
03095      185,   186,   187,   188,   189,   190,   191,     0,   192,   193,
03096      640,   555,     0,     0,   641,     0,   194,     0,     0,     0,
03097        0,     0,     0,     0,     0,     0,   165,   166,   167,   168,
03098      169,   170,   171,   172,   173,     0,     0,   174,   175,     0,
03099        0,   176,   177,   178,   179,     0,     0,     0,     0,     0,
03100        0,     0,     0,     0,     0,   180,   181,     0,     0,     0,
03101        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03102        0,     0,     0,     0,     0,     0,   182,   183,   184,   185,
03103      186,   187,   188,   189,   190,   191,     0,   192,   193,   643,
03104      563,     0,     0,   644,     0,   194,     0,     0,     0,     0,
03105        0,     0,     0,     0,     0,   165,   166,   167,   168,   169,
03106      170,   171,   172,   173,     0,     0,   174,   175,     0,     0,
03107      176,   177,   178,   179,     0,     0,     0,     0,     0,     0,
03108        0,     0,     0,     0,   180,   181,     0,     0,     0,     0,
03109        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03110        0,     0,     0,     0,     0,   182,   183,   184,   185,   186,
03111      187,   188,   189,   190,   191,     0,   192,   193,   728,   555,
03112        0,     0,   729,     0,   194,     0,     0,     0,     0,     0,
03113        0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
03114      171,   172,   173,     0,     0,   174,   175,     0,     0,   176,
03115      177,   178,   179,     0,     0,     0,     0,     0,     0,     0,
03116        0,     0,     0,   180,   181,     0,     0,     0,     0,     0,
03117        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03118        0,     0,     0,     0,   182,   183,   184,   185,   186,   187,
03119      188,   189,   190,   191,     0,   192,   193,   731,   563,     0,
03120        0,   732,     0,   194,     0,     0,     0,     0,     0,     0,
03121        0,     0,     0,   165,   166,   167,   168,   169,   170,   171,
03122      172,   173,     0,     0,   174,   175,     0,     0,   176,   177,
03123      178,   179,     0,     0,     0,     0,     0,     0,     0,     0,
03124        0,     0,   180,   181,     0,     0,     0,     0,     0,     0,
03125        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03126        0,     0,     0,   182,   183,   184,   185,   186,   187,   188,
03127      189,   190,   191,     0,   192,   193,   738,   555,     0,     0,
03128      739,     0,   194,     0,     0,     0,     0,     0,     0,     0,
03129        0,     0,   165,   166,   167,   168,   169,   170,   171,   172,
03130      173,     0,     0,   174,   175,     0,     0,   176,   177,   178,
03131      179,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03132        0,   180,   181,     0,     0,     0,     0,     0,     0,     0,
03133        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03134        0,     0,   182,   183,   184,   185,   186,   187,   188,   189,
03135      190,   191,     0,   192,   193,  1007,   555,     0,     0,  1008,
03136        0,   194,     0,     0,     0,     0,     0,     0,     0,     0,
03137        0,   165,   166,   167,   168,   169,   170,   171,   172,   173,
03138        0,     0,   174,   175,     0,     0,   176,   177,   178,   179,
03139        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03140      180,   181,     0,     0,     0,     0,     0,     0,     0,     0,
03141        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03142        0,   182,   183,   184,   185,   186,   187,   188,   189,   190,
03143      191,     0,   192,   193,  1040,   555,     0,     0,  1041,     0,
03144      194,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03145      165,   166,   167,   168,   169,   170,   171,   172,   173,     0,
03146        0,   174,   175,     0,     0,   176,   177,   178,   179,     0,
03147        0,     0,     0,     0,     0,     0,     0,     0,     0,   180,
03148      181,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03149        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03150      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
03151        0,   192,   193,  1043,   563,     0,     0,  1044,     0,   194,
03152        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
03153      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
03154      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
03155        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
03156      329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
03157      339,   340,   341,     0,     0,   342,   343,     0,     0,   182,
03158      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
03159      192,   193,     0,     0,     0,     0,     0,     0,   194,     0,
03160        0,     0,     0,     0,     0,     0,   344,     0,   345,   346,
03161      347,   348,   349,   350,   351,   352,   353,   354,     0,     0,
03162        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03163        0,     0,     0,   234
03164 };
03165 
03166 #define yypact_value_is_default(yystate) \
03167   ((yystate) == (-813))
03168 
03169 #define yytable_value_is_error(yytable_value) \
03170   ((yytable_value) == (-628))
03171 
03172 static const yytype_int16 yycheck[] =
03173 {
03174        2,    27,    98,    29,    57,    81,    16,    17,     8,    76,
03175       20,     8,    16,    17,     8,   328,    20,   361,    89,    22,
03176      576,    92,    51,    28,   414,    88,    89,   328,    28,    92,
03177      422,    28,   422,     4,    28,    54,   355,   578,   357,   356,
03178       55,    69,   223,    96,   670,     2,    92,     4,   575,    53,
03179      615,    53,    54,   378,    65,   595,    69,     2,   265,     4,
03180       57,   778,   269,    55,    92,   233,    81,    51,   460,   473,
03181      686,    16,    17,    76,   469,    20,   787,   642,    93,    94,
03182       95,   442,   401,   508,    13,   716,   511,    66,   872,   720,
03183      258,    25,    27,   261,   906,   253,    63,    78,   417,    96,
03184      419,   418,    29,    89,   874,    25,    51,    63,   143,    87,
03185       55,     0,   775,    87,    16,    17,    89,   138,    20,    25,
03186      132,    66,   143,    26,   519,    13,   445,    87,    56,   115,
03187       37,    38,    28,    25,    16,    17,    81,   800,    20,   120,
03188       13,    99,   115,    88,    89,   112,    25,    92,    93,    94,
03189       95,    53,    54,   472,   471,   939,   112,   135,   102,    13,
03190       25,   135,   778,   136,   122,   730,    25,   325,    26,   139,
03191      233,   787,   235,   143,   134,   135,   741,   206,   895,   246,
03192      806,   807,    13,   142,   725,   204,   113,    25,   207,   208,
03193      209,    52,   289,    13,   291,    56,   293,   737,   274,   262,
03194      297,   742,   136,  1015,   138,   745,   141,   136,   143,   255,
03195      994,   240,   141,     1,   143,   217,   136,   227,   138,   229,
03196      230,   223,   992,   227,   253,   229,   142,   255,   230,   132,
03197      136,   623,   622,   623,   951,   946,   143,   142,   309,   310,
03198      311,   312,   255,  1027,   136,   271,   309,   310,   311,   312,
03199      431,   314,   315,   141,   658,   143,   424,   136,   884,   274,
03200      428,   206,   273,   582,   581,   433,   691,   592,   141,   253,
03201      143,   136,   633,   902,   132,   594,   593,   136,   142,   895,
03202      138,   449,   227,   115,   229,   230,   902,   141,   233,   143,
03203      235,   362,   363,  1010,   251,   240,   325,   928,   136,   362,
03204      363,    25,   697,   844,   323,   846,   251,   138,   253,   328,
03205      141,   326,   143,    25,   377,   856,   115,   262,   364,   323,
03206      861,   141,    89,   143,   328,   227,   853,   229,   136,   274,
03207      946,   119,    89,    89,   326,   658,   364,   308,    26,   965,
03208      744,   325,   746,   136,   323,   227,   356,   229,   115,   328,
03209      518,   308,   380,   141,   356,   143,   313,   138,    87,   115,
03210      357,    37,    38,   308,   309,   310,   311,   312,   313,   314,
03211      315,   141,   928,   143,  1003,    89,    25,   115,   323,    87,
03212      325,   326,   726,   328,   925,   926,    56,  1003,    87,   486,
03213      930,   115,    26,   469,   413,   414,   493,   698,   136,    87,
03214      115,   115,   715,   422,   401,   134,   135,    70,   418,    63,
03215       63,   356,   136,   358,   136,   139,   418,   362,   363,   143,
03216      136,   744,   419,   746,   136,   404,   405,   135,   430,   431,
03217      637,   612,   377,    90,   439,   134,   135,    89,   457,   439,
03218      442,   460,   439,   519,   132,   439,   134,   135,   445,   990,
03219      138,   991,   138,    87,   469,   109,   109,   111,   111,   404,
03220      405,   471,   125,   126,   127,   136,   115,   136,   636,   471,
03221       89,    87,   143,   418,   143,   472,   868,  1042,   868,    63,
03222      138,    87,  1023,    67,  1025,   442,   132,   136,   142,   142,
03223      139,   558,    70,   512,   143,    70,   115,   442,   132,   566,
03224      134,   135,   138,   136,   519,   507,   508,   452,   139,   511,
03225      143,    52,   414,    54,    55,    56,    57,   543,   672,   135,
03226      674,    26,    87,   115,   469,   109,   471,   111,   134,   135,
03227      704,    26,   138,   596,   601,   561,    52,   711,    54,    55,
03228       56,    57,   571,   140,   573,    87,   574,   575,   123,   124,
03229      125,   126,   127,   133,    87,   457,   559,    15,   577,    17,
03230      588,    89,   638,   626,   567,    63,    56,   569,   136,   134,
03231      135,   581,   916,   577,   519,   743,    63,   112,   922,   581,
03232      761,   112,    87,   593,    70,   582,    63,   115,   112,   615,
03233      609,   593,    87,   135,   762,   136,   473,   594,   601,   601,
03234      112,   606,   135,   622,   623,   773,   606,    87,   136,   606,
03235      612,   109,   606,   111,   112,    89,   642,   686,    96,    87,
03236      136,   697,   109,   638,   111,   112,   571,   132,   573,   134,
03237      135,   633,   109,   138,   111,   112,   581,   132,   705,   134,
03238      135,   115,   686,   138,    58,   712,    89,   666,   593,    87,
03239      595,   596,    87,   749,   134,   135,    70,    87,   687,    17,
03240      686,   690,   733,   692,   136,   736,   668,   135,   670,    87,
03241      733,   141,   115,   736,    56,   694,   633,    87,    14,    15,
03242       25,   626,   697,   139,    98,    99,   136,   136,   633,   691,
03243      132,    87,   860,   638,   747,   136,   715,   135,   142,   134,
03244      135,  1020,  1019,   871,   730,   135,   734,    87,   122,   133,
03245      712,   715,   781,   715,   716,   741,   718,   135,   720,   698,
03246      622,    63,   701,   702,   134,   135,   142,   881,   882,   708,
03247      709,    87,   886,   136,   888,    87,   890,   781,   134,   135,
03248       89,   785,   687,   136,   136,   690,   136,   692,    63,   775,
03249      747,   115,   697,   698,   134,   135,   701,   702,   777,   761,
03250       87,   138,   686,   708,   709,    10,   115,   109,    87,   111,
03251      112,     8,   843,   686,   800,   652,    89,    89,   134,   135,
03252      843,   658,   134,   135,    13,   138,   815,   136,   733,   804,
03253      133,   736,   737,   115,   109,    89,   111,   112,   817,     2,
03254      745,     4,   115,   115,   806,   807,    89,   134,   135,   686,
03255      136,   840,   136,    16,    17,   134,   135,    20,   847,   848,
03256       52,   115,   851,   136,   136,   853,   895,   855,   136,    54,
03257      899,   850,   115,   902,   862,   904,   838,   136,    52,   841,
03258       65,    66,   136,   136,   998,   999,  1000,  1001,    51,   868,
03259      829,   895,    52,   136,   136,   899,   117,    15,   902,   804,
03260      904,   140,   891,    66,   136,    70,   133,   744,   136,   746,
03261      815,   120,   115,   136,   787,   141,   136,   790,   136,   894,
03262       85,    86,   884,   136,   829,    88,    89,    10,    10,    92,
03263      919,   133,   769,   770,    90,   840,  1050,   136,   843,     9,
03264      915,   778,   847,   848,   139,   136,   851,   120,   136,   136,
03265      787,    56,   136,   136,   943,   944,   133,   122,   123,   124,
03266      125,   126,   127,   110,   136,    52,   928,    54,    55,    56,
03267       57,    56,   136,    10,  1003,   136,  1005,   136,   136,    54,
03268       55,  1010,    57,  1012,   136,   971,   891,   136,   133,   894,
03269       65,    66,   981,   136,   983,   136,   138,    70,   138,  1003,
03270      989,  1005,    93,   965,    91,    95,  1010,   452,  1012,   712,
03271      915,   895,    85,    86,   919,   899,   686,  1022,   902,   769,
03272      904,   809,   810,  1052,  1015,   930,   750,  1021,   297,   902,
03273      101,   904,    59,    96,   936,   872,   781,   874,   943,   944,
03274      899,   895,    52,   206,    54,    55,    56,    57,  1052,  1019,
03275      123,   124,   125,   126,   127,   778,  1042,  1019,   895,  1021,
03276     1022,    -1,   398,  1020,   227,   902,   229,   230,    -1,    -1,
03277      233,    -1,   235,   946,    -1,   948,   981,   240,   983,    -1,
03278      953,    91,    -1,    -1,   989,    -1,   991,    97,   251,    -1,
03279      253,    -1,    52,    -1,    54,    55,    56,    57,    -1,   262,
03280       -1,    -1,   939,   940,    59,    60,    61,    62,    52,   946,
03281       54,    55,    56,    57,  1019,    -1,    -1,    -1,    -1,  1003,
03282       -1,  1005,    -1,    -1,    -1,    -1,  1010,    -1,  1012,    -1,
03283     1003,    91,  1005,    -1,    -1,    -1,    -1,    97,    -1,  1012,
03284       40,    41,    42,    43,    44,   308,   309,   310,   311,   312,
03285      313,   314,   315,    -1,    -1,   992,    -1,   994,  1031,    -1,
03286      323,    -1,   325,    -1,    -1,   328,  1003,    -1,  1052,    -1,
03287       -1,    -1,   960,   961,    -1,    -1,    -1,    -1,   966,  1052,
03288      968,   969,    -1,    16,    17,    -1,    -1,    20,    -1,    -1,
03289     1027,    -1,    -1,   356,    -1,   358,    -1,    -1,    -1,   362,
03290      363,    -1,    -1,    -1,    -1,    -1,    -1,    52,    -1,    54,
03291       55,    56,    57,    58,   377,    48,    49,    -1,    -1,    -1,
03292       53,    54,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,
03293       -1,    -1,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03294       -1,   404,   405,    -1,    -1,    -1,    91,  1035,  1036,  1037,
03295     1038,    -1,    97,    98,    99,   418,    52,    -1,    54,    55,
03296       56,    57,    58,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03297     1058,    -1,    -1,    -1,    70,    -1,    -1,   122,    -1,   442,
03298      125,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   452,
03299       -1,    -1,    -1,    -1,    -1,    91,     0,    -1,   143,    -1,
03300       -1,    97,    98,    99,     8,     9,    10,    -1,   471,    13,
03301       14,    15,    52,    17,    54,    55,    56,    57,    58,    -1,
03302       -1,    -1,    26,    27,    -1,    -1,   122,    -1,    -1,   125,
03303       70,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03304       44,    -1,   138,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03305       -1,    91,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,
03306       -1,    -1,    -1,     2,    -1,     4,    -1,    -1,    -1,    -1,
03307       -1,   204,    -1,    -1,   207,   208,   209,   210,    -1,    -1,
03308       -1,    -1,   122,    87,    -1,   125,    -1,    -1,    -1,    -1,
03309       -1,    -1,    -1,    -1,   227,    -1,   229,   230,    -1,    52,
03310       -1,    54,    55,    56,    57,    58,   110,    -1,   571,    -1,
03311      573,    -1,    51,    -1,    -1,    -1,    55,    70,   581,    -1,
03312       -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,   132,   133,
03313      593,   135,   595,   596,   138,   139,    -1,   141,    91,   143,
03314       85,    86,    81,    -1,    -1,    98,    99,    -1,    -1,    -1,
03315       -1,    -1,    -1,    -1,    93,    94,    95,    96,    -1,    -1,
03316       -1,    -1,    -1,   626,    -1,    -1,    -1,    -1,    -1,   122,
03317      633,    -1,    -1,    -1,    -1,   120,   121,   122,   123,   124,
03318      125,   126,   127,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03319      323,    -1,    -1,    -1,    -1,   328,   329,   330,   331,   332,
03320      333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
03321      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
03322      353,   354,    -1,   356,   687,    -1,    -1,   690,    -1,   692,
03323       -1,    -1,    -1,    -1,    -1,   698,    -1,    -1,   701,   702,
03324       -1,    -1,    -1,    -1,    -1,   708,   709,    -1,    -1,    -1,
03325       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03326       -1,    -1,    -1,    -1,    -1,    -1,     2,   206,     4,    -1,
03327      733,   404,   405,   736,   737,    -1,    -1,    -1,    -1,   412,
03328      413,   414,   745,    -1,    -1,   418,    -1,   420,   421,   422,
03329       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03330       -1,   240,    -1,    -1,    -1,    -1,    -1,    -1,   441,    -1,
03331       -1,    -1,   251,   446,   253,    51,    -1,    -1,    -1,    55,
03332       -1,    -1,    -1,    -1,   457,    -1,    -1,   460,    -1,    -1,
03333       -1,    -1,    -1,    -1,    -1,   274,    -1,    -1,   471,    -1,
03334       -1,    -1,    -1,    -1,    -1,    81,     2,    -1,     4,    -1,
03335       -1,    -1,   815,    -1,    -1,    -1,    -1,    93,    94,    95,
03336       96,    -1,    -1,    -1,   497,    -1,   829,    -1,    -1,   308,
03337       -1,    -1,    -1,    -1,   313,    -1,    -1,   840,    -1,   512,
03338      843,    -1,    -1,    -1,   847,   848,   325,   326,   851,    -1,
03339       -1,    -1,    -1,    -1,    -1,    51,    -1,    -1,    -1,    55,
03340       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03341       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,
03342       -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,   891,    -1,
03343       -1,    -1,    -1,    -1,    -1,    -1,    -1,    93,    94,    95,
03344       -1,    -1,    -1,    -1,   577,    -1,    -1,    -1,   581,    -1,
03345       -1,    -1,    -1,    -1,    -1,    -1,   919,    -1,    -1,    -1,
03346      593,    -1,    -1,    -1,    -1,    -1,    -1,   930,    -1,    -1,
03347      206,    -1,    -1,    -1,    -1,    -1,   609,    -1,    -1,    -1,
03348      943,   944,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   622,
03349      623,    70,    71,    72,    73,    74,    75,    76,    77,    -1,
03350       79,    80,    -1,   442,   240,    -1,    85,    86,    -1,    -1,
03351       -1,    -1,    -1,   452,    -1,   251,    -1,   253,   981,    -1,
03352      983,    -1,    -1,    -1,    -1,     2,   989,     4,   991,    -1,
03353      469,    -1,    -1,   666,    -1,    -1,    -1,    -1,   274,   118,
03354      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03355      206,    -1,    -1,    -1,    -1,    -1,  1019,    -1,    -1,    -1,
03356       -1,   694,    -1,    -1,    -1,   698,   699,    -1,   701,   702,
03357       -1,    -1,   308,    -1,    51,   708,   709,   313,    -1,    -1,
03358      519,    -1,   715,    -1,   240,    -1,    -1,    -1,    -1,   325,
03359      326,    -1,    -1,    -1,    -1,   251,    -1,   253,    -1,    -1,
03360       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03361       -1,    -1,    -1,    -1,    -1,    -1,    93,    -1,   274,   752,
03362       -1,    -1,   358,   756,   757,    -1,   759,   760,    -1,    -1,
03363       -1,    -1,   571,    -1,   573,    -1,    -1,    -1,    -1,    -1,
03364       -1,    -1,    -1,    -1,   777,    -1,    -1,    -1,    -1,    -1,
03365       -1,    -1,   308,    -1,    -1,    -1,   595,   313,    -1,    -1,
03366       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   325,
03367      326,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03368       -1,    -1,    -1,    -1,   817,    -1,    -1,     2,   821,     4,
03369       -1,    -1,    -1,    -1,   633,    -1,   829,    -1,    -1,   638,
03370       -1,    -1,   358,    -1,    -1,    -1,   442,    -1,    -1,    -1,
03371       -1,    -1,    -1,    -1,    -1,    -1,   452,   850,    -1,    -1,
03372       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   206,
03373       -1,    -1,    -1,   469,   867,   868,    51,    -1,    -1,    -1,
03374       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   687,    -1,
03375       -1,   690,    -1,   692,    -1,    -1,    -1,    -1,   697,    -1,
03376       -1,    -1,    -1,   240,    -1,    -1,    -1,    -1,    -1,    -1,
03377       -1,    -1,    -1,    -1,   251,    -1,   253,    -1,    -1,    -1,
03378       -1,    -1,    -1,   519,    -1,    -1,   442,    -1,    -1,    -1,
03379       -1,    -1,    44,    -1,    -1,    -1,   452,    -1,   737,    -1,
03380       -1,    -1,    -1,    -1,    -1,    -1,   745,    -1,    -1,    -1,
03381       -1,    -1,    -1,   469,    -1,    -1,    -1,    -1,    70,    71,
03382       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03383       82,   308,    -1,    85,    86,   571,   313,   573,    -1,    -1,
03384       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   325,    -1,
03385       -1,   328,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   595,
03386       -1,    -1,    -1,   519,   116,   804,   118,   119,   120,   121,
03387      122,   123,   124,   125,   126,   127,   815,    -1,    -1,    -1,
03388       -1,   358,    -1,    -1,   136,    -1,  1019,    -1,    -1,    -1,
03389       -1,   206,    -1,    -1,    -1,    -1,    -1,   633,    -1,    -1,
03390       -1,   840,   638,    -1,    -1,    -1,    -1,    -1,   847,   848,
03391       -1,    -1,   851,    -1,    -1,   571,    -1,   573,    -1,    -1,
03392       -1,    -1,    -1,    -1,    -1,   240,    -1,    -1,    -1,    -1,
03393       -1,    -1,    -1,    -1,    -1,    -1,   251,    -1,   253,   595,
03394       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03395       -1,   687,   891,    -1,   690,   894,   692,    -1,    -1,    -1,
03396       -1,   697,    -1,    -1,    -1,   442,    -1,    -1,    -1,    -1,
03397       -1,    -1,    -1,    -1,    -1,   452,   915,   633,    -1,    -1,
03398      919,    -1,   638,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03399       -1,   930,    -1,   308,    -1,    -1,    -1,    -1,   313,    -1,
03400       -1,   737,    -1,    -1,   943,   944,    -1,    -1,    -1,   745,
03401      325,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03402       -1,    -1,   678,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03403       -1,   687,    -1,    -1,   690,    -1,   692,    -1,    -1,    -1,
03404       -1,   697,   981,   358,   983,    -1,    -1,    -1,    -1,    -1,
03405      989,    -1,   991,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03406       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   804,    -1,
03407       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   815,
03408       -1,   737,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   745,
03409       -1,    -1,    -1,    -1,   571,    -1,   573,    -1,    -1,    -1,
03410       -1,    -1,    -1,    -1,   840,    -1,    -1,    -1,    -1,    -1,
03411       -1,   847,   848,    -1,    -1,   851,    -1,    -1,   595,    70,
03412       71,    72,    73,    74,    75,    76,    -1,   442,    79,    80,
03413       -1,    -1,    -1,    -1,    85,    86,    -1,   452,    -1,    -1,
03414       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   804,    -1,
03415       -1,    -1,    -1,    -1,    -1,   891,   633,    -1,   894,   815,
03416       -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,
03417      121,   122,   123,   124,   125,   126,   127,    -1,    -1,   915,
03418       -1,    -1,    -1,   919,   840,    -1,    -1,    -1,    -1,    -1,
03419       -1,   847,   848,    -1,   930,   851,    -1,    -1,    -1,    -1,
03420       -1,    -1,    -1,    -1,    -1,    -1,    -1,   943,   944,    -1,
03421      687,    -1,    -1,   690,    -1,   692,    -1,    -1,    -1,    -1,
03422       -1,   698,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03423       -1,    -1,    -1,    -1,    -1,   891,    -1,    -1,   894,    -1,
03424       -1,    -1,    -1,    -1,    -1,   981,    -1,   983,    -1,    -1,
03425       -1,    -1,    -1,   989,    -1,   991,   571,    -1,   573,   915,
03426      737,    -1,    -1,   919,    -1,    -1,    -1,    -1,   745,     0,
03427       -1,    -1,    -1,    -1,   930,    -1,    -1,     8,     9,    10,
03428      595,    -1,    13,    14,    15,    -1,    17,   943,   944,    -1,
03429       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,    -1,
03430       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03431       41,    42,    43,    44,    -1,    -1,    -1,    -1,   633,    -1,
03432       -1,    -1,    -1,    -1,    -1,   981,    -1,   983,    -1,    -1,
03433       -1,    -1,    -1,   989,    -1,   991,    -1,    -1,   815,    70,
03434       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03435       81,    82,    -1,    -1,    85,    86,    87,    -1,    89,    90,
03436       -1,    -1,    -1,   840,    -1,    96,    -1,    -1,    -1,    -1,
03437      847,   848,   687,    -1,   851,   690,    -1,   692,    -1,   110,
03438       -1,    -1,   113,    -1,   115,   116,   117,   118,   119,   120,
03439      121,   122,   123,   124,   125,   126,   127,    -1,    -1,    -1,
03440       -1,   132,   133,   134,   135,   136,    -1,    -1,   139,   140,
03441      141,    -1,   143,    -1,   891,    -1,    -1,    -1,    -1,    -1,
03442       -1,    -1,   737,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03443      745,    70,    71,    72,    73,    74,    75,    76,   915,    -1,
03444       79,    80,   919,    -1,    -1,    -1,    85,    86,    -1,    -1,
03445       -1,    -1,    -1,   930,    -1,    -1,    -1,    -1,    -1,    -1,
03446       -1,    -1,    -1,    -1,    -1,    -1,   943,   944,    -1,    -1,
03447       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
03448      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03449       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03450      815,    -1,    -1,    -1,   981,    -1,   983,    -1,    -1,    -1,
03451       -1,    -1,   989,    -1,   991,    -1,    -1,    -1,    -1,    -1,
03452       -1,    -1,    -1,    -1,    -1,   840,    -1,    -1,    -1,    -1,
03453       -1,    -1,   847,   848,    -1,    -1,   851,    -1,    -1,    -1,
03454       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03455       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03456       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03457       -1,    -1,    -1,    -1,    -1,    -1,   891,    -1,    -1,    -1,
03458       -1,    -1,    -1,    -1,    -1,    -1,    -1,     0,     1,    -1,
03459        3,     4,     5,     6,     7,    -1,    -1,    -1,    11,    12,
03460       -1,    -1,    -1,    16,   919,    18,    19,    20,    21,    22,
03461       23,    24,    -1,    -1,    -1,   930,    -1,    30,    31,    32,
03462       33,    34,    35,    36,    -1,    -1,    39,    -1,   943,   944,
03463       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03464       53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
03465       -1,    64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,
03466       -1,    -1,    -1,    -1,    -1,    -1,   981,    -1,   983,    -1,
03467       -1,    -1,    -1,    -1,   989,    88,   991,    -1,    91,    92,
03468       -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,   102,
03469      103,   104,   105,   106,   107,   108,     0,    -1,    -1,    -1,
03470       -1,    -1,    -1,    -1,     8,     9,    10,    -1,    -1,    13,
03471       14,    15,    -1,    17,    -1,   128,   129,   130,    -1,    44,
03472       -1,    25,    -1,    27,    28,    29,    -1,    -1,   141,    -1,
03473      143,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03474       44,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
03475       75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
03476       85,    86,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
03477       74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
03478       -1,    85,    86,    87,    -1,    89,    90,    -1,    -1,    -1,
03479       -1,   116,    96,   118,   119,   120,   121,   122,   123,   124,
03480      125,   126,   127,    -1,    -1,    -1,   110,    -1,    -1,   113,
03481       -1,   115,   116,   117,   118,   119,   120,   121,   122,   123,
03482      124,   125,   126,   127,    -1,    -1,    -1,    -1,    -1,   133,
03483      134,   135,   136,     0,    -1,   139,   140,   141,    -1,   143,
03484       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03485       17,    -1,    -1,    -1,    -1,    -1,    44,    -1,    25,    -1,
03486       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03487       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03488       -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
03489       78,    79,    80,    81,    82,    -1,    -1,    85,    86,    -1,
03490       -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
03491       77,    78,    79,    80,    81,    82,    -1,    -1,    85,    86,
03492       87,    -1,    89,    90,    -1,    -1,    -1,    -1,   116,    96,
03493      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
03494       -1,    -1,    -1,   110,    -1,    -1,   113,    -1,   115,   116,
03495      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
03496      127,    -1,    -1,    -1,    -1,    -1,   133,   134,   135,   136,
03497        0,    -1,   139,   140,   141,    -1,   143,    -1,     8,     9,
03498       10,    -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,
03499       -1,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,
03500       -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,
03501       40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,    70,
03502       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03503       81,    82,    -1,    -1,    85,    86,    -1,    -1,    -1,    -1,
03504       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03505       80,    81,    82,    -1,    -1,    85,    86,    87,    -1,    -1,
03506       90,    -1,    -1,    -1,    -1,   116,    96,   118,   119,   120,
03507      121,   122,   123,   124,   125,   126,   127,    -1,    -1,    -1,
03508      110,    -1,    -1,   113,    -1,    -1,   116,   117,   118,   119,
03509      120,   121,   122,   123,   124,   125,   126,   127,    -1,    -1,
03510       -1,    -1,   132,   133,   134,   135,   136,     0,    -1,   139,
03511      140,   141,    -1,   143,    -1,     8,     9,    10,    -1,    -1,
03512       13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,
03513       -1,    -1,    -1,    26,    27,    28,    29,    -1,    -1,    -1,
03514       -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,
03515       43,    44,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
03516       74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
03517       -1,    85,    86,    -1,    -1,    -1,    -1,    70,    71,    72,
03518       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
03519       -1,    -1,    85,    86,    87,    -1,    -1,    90,    -1,    -1,
03520       -1,    -1,    -1,    96,   118,   119,   120,   121,   122,   123,
03521      124,   125,   126,   127,    -1,    -1,    -1,   110,    -1,    -1,
03522      113,    -1,    -1,   116,   117,   118,   119,   120,   121,   122,
03523      123,   124,   125,   126,   127,    -1,    -1,    -1,    -1,   132,
03524      133,   134,   135,   136,     0,    -1,   139,   140,   141,    -1,
03525      143,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03526       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03527       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03528       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03529       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03530       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03531       -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
03532       76,    77,    78,    79,    80,    81,    82,    -1,    -1,    85,
03533       86,    87,    -1,    89,    90,    -1,    -1,    -1,    -1,    -1,
03534       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03535       -1,    -1,    -1,    -1,   110,    -1,    -1,   113,    -1,   115,
03536      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03537      126,   127,    -1,    -1,    -1,    -1,    -1,   133,   134,   135,
03538      136,     0,    -1,   139,   140,   141,    -1,   143,    -1,     8,
03539        9,    10,    -1,    -1,    13,    14,    15,    -1,    17,    -1,
03540       -1,    -1,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,
03541       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,
03542       -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
03543       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03544       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03545       -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
03546       79,    80,    81,    82,    -1,    -1,    85,    86,    87,    -1,
03547       -1,    90,    -1,    -1,    -1,    -1,    -1,    96,    -1,    -1,
03548       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03549       -1,   110,    -1,    -1,    -1,    -1,    -1,   116,    -1,   118,
03550      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03551       -1,    -1,    -1,   132,   133,   134,   135,   136,     0,   138,
03552      139,   140,   141,    -1,   143,    -1,     8,     9,    10,    -1,
03553       -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03554       -1,    -1,    -1,    -1,    -1,    27,    28,    29,    -1,    -1,
03555       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03556       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03557       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03558       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,
03559       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03560       82,    -1,    -1,    85,    86,    87,    -1,    -1,    90,    -1,
03561       -1,    -1,    -1,    -1,    96,    -1,    -1,    -1,    -1,    -1,
03562       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,
03563       -1,   113,    -1,    -1,   116,   117,   118,   119,   120,   121,
03564      122,   123,   124,   125,   126,   127,    -1,    -1,    -1,    -1,
03565       -1,   133,   134,   135,   136,     0,    -1,   139,   140,   141,
03566       -1,   143,    -1,     8,     9,    10,    -1,    -1,    13,    14,
03567       15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03568       -1,    26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
03569       -1,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03570       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03571       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03572       -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
03573       75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
03574       85,    86,    87,    -1,    -1,    90,    -1,    -1,    -1,    -1,
03575       -1,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03576       -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,    -1,    -1,
03577       -1,   116,    -1,   118,   119,   120,   121,   122,   123,   124,
03578      125,   126,   127,    -1,    -1,    -1,    -1,   132,   133,   134,
03579      135,   136,     0,   138,   139,   140,   141,    -1,   143,    -1,
03580        8,     9,    10,    -1,    -1,    13,    14,    15,    -1,    17,
03581       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    27,
03582       28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,
03583       38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
03584       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03585       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03586       -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
03587       78,    79,    80,    81,    82,    -1,    -1,    85,    86,    87,
03588       -1,    -1,    90,    -1,    -1,    -1,    -1,    -1,    96,    -1,
03589       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03590       -1,    -1,   110,    -1,    -1,    -1,    -1,    -1,   116,    -1,
03591      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
03592       -1,    -1,    -1,    -1,    -1,   133,   134,   135,   136,     0,
03593      138,   139,   140,   141,    -1,   143,    -1,     8,     9,    10,
03594       -1,    -1,    -1,    14,    15,    -1,    17,    -1,    -1,    -1,
03595       -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,
03596       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03597       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03598       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03599       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
03600       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03601       81,    82,    -1,    -1,    85,    86,    87,    -1,    89,    -1,
03602       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03603       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
03604       -1,    -1,    -1,    -1,   115,   116,    -1,   118,   119,   120,
03605      121,   122,   123,   124,   125,   126,   127,    -1,    -1,    -1,
03606       -1,   132,   133,   134,   135,   136,     0,    -1,   139,    -1,
03607      141,    -1,   143,    -1,     8,     9,    10,    -1,    -1,    -1,
03608       14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,
03609       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03610       -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03611       44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03612       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03613       -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
03614       74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
03615       -1,    85,    86,    87,    -1,    89,    -1,    -1,    -1,    -1,
03616       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03617       -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,    -1,
03618       -1,   115,   116,    -1,   118,   119,   120,   121,   122,   123,
03619      124,   125,   126,   127,    -1,    -1,    -1,    -1,    -1,   133,
03620      134,   135,   136,    -1,    -1,   139,    -1,   141,     1,   143,
03621        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
03622       -1,    -1,    15,    16,    -1,    18,    19,    20,    21,    22,
03623       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03624       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03625       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03626       53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
03627       -1,    64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,
03628       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03629       -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,
03630       -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,   102,
03631      103,   104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,
03632       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03633       -1,    -1,    -1,    -1,    -1,   128,   129,   130,    -1,    -1,
03634       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     1,
03635      143,     3,     4,     5,     6,     7,    -1,    -1,    10,    11,
03636       12,    -1,    14,    15,    16,    -1,    18,    19,    20,    21,
03637       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03638       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03639       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03640       52,    53,    54,    55,    56,    57,    -1,    59,    60,    61,
03641       62,    -1,    64,    65,    66,    -1,    68,    69,    -1,    -1,
03642       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03643       -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    91,
03644       92,    -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,
03645      102,   103,   104,   105,   106,   107,   108,    -1,    -1,    -1,
03646       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03647       -1,    -1,    -1,    -1,    -1,    -1,   128,   129,   130,    -1,
03648       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,
03649        1,   143,     3,     4,     5,     6,     7,    -1,    -1,    10,
03650       11,    12,    -1,    -1,    15,    16,    17,    18,    19,    20,
03651       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03652       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03653       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
03654       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03655       61,    62,    -1,    64,    65,    66,    -1,    68,    69,    -1,
03656       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03657       -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,
03658       91,    92,    -1,    94,    95,    -1,    97,    -1,    -1,   100,
03659      101,   102,   103,   104,   105,   106,   107,   108,    -1,    -1,
03660       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03661       -1,    -1,    -1,    -1,    -1,    -1,    -1,   128,   129,   130,
03662       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03663      141,     1,   143,     3,     4,     5,     6,     7,    -1,    -1,
03664       10,    11,    12,    -1,    -1,    15,    16,    -1,    18,    19,
03665       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03666       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03667       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03668       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03669       60,    61,    62,    -1,    64,    65,    66,    -1,    68,    69,
03670       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03671       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
03672       -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,    -1,
03673      100,   101,   102,   103,   104,   105,   106,   107,   108,    -1,
03674       -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,
03675        5,     6,     7,    -1,     9,    10,    11,    12,   128,   129,
03676      130,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03677       -1,   141,    -1,   143,    -1,    30,    31,    32,    33,    34,
03678       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03679       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03680       55,    56,    57,    -1,    59,    60,    61,    62,    -1,    64,
03681       65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,    -1,
03682       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03683       -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,
03684       95,    -1,    97,    -1,    -1,   100,   101,   102,   103,   104,
03685      105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,    -1,
03686       -1,     1,    -1,     3,     4,     5,     6,     7,    -1,    -1,
03687       -1,    11,    12,   128,   129,   130,    16,    -1,    18,    19,
03688       20,    21,    22,    23,    24,    -1,   141,    -1,   143,    -1,
03689       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03690       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03691       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03692       60,    61,    62,    -1,    64,    65,    66,    -1,    68,    69,
03693       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03694       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
03695       -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,    -1,
03696      100,   101,   102,   103,   104,   105,   106,   107,   108,    -1,
03697       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03698       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   128,   129,
03699      130,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   139,
03700       -1,   141,     1,   143,     3,     4,     5,     6,     7,    -1,
03701       -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,    18,
03702       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03703       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03704       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03705       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03706       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03707       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03708       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03709       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
03710       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03711       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03712       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   128,
03713      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03714      139,    -1,   141,     1,   143,     3,     4,     5,     6,     7,
03715       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,
03716       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03717       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03718       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03719       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03720       -1,    59,    60,    61,    62,    -1,    64,    65,    66,    -1,
03721       68,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03722       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03723       88,    -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,
03724       -1,    -1,   100,   101,   102,   103,   104,   105,   106,   107,
03725      108,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03726       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03727      128,   129,   130,    -1,    -1,   133,     1,    -1,     3,     4,
03728        5,     6,     7,   141,    -1,   143,    11,    12,    -1,    -1,
03729       -1,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03730       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03731       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03732       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03733       55,    56,    57,    -1,    59,    60,    61,    62,    -1,    64,
03734       65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,    -1,
03735       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03736       -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,
03737       95,    -1,    97,    -1,    -1,   100,   101,   102,   103,   104,
03738      105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,    -1,
03739       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03740       -1,    -1,    -1,   128,   129,   130,    -1,    -1,   133,    -1,
03741       -1,    -1,    -1,    -1,    -1,    -1,   141,     1,   143,     3,
03742        4,     5,     6,     7,    -1,    -1,    10,    11,    12,    -1,
03743       -1,    -1,    16,    -1,    18,    19,    20,    21,    22,    23,
03744       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03745       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03746       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03747       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03748       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03749       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03750       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03751       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03752      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03753       -1,    -1,     1,    -1,     3,     4,     5,     6,     7,    -1,
03754       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03755       19,    20,    21,    22,    23,    24,    -1,   141,    -1,   143,
03756       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03757       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03758       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03759       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03760       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03761       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03762       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
03763       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03764       -1,   110,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03765        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03766      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03767       24,    -1,   141,    -1,   143,    -1,    30,    31,    32,    33,
03768       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03769       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03770       54,    55,    56,    57,    58,    59,    60,    61,    62,    -1,
03771       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03772       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03773       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03774       94,    95,    -1,    97,    98,    99,   100,   101,   102,   103,
03775      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03776       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03777       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03778       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,   143,
03779       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03780       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03781       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03782       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03783       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03784       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03785       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
03786       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03787       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03788        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03789      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03790       24,    -1,   141,    -1,   143,    -1,    30,    31,    32,    33,
03791       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03792       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03793       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03794       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03795       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03796       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03797       94,    95,    -1,    -1,    -1,    -1,   100,   101,   102,   103,
03798      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03799       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03800       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03801       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,   143,
03802       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03803       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03804       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03805       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03806       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03807       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03808       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
03809       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03810       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03811        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   128,
03812      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03813       24,    -1,   141,    -1,    -1,    -1,    30,    31,    32,    33,
03814       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03815       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03816       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03817       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03818       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03819       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03820       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03821      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03822       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03823       -1,    -1,    -1,    -1,   128,   129,   130,    -1,    -1,    -1,
03824       -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,
03825        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03826       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03827       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03828       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03829       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03830       55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03831       -1,    -1,    -1,    68,    69,    70,    71,    72,    73,    74,
03832       75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,    84,
03833       85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03834       -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
03835       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03836       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,   124,
03837      125,   126,   127,    -1,   129,   130,    -1,    -1,    -1,    -1,
03838       -1,    -1,   137,   138,     3,     4,     5,     6,     7,     8,
03839        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03840       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03841       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03842       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03843       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03844       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
03845       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
03846       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
03847       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
03848       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
03850      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03851      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,   137,     3,
03852        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03853       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03854       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03855       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03856       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03857       54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03858       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03859       74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,
03860       84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03861       -1,    -1,    -1,    97,    98,    -1,    -1,   101,    -1,    -1,
03862       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03863       -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
03864      124,   125,   126,   127,    -1,   129,   130,    -1,    -1,    -1,
03865       -1,    -1,    -1,   137,     3,     4,     5,     6,     7,     8,
03866        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03867       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03868       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03869       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03870       49,    50,    51,    52,    53,    -1,    -1,    56,    -1,    -1,
03871       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
03872       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
03873       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
03874       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
03875       -1,    -1,   101,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03876       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
03877      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03878      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,   137,     3,
03879        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03880       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03881       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03882       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03883       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03884       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03885       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03886       74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,
03887       84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03888       -1,    -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,
03889       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03890       -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
03891      124,   125,   126,   127,    -1,   129,   130,     3,     4,     5,
03892       -1,     7,    -1,   137,    -1,    11,    12,    -1,    -1,    -1,
03893       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03894       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03895       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03896       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03897       56,    57,    -1,    59,    60,    61,    62,    -1,    64,    65,
03898       66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03899       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03900       -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,    95,
03901       -1,    -1,    -1,    -1,   100,   101,   102,   103,   104,   105,
03902      106,   107,   108,    -1,    -1,    -1,    -1,    -1,     3,     4,
03903        5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,
03904       -1,    16,   128,    18,    19,    20,    21,    22,    23,    24,
03905      136,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03906       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03907       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03908       55,    56,    57,    -1,    59,    60,    61,    62,    -1,    64,
03909       65,    66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03910       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03911       -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,
03912       95,    -1,    -1,    -1,    -1,   100,   101,   102,   103,   104,
03913      105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,     3,
03914        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,    -1,
03915       -1,    -1,    16,   128,    18,    19,    20,    21,    22,    23,
03916       24,   136,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03917       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03918       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03919       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03920       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03921       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03922       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03923       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03924      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03925       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03926       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03927       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03928       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03929       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03930       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03931       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03932       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03933       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03934       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    98,
03935       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03936       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03937        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   128,
03938      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03939       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03940       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03941       -1,    45,    46,    -1,    48,    49,    50,    51,    52,    53,
03942       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03943       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03944       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03945       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03946       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03947      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03948       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03949       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03950       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03951       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03952       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03953       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03954       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03955       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03956       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03957       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    98,
03958       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03959       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03960        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03961      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03962       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03963       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03964       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03965       54,    55,    56,    57,    58,    59,    60,    61,    62,    -1,
03966       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03967       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03968       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03969       94,    95,    -1,    97,    98,    -1,   100,   101,   102,   103,
03970      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03971       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03972       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03973       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03974       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03975       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03976       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03977       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03978       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03979       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03980       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    98,
03981       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03982       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03983        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03984      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03985       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03986       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03987       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03988       54,    55,    56,    57,    58,    59,    60,    61,    62,    -1,
03989       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03990       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03991       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03992       94,    95,    -1,    97,    98,    -1,   100,   101,   102,   103,
03993      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03994       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03995       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03996       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03997       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03998       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03999       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
04000       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04001       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04002       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04003       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    98,
04004       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04005       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04006        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04007      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04008       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04009       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04010       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04011       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04012       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04013       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04014       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04015       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04016      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04017       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04018       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04019       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04020       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04021       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04022       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04023       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04024       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04025       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04026       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
04027       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04028       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04029        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04030      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04031       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04032       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04033       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04034       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04035       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04036       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04037       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04038       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04039      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04040       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04041       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04042       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04043       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04044       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04045       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04046       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04047       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04048       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04049       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
04050       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04051       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04052        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04053      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04054       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04055       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04056       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04057       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04058       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04059       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04060       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04061       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04062      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04063       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04064       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04065       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04066       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04067       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04068       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04069       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04070       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04071       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04072       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
04073       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04074       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04075        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04076      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04077       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04078       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04079       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04080       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04081       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04082       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04083       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04084       94,    95,    -1,    -1,    -1,    -1,   100,   101,   102,   103,
04085      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04086       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04087       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04088       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04089       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04090       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04091       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04092       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04093       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04094       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04095       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
04096       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04097       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04098        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04099      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04100       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04101       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04102       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04103       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04104       64,    65,    66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04105       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04106       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04107       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04108      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04109        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04110       -1,    -1,    -1,    16,   128,    18,    19,    20,    21,    22,
04111       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04112       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04113       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04114       53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
04115       -1,    64,    65,    66,    -1,    -1,    -1,    -1,    -1,    -1,
04116       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04117       -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,
04118       -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,   102,
04119      103,   104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,
04120       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
04121       12,    -1,    -1,    -1,    16,   128,    18,    19,    20,    21,
04122       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
04123       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
04124       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
04125       52,    53,    54,    55,    56,    57,    -1,    59,    60,    61,
04126       62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,    -1,
04127       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04128       -1,    -1,    -1,    85,    -1,    -1,    88,    -1,    -1,    91,
04129       92,    -1,    94,    95,    -1,    -1,    -1,    -1,   100,   101,
04130      102,   103,   104,   105,   106,   107,   108,    -1,    -1,    -1,
04131       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
04132       11,    12,    -1,    -1,    -1,    16,   128,    18,    19,    20,
04133       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
04134       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
04135       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
04136       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
04137       61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,
04138       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04139       -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,
04140       91,    92,    -1,    94,    95,    -1,    -1,    -1,    -1,   100,
04141      101,   102,   103,   104,   105,   106,   107,   108,    -1,    -1,
04142       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04143       -1,    11,    12,    -1,    -1,    -1,    16,   128,    18,    19,
04144       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04145       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04146       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04147       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04148       60,    61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,
04149       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04150       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
04151       -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,    -1,
04152      100,   101,   102,   103,   104,   105,   106,   107,   108,    -1,
04153       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04154       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   128,    18,
04155       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04156       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04157       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04158       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04159       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    -1,
04160       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04161       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04162       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
04163       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04164       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
04165       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,   128,
04166       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
04167       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
04168       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
04169       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
04170       -1,    59,    60,    61,    62,    -1,    64,    65,    66,    -1,
04171       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04172       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04173       88,    -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,
04174       -1,    -1,   100,   101,   102,   103,   104,   105,   106,   107,
04175      108,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,
04176       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04177      128,    68,    69,    70,    71,    72,    73,    74,    75,    76,
04178       -1,    -1,    79,    80,    -1,    -1,    83,    84,    85,    86,
04179       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04180       97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04181       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04182       -1,   118,   119,   120,   121,   122,   123,   124,   125,   126,
04183      127,    -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,
04184      137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04185       68,    69,    70,    71,    72,    73,    74,    75,    76,    -1,
04186       -1,    79,    80,    -1,    -1,    83,    84,    85,    86,    -1,
04187       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,
04188       98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04189       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04190      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
04191       -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,   137,
04192       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
04193       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
04194       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
04195       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
04196       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04197       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
04198      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
04199      129,   130,    52,    53,    -1,    -1,    56,    -1,   137,    -1,
04200       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,
04201       70,    71,    72,    73,    74,    75,    76,    -1,    -1,    79,
04202       80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,    -1,
04203       -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    -1,
04204       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04205       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,
04206      120,   121,   122,   123,   124,   125,   126,   127,    -1,   129,
04207      130,    52,    53,    -1,    -1,    56,    -1,   137,    -1,    -1,
04208       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
04209       71,    72,    73,    74,    75,    76,    -1,    -1,    79,    80,
04210       -1,    -1,    83,    84,    85,    86,    -1,    -1,    -1,    -1,
04211       -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    -1,    -1,
04212       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04213       -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,
04214      121,   122,   123,   124,   125,   126,   127,    -1,   129,   130,
04215       52,    53,    -1,    -1,    56,    -1,   137,    -1,    -1,    -1,
04216       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
04217       72,    73,    74,    75,    76,    -1,    -1,    79,    80,    -1,
04218       -1,    83,    84,    85,    86,    -1,    -1,    -1,    -1,    -1,
04219       -1,    -1,    -1,    -1,    -1,    97,    98,    -1,    -1,    -1,
04220       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04221       -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
04222      122,   123,   124,   125,   126,   127,    -1,   129,   130,    52,
04223       53,    -1,    -1,    56,    -1,   137,    -1,    -1,    -1,    -1,
04224       -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,
04225       73,    74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,
04226       83,    84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,
04227       -1,    -1,    -1,    -1,    97,    98,    -1,    -1,    -1,    -1,
04228       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04229       -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,
04230      123,   124,   125,   126,   127,    -1,   129,   130,    52,    53,
04231       -1,    -1,    56,    -1,   137,    -1,    -1,    -1,    -1,    -1,
04232       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
04233       74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,
04234       84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04235       -1,    -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,
04236       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04237       -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
04238      124,   125,   126,   127,    -1,   129,   130,    52,    53,    -1,
04239       -1,    56,    -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,
04240       -1,    -1,    -1,    68,    69,    70,    71,    72,    73,    74,
04241       75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,    84,
04242       85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04243       -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
04244       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04245       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,   124,
04246      125,   126,   127,    -1,   129,   130,    52,    53,    -1,    -1,
04247       56,    -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04248       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
04249       76,    -1,    -1,    79,    80,    -1,    -1,    83,    84,    85,
04250       86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04251       -1,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04252       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04253       -1,    -1,   118,   119,   120,   121,   122,   123,   124,   125,
04254      126,   127,    -1,   129,   130,    52,    53,    -1,    -1,    56,
04255       -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04256       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
04257       -1,    -1,    79,    80,    -1,    -1,    83,    84,    85,    86,
04258       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04259       97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04260       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04261       -1,   118,   119,   120,   121,   122,   123,   124,   125,   126,
04262      127,    -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,
04263      137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04264       68,    69,    70,    71,    72,    73,    74,    75,    76,    -1,
04265       -1,    79,    80,    -1,    -1,    83,    84,    85,    86,    -1,
04266       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,
04267       98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04268       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04269      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
04270       -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,   137,
04271       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
04272       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
04273       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
04274       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
04275       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
04276       80,    81,    82,    -1,    -1,    85,    86,    -1,    -1,   118,
04277      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
04278      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,   137,    -1,
04279       -1,    -1,    -1,    -1,    -1,    -1,   116,    -1,   118,   119,
04280      120,   121,   122,   123,   124,   125,   126,   127,    -1,    -1,
04281       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04282       -1,    -1,    -1,   143
04283 };
04284 
04285 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04286    symbol of state STATE-NUM.  */
04287 static const yytype_uint16 yystos[] =
04288 {
04289        0,   145,   146,     0,     1,     3,     4,     5,     6,     7,
04290       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04291       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04292       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04293       57,    59,    60,    61,    62,    64,    65,    66,    68,    69,
04294       88,    91,    92,    94,    95,    97,   100,   101,   102,   103,
04295      104,   105,   106,   107,   108,   128,   129,   130,   147,   148,
04296      149,   156,   158,   159,   161,   162,   165,   166,   167,   169,
04297      170,   171,   173,   174,   184,   199,   218,   219,   220,   221,
04298      222,   223,   224,   225,   226,   227,   228,   255,   256,   270,
04299      271,   272,   273,   274,   275,   276,   279,   281,   282,   294,
04300      296,   297,   298,   299,   300,   301,   302,   303,   336,   347,
04301      149,     3,     4,     5,     6,     7,     8,     9,    10,    11,
04302       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
04303       22,    23,    24,    25,    26,    30,    31,    32,    33,    34,
04304       35,    36,    37,    38,    39,    45,    46,    47,    48,    49,
04305       50,    51,    52,    53,    56,    68,    69,    70,    71,    72,
04306       73,    74,    75,    76,    79,    80,    83,    84,    85,    86,
04307       97,    98,   118,   119,   120,   121,   122,   123,   124,   125,
04308      126,   127,   129,   130,   137,   177,   178,   179,   180,   182,
04309      183,   294,   296,    39,    58,    88,    91,    97,    98,    99,
04310      129,   166,   174,   184,   186,   191,   194,   196,   218,   299,
04311      300,   302,   303,   334,   335,   191,   191,   138,   192,   193,
04312      138,   188,   192,   138,   143,   341,    54,   179,   341,   150,
04313      132,    21,    22,    30,    31,    32,   165,   184,   218,   184,
04314       56,     1,    47,    91,   152,   153,   154,   156,   168,   169,
04315      347,   201,   202,   187,   196,   334,   347,   186,   333,   334,
04316      347,    46,    88,   128,   136,   173,   199,   218,   299,   300,
04317      303,   246,   247,    54,    55,    57,   177,   286,   295,   285,
04318      286,   287,   142,   277,   142,   283,   142,   280,   142,   284,
04319      298,   161,   184,   184,   141,   143,   340,   345,   346,    40,
04320       41,    42,    43,    44,    37,    38,    26,   132,   188,   192,
04321      261,    28,   253,   115,   136,    91,    97,   170,   115,    70,
04322       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
04323       81,    82,    85,    86,   116,   118,   119,   120,   121,   122,
04324      123,   124,   125,   126,   127,    87,   134,   135,   200,   159,
04325      160,   160,   205,   207,   160,   340,   346,    88,   167,   174,
04326      218,   234,   299,   300,   303,    52,    56,    85,    88,   175,
04327      176,   218,   299,   300,   303,   176,    33,    34,    35,    36,
04328       49,    50,    51,    52,    56,   138,   177,   301,   331,    87,
04329      135,   339,   261,   273,    89,    89,   136,   186,    56,   186,
04330      186,   186,   115,    90,   136,   195,   347,    87,   134,   135,
04331       89,    89,   136,   195,   191,   341,   342,   191,   190,   191,
04332      196,   334,   347,   159,   342,   159,    54,    65,    66,   157,
04333      138,   185,   132,   152,    87,   135,    89,   156,   155,   168,
04334      139,   340,   346,   342,   342,   159,   140,   136,   143,   344,
04335      136,   344,   133,   344,   341,    56,   298,   170,   172,   136,
04336       87,   134,   135,   248,    63,   109,   111,   112,   288,   112,
04337      288,   112,    67,   288,   112,   112,   278,   288,   112,    63,
04338      112,   112,   112,   278,   112,    63,   112,    70,   141,   149,
04339      160,   160,   160,   160,   156,   159,   159,   263,   262,    96,
04340      163,   254,    97,   161,   186,   196,   197,   198,   168,   136,
04341      173,   136,   158,   161,   174,   184,   186,   198,   184,   184,
04342      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04343      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04344      184,   184,   184,   184,    52,    53,    56,   182,   260,   337,
04345      338,   190,    52,    53,    56,   182,   259,   337,   151,   152,
04346       13,   230,   345,   230,   160,   160,   340,    17,   264,    56,
04347       87,   134,   135,    25,   159,    52,    56,   175,     1,   119,
04348      304,   345,    87,   134,   135,   214,   332,   215,   339,    52,
04349       56,   337,   161,   184,   161,   184,   181,   184,   186,    97,
04350      186,   194,   334,    52,    56,   190,    52,    56,   335,   342,
04351      139,   342,   136,   136,   342,   179,   204,   184,   147,   133,
04352      337,   337,   184,   132,   342,   154,   203,   334,   136,   172,
04353       52,    56,   190,    52,    56,    52,    54,    55,    56,    57,
04354       58,    70,    91,    97,    98,    99,   122,   125,   138,   251,
04355      308,   310,   311,   312,   313,   314,   315,   316,   319,   320,
04356      321,   322,   325,   326,   327,   328,   329,   290,   289,   142,
04357      288,   142,   142,   142,   184,    78,   120,   241,   242,   347,
04358      241,   164,   241,   186,   136,   342,   172,   136,   115,    44,
04359      341,    89,    89,   188,   192,   258,   341,   343,    89,    89,
04360      188,   192,   257,    10,   229,     8,   266,   347,   152,    13,
04361      152,    27,   231,   345,   231,   264,   196,   229,    52,    56,
04362      190,    52,    56,   209,   212,   345,   305,   211,    52,    56,
04363      175,   190,   151,   159,   138,   306,   307,   216,   188,   189,
04364      192,   347,    44,   179,   186,   195,    89,    89,   343,    89,
04365       89,   334,   159,   133,   147,   342,   344,   170,   343,    91,
04366       97,   235,   236,   237,   312,   310,   249,   115,   136,   309,
04367      186,   136,   330,   347,    52,   136,   330,   136,   309,    52,
04368      136,   309,    52,   291,    54,    55,    57,   293,   303,   238,
04369      240,   243,   312,   314,   315,   317,   318,   321,   323,   324,
04370      327,   329,   341,   152,   152,   241,   152,    97,   186,   172,
04371      184,   117,   161,   184,   161,   184,   163,   188,   140,    89,
04372      161,   184,   161,   184,   163,   189,   186,   198,   267,   347,
04373       15,   233,   347,    14,   232,   233,   233,   206,   208,   229,
04374      136,   230,   343,   160,   345,   160,   151,   343,   229,   342,
04375      310,   151,   310,   177,   261,   253,   184,    89,   136,   342,
04376      133,   237,   136,   312,   136,   342,   243,   250,   186,   308,
04377      313,   325,   327,   316,   321,   329,   314,   322,   327,   312,
04378      314,   292,   243,   120,   115,   136,   239,    88,   218,   136,
04379      330,   330,   136,   239,   136,   239,   141,    10,   133,   152,
04380       10,   186,   184,   161,   184,    90,   268,   347,   152,     9,
04381      269,   347,   160,   229,   229,   152,   152,   186,   152,   231,
04382      213,   345,   229,   342,   229,   345,   217,   342,   236,   136,
04383       97,   235,   139,    29,   113,   252,   136,   309,   136,   309,
04384      330,   136,   309,   136,   309,   309,   152,   120,   218,   238,
04385      324,   327,    56,    87,   317,   321,   314,   323,   327,   314,
04386       52,   244,   245,   311,   133,    88,   174,   218,   299,   300,
04387      303,   230,   152,   230,   229,   229,   233,   264,   265,   210,
04388      151,   306,   136,   236,   136,   312,   152,   152,   314,   327,
04389      314,   314,   110,   136,   239,   136,   239,    52,    56,   330,
04390      136,   239,   136,   239,   239,   136,   341,    56,    87,   134,
04391      135,   152,   152,   152,   229,   151,   236,   136,    10,   133,
04392      309,   136,   309,   309,   309,   314,   327,   314,   314,   245,
04393       52,    56,   190,    52,    56,   266,   232,   229,   229,   236,
04394      314,   239,   136,   239,   239,   239,   343,   309,   314,   239
04395 };
04396 
04397 #define yyerrok         (yyerrstatus = 0)
04398 #define yyclearin       (yychar = YYEMPTY)
04399 #define YYEMPTY         (-2)
04400 #define YYEOF           0
04401 
04402 #define YYACCEPT        goto yyacceptlab
04403 #define YYABORT         goto yyabortlab
04404 #define YYERROR         goto yyerrorlab
04405 
04406 
04407 /* Like YYERROR except do call yyerror.  This remains here temporarily
04408    to ease the transition to the new meaning of YYERROR, for GCC.
04409    Once GCC version 2 has supplanted version 1, this can go.  However,
04410    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04411    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04412    discussed.  */
04413 
04414 #define YYFAIL          goto yyerrlab
04415 #if defined YYFAIL
04416   /* This is here to suppress warnings from the GCC cpp's
04417      -Wunused-macros.  Normally we don't worry about that warning, but
04418      some users do, and we want to make it easy for users to remove
04419      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04420 #endif
04421 
04422 #define YYRECOVERING()  (!!yyerrstatus)
04423 
04424 #define YYBACKUP(Token, Value)                                  \
04425 do                                                              \
04426   if (yychar == YYEMPTY && yylen == 1)                          \
04427     {                                                           \
04428       yychar = (Token);                                         \
04429       yylval = (Value);                                         \
04430       YYPOPSTACK (1);                                           \
04431       goto yybackup;                                            \
04432     }                                                           \
04433   else                                                          \
04434     {                                                           \
04435       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04436       YYERROR;                                                  \
04437     }                                                           \
04438 while (YYID (0))
04439 
04440 
04441 #define YYTERROR        1
04442 #define YYERRCODE       256
04443 
04444 
04445 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04446    If N is 0, then set CURRENT to the empty location which ends
04447    the previous symbol: RHS[0] (always defined).  */
04448 
04449 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04450 #ifndef YYLLOC_DEFAULT
04451 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04452     do                                                                  \
04453       if (YYID (N))                                                    \
04454         {                                                               \
04455           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04456           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04457           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04458           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04459         }                                                               \
04460       else                                                              \
04461         {                                                               \
04462           (Current).first_line   = (Current).last_line   =              \
04463             YYRHSLOC (Rhs, 0).last_line;                                \
04464           (Current).first_column = (Current).last_column =              \
04465             YYRHSLOC (Rhs, 0).last_column;                              \
04466         }                                                               \
04467     while (YYID (0))
04468 #endif
04469 
04470 
04471 /* This macro is provided for backward compatibility. */
04472 
04473 #ifndef YY_LOCATION_PRINT
04474 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04475 #endif
04476 
04477 
04478 /* YYLEX -- calling `yylex' with the right arguments.  */
04479 
04480 #ifdef YYLEX_PARAM
04481 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04482 #else
04483 # define YYLEX yylex (&yylval, parser)
04484 #endif
04485 
04486 /* Enable debugging if requested.  */
04487 #if YYDEBUG
04488 
04489 # ifndef YYFPRINTF
04490 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04491 #  define YYFPRINTF fprintf
04492 # endif
04493 
04494 # define YYDPRINTF(Args)                        \
04495 do {                                            \
04496   if (yydebug)                                  \
04497     YYFPRINTF Args;                             \
04498 } while (YYID (0))
04499 
04500 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04501 do {                                                                      \
04502   if (yydebug)                                                            \
04503     {                                                                     \
04504       YYFPRINTF (stderr, "%s ", Title);                                   \
04505       yy_symbol_print (stderr,                                            \
04506                   Type, Value, parser); \
04507       YYFPRINTF (stderr, "\n");                                           \
04508     }                                                                     \
04509 } while (YYID (0))
04510 
04511 
04512 /*--------------------------------.
04513 | Print this symbol on YYOUTPUT.  |
04514 `--------------------------------*/
04515 
04516 /*ARGSUSED*/
04517 #if (defined __STDC__ || defined __C99__FUNC__ \
04518      || defined __cplusplus || defined _MSC_VER)
04519 static void
04520 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04521 #else
04522 static void
04523 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04524     FILE *yyoutput;
04525     int yytype;
04526     YYSTYPE const * const yyvaluep;
04527     struct parser_params *parser;
04528 #endif
04529 {
04530   if (!yyvaluep)
04531     return;
04532   YYUSE (parser);
04533 # ifdef YYPRINT
04534   if (yytype < YYNTOKENS)
04535     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04536 # else
04537   YYUSE (yyoutput);
04538 # endif
04539   switch (yytype)
04540     {
04541       default:
04542         break;
04543     }
04544 }
04545 
04546 
04547 /*--------------------------------.
04548 | Print this symbol on YYOUTPUT.  |
04549 `--------------------------------*/
04550 
04551 #if (defined __STDC__ || defined __C99__FUNC__ \
04552      || defined __cplusplus || defined _MSC_VER)
04553 static void
04554 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04555 #else
04556 static void
04557 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04558     FILE *yyoutput;
04559     int yytype;
04560     YYSTYPE const * const yyvaluep;
04561     struct parser_params *parser;
04562 #endif
04563 {
04564   if (yytype < YYNTOKENS)
04565     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04566   else
04567     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04568 
04569   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04570   YYFPRINTF (yyoutput, ")");
04571 }
04572 
04573 /*------------------------------------------------------------------.
04574 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04575 | TOP (included).                                                   |
04576 `------------------------------------------------------------------*/
04577 
04578 #if (defined __STDC__ || defined __C99__FUNC__ \
04579      || defined __cplusplus || defined _MSC_VER)
04580 static void
04581 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04582 #else
04583 static void
04584 yy_stack_print (yybottom, yytop)
04585     yytype_int16 *yybottom;
04586     yytype_int16 *yytop;
04587 #endif
04588 {
04589   YYFPRINTF (stderr, "Stack now");
04590   for (; yybottom <= yytop; yybottom++)
04591     {
04592       int yybot = *yybottom;
04593       YYFPRINTF (stderr, " %d", yybot);
04594     }
04595   YYFPRINTF (stderr, "\n");
04596 }
04597 
04598 # define YY_STACK_PRINT(Bottom, Top)                            \
04599 do {                                                            \
04600   if (yydebug)                                                  \
04601     yy_stack_print ((Bottom), (Top));                           \
04602 } while (YYID (0))
04603 
04604 
04605 /*------------------------------------------------.
04606 | Report that the YYRULE is going to be reduced.  |
04607 `------------------------------------------------*/
04608 
04609 #if (defined __STDC__ || defined __C99__FUNC__ \
04610      || defined __cplusplus || defined _MSC_VER)
04611 static void
04612 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04613 #else
04614 static void
04615 yy_reduce_print (yyvsp, yyrule, parser)
04616     YYSTYPE *yyvsp;
04617     int yyrule;
04618     struct parser_params *parser;
04619 #endif
04620 {
04621   int yynrhs = yyr2[yyrule];
04622   int yyi;
04623   unsigned long int yylno = yyrline[yyrule];
04624   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04625              yyrule - 1, yylno);
04626   /* The symbols being reduced.  */
04627   for (yyi = 0; yyi < yynrhs; yyi++)
04628     {
04629       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04630       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04631                        &(yyvsp[(yyi + 1) - (yynrhs)])
04632                                        , parser);
04633       YYFPRINTF (stderr, "\n");
04634     }
04635 }
04636 
04637 # define YY_REDUCE_PRINT(Rule)          \
04638 do {                                    \
04639   if (yydebug)                          \
04640     yy_reduce_print (yyvsp, Rule, parser); \
04641 } while (YYID (0))
04642 
04643 /* Nonzero means print parse trace.  It is left uninitialized so that
04644    multiple parsers can coexist.  */
04645 #ifndef yydebug
04646 int yydebug;
04647 #endif
04648 #else /* !YYDEBUG */
04649 # define YYDPRINTF(Args)
04650 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04651 # define YY_STACK_PRINT(Bottom, Top)
04652 # define YY_REDUCE_PRINT(Rule)
04653 #endif /* !YYDEBUG */
04654 
04655 
04656 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04657 #ifndef YYINITDEPTH
04658 # define YYINITDEPTH 200
04659 #endif
04660 
04661 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04662    if the built-in stack extension method is used).
04663 
04664    Do not make this value too large; the results are undefined if
04665    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04666    evaluated with infinite-precision integer arithmetic.  */
04667 
04668 #ifndef YYMAXDEPTH
04669 # define YYMAXDEPTH 10000
04670 #endif
04671 
04672 
04673 #if YYERROR_VERBOSE
04674 
04675 # ifndef yystrlen
04676 #  if defined __GLIBC__ && defined _STRING_H
04677 #   define yystrlen strlen
04678 #  else
04679 /* Return the length of YYSTR.  */
04680 #if (defined __STDC__ || defined __C99__FUNC__ \
04681      || defined __cplusplus || defined _MSC_VER)
04682 static YYSIZE_T
04683 yystrlen (const char *yystr)
04684 #else
04685 static YYSIZE_T
04686 yystrlen (yystr)
04687     const char *yystr;
04688 #endif
04689 {
04690   YYSIZE_T yylen;
04691   for (yylen = 0; yystr[yylen]; yylen++)
04692     continue;
04693   return yylen;
04694 }
04695 #  endif
04696 # endif
04697 
04698 # ifndef yystpcpy
04699 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04700 #   define yystpcpy stpcpy
04701 #  else
04702 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04703    YYDEST.  */
04704 #if (defined __STDC__ || defined __C99__FUNC__ \
04705      || defined __cplusplus || defined _MSC_VER)
04706 static char *
04707 yystpcpy (char *yydest, const char *yysrc)
04708 #else
04709 static char *
04710 yystpcpy (yydest, yysrc)
04711     char *yydest;
04712     const char *yysrc;
04713 #endif
04714 {
04715   char *yyd = yydest;
04716   const char *yys = yysrc;
04717 
04718   while ((*yyd++ = *yys++) != '\0')
04719     continue;
04720 
04721   return yyd - 1;
04722 }
04723 #  endif
04724 # endif
04725 
04726 # ifndef yytnamerr
04727 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04728    quotes and backslashes, so that it's suitable for yyerror.  The
04729    heuristic is that double-quoting is unnecessary unless the string
04730    contains an apostrophe, a comma, or backslash (other than
04731    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04732    null, do not copy; instead, return the length of what the result
04733    would have been.  */
04734 static YYSIZE_T
04735 yytnamerr (char *yyres, const char *yystr)
04736 {
04737   if (*yystr == '"')
04738     {
04739       YYSIZE_T yyn = 0;
04740       char const *yyp = yystr;
04741 
04742       for (;;)
04743         switch (*++yyp)
04744           {
04745           case '\'':
04746           case ',':
04747             goto do_not_strip_quotes;
04748 
04749           case '\\':
04750             if (*++yyp != '\\')
04751               goto do_not_strip_quotes;
04752             /* Fall through.  */
04753           default:
04754             if (yyres)
04755               yyres[yyn] = *yyp;
04756             yyn++;
04757             break;
04758 
04759           case '"':
04760             if (yyres)
04761               yyres[yyn] = '\0';
04762             return yyn;
04763           }
04764     do_not_strip_quotes: ;
04765     }
04766 
04767   if (! yyres)
04768     return yystrlen (yystr);
04769 
04770   return yystpcpy (yyres, yystr) - yyres;
04771 }
04772 # endif
04773 
04774 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
04775    about the unexpected token YYTOKEN for the state stack whose top is
04776    YYSSP.
04777 
04778    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
04779    not large enough to hold the message.  In that case, also set
04780    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
04781    required number of bytes is too large to store.  */
04782 static int
04783 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
04784                 yytype_int16 *yyssp, int yytoken)
04785 {
04786   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
04787   YYSIZE_T yysize = yysize0;
04788   YYSIZE_T yysize1;
04789   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04790   /* Internationalized format string. */
04791   const char *yyformat = 0;
04792   /* Arguments of yyformat. */
04793   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04794   /* Number of reported tokens (one for the "unexpected", one per
04795      "expected"). */
04796   int yycount = 0;
04797 
04798   /* There are many possibilities here to consider:
04799      - Assume YYFAIL is not used.  It's too flawed to consider.  See
04800        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
04801        for details.  YYERROR is fine as it does not invoke this
04802        function.
04803      - If this state is a consistent state with a default action, then
04804        the only way this function was invoked is if the default action
04805        is an error action.  In that case, don't check for expected
04806        tokens because there are none.
04807      - The only way there can be no lookahead present (in yychar) is if
04808        this state is a consistent state with a default action.  Thus,
04809        detecting the absence of a lookahead is sufficient to determine
04810        that there is no unexpected or expected token to report.  In that
04811        case, just report a simple "syntax error".
04812      - Don't assume there isn't a lookahead just because this state is a
04813        consistent state with a default action.  There might have been a
04814        previous inconsistent state, consistent state with a non-default
04815        action, or user semantic action that manipulated yychar.
04816      - Of course, the expected token list depends on states to have
04817        correct lookahead information, and it depends on the parser not
04818        to perform extra reductions after fetching a lookahead from the
04819        scanner and before detecting a syntax error.  Thus, state merging
04820        (from LALR or IELR) and default reductions corrupt the expected
04821        token list.  However, the list is correct for canonical LR with
04822        one exception: it will still contain any token that will not be
04823        accepted due to an error action in a later state.
04824   */
04825   if (yytoken != YYEMPTY)
04826     {
04827       int yyn = yypact[*yyssp];
04828       yyarg[yycount++] = yytname[yytoken];
04829       if (!yypact_value_is_default (yyn))
04830         {
04831           /* Start YYX at -YYN if negative to avoid negative indexes in
04832              YYCHECK.  In other words, skip the first -YYN actions for
04833              this state because they are default actions.  */
04834           int yyxbegin = yyn < 0 ? -yyn : 0;
04835           /* Stay within bounds of both yycheck and yytname.  */
04836           int yychecklim = YYLAST - yyn + 1;
04837           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04838           int yyx;
04839 
04840           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04841             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
04842                 && !yytable_value_is_error (yytable[yyx + yyn]))
04843               {
04844                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04845                   {
04846                     yycount = 1;
04847                     yysize = yysize0;
04848                     break;
04849                   }
04850                 yyarg[yycount++] = yytname[yyx];
04851                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04852                 if (! (yysize <= yysize1
04853                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04854                   return 2;
04855                 yysize = yysize1;
04856               }
04857         }
04858     }
04859 
04860   switch (yycount)
04861     {
04862 # define YYCASE_(N, S)                      \
04863       case N:                               \
04864         yyformat = S;                       \
04865       break
04866       YYCASE_(0, YY_("syntax error"));
04867       YYCASE_(1, YY_("syntax error, unexpected %s"));
04868       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
04869       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
04870       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
04871       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
04872 # undef YYCASE_
04873     }
04874 
04875   yysize1 = yysize + yystrlen (yyformat);
04876   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04877     return 2;
04878   yysize = yysize1;
04879 
04880   if (*yymsg_alloc < yysize)
04881     {
04882       *yymsg_alloc = 2 * yysize;
04883       if (! (yysize <= *yymsg_alloc
04884              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
04885         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
04886       return 1;
04887     }
04888 
04889   /* Avoid sprintf, as that infringes on the user's name space.
04890      Don't have undefined behavior even if the translation
04891      produced a string with the wrong number of "%s"s.  */
04892   {
04893     char *yyp = *yymsg;
04894     int yyi = 0;
04895     while ((*yyp = *yyformat) != '\0')
04896       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
04897         {
04898           yyp += yytnamerr (yyp, yyarg[yyi++]);
04899           yyformat += 2;
04900         }
04901       else
04902         {
04903           yyp++;
04904           yyformat++;
04905         }
04906   }
04907   return 0;
04908 }
04909 #endif /* YYERROR_VERBOSE */
04910 
04911 /*-----------------------------------------------.
04912 | Release the memory associated to this symbol.  |
04913 `-----------------------------------------------*/
04914 
04915 /*ARGSUSED*/
04916 #if (defined __STDC__ || defined __C99__FUNC__ \
04917      || defined __cplusplus || defined _MSC_VER)
04918 static void
04919 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04920 #else
04921 static void
04922 yydestruct (yymsg, yytype, yyvaluep, parser)
04923     const char *yymsg;
04924     int yytype;
04925     YYSTYPE *yyvaluep;
04926     struct parser_params *parser;
04927 #endif
04928 {
04929   YYUSE (yyvaluep);
04930   YYUSE (parser);
04931 
04932   if (!yymsg)
04933     yymsg = "Deleting";
04934   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04935 
04936   switch (yytype)
04937     {
04938 
04939       default:
04940         break;
04941     }
04942 }
04943 
04944 
04945 /* Prevent warnings from -Wmissing-prototypes.  */
04946 #ifdef YYPARSE_PARAM
04947 #if defined __STDC__ || defined __cplusplus
04948 int yyparse (void *YYPARSE_PARAM);
04949 #else
04950 int yyparse ();
04951 #endif
04952 #else /* ! YYPARSE_PARAM */
04953 #if defined __STDC__ || defined __cplusplus
04954 int yyparse (struct parser_params *parser);
04955 #else
04956 int yyparse ();
04957 #endif
04958 #endif /* ! YYPARSE_PARAM */
04959 
04960 
04961 /*----------.
04962 | yyparse.  |
04963 `----------*/
04964 
04965 #ifdef YYPARSE_PARAM
04966 #if (defined __STDC__ || defined __C99__FUNC__ \
04967      || defined __cplusplus || defined _MSC_VER)
04968 int
04969 yyparse (void *YYPARSE_PARAM)
04970 #else
04971 int
04972 yyparse (YYPARSE_PARAM)
04973     void *YYPARSE_PARAM;
04974 #endif
04975 #else /* ! YYPARSE_PARAM */
04976 #if (defined __STDC__ || defined __C99__FUNC__ \
04977      || defined __cplusplus || defined _MSC_VER)
04978 int
04979 yyparse (struct parser_params *parser)
04980 #else
04981 int
04982 yyparse (parser)
04983     struct parser_params *parser;
04984 #endif
04985 #endif
04986 {
04987 /* The lookahead symbol.  */
04988 int yychar;
04989 
04990 /* The semantic value of the lookahead symbol.  */
04991 YYSTYPE yylval;
04992 
04993     /* Number of syntax errors so far.  */
04994     int yynerrs;
04995 
04996     int yystate;
04997     /* Number of tokens to shift before error messages enabled.  */
04998     int yyerrstatus;
04999 
05000     /* The stacks and their tools:
05001        `yyss': related to states.
05002        `yyvs': related to semantic values.
05003 
05004        Refer to the stacks thru separate pointers, to allow yyoverflow
05005        to reallocate them elsewhere.  */
05006 
05007     /* The state stack.  */
05008     yytype_int16 yyssa[YYINITDEPTH];
05009     yytype_int16 *yyss;
05010     yytype_int16 *yyssp;
05011 
05012     /* The semantic value stack.  */
05013     YYSTYPE yyvsa[YYINITDEPTH];
05014     YYSTYPE *yyvs;
05015     YYSTYPE *yyvsp;
05016 
05017     YYSIZE_T yystacksize;
05018 
05019   int yyn;
05020   int yyresult;
05021   /* Lookahead token as an internal (translated) token number.  */
05022   int yytoken;
05023   /* The variables used to return semantic value and location from the
05024      action routines.  */
05025   YYSTYPE yyval;
05026 
05027 #if YYERROR_VERBOSE
05028   /* Buffer for error messages, and its allocated size.  */
05029   char yymsgbuf[128];
05030   char *yymsg = yymsgbuf;
05031   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
05032 #endif
05033 
05034 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
05035 
05036   /* The number of symbols on the RHS of the reduced rule.
05037      Keep to zero when no symbol should be popped.  */
05038   int yylen = 0;
05039 
05040   yytoken = 0;
05041   yyss = yyssa;
05042   yyvs = yyvsa;
05043   yystacksize = YYINITDEPTH;
05044 
05045   YYDPRINTF ((stderr, "Starting parse\n"));
05046 
05047   yystate = 0;
05048   yyerrstatus = 0;
05049   yynerrs = 0;
05050   yychar = YYEMPTY; /* Cause a token to be read.  */
05051 
05052   /* Initialize stack pointers.
05053      Waste one element of value and location stack
05054      so that they stay on the same level as the state stack.
05055      The wasted elements are never initialized.  */
05056   yyssp = yyss;
05057   yyvsp = yyvs;
05058 
05059   goto yysetstate;
05060 
05061 /*------------------------------------------------------------.
05062 | yynewstate -- Push a new state, which is found in yystate.  |
05063 `------------------------------------------------------------*/
05064  yynewstate:
05065   /* In all cases, when you get here, the value and location stacks
05066      have just been pushed.  So pushing a state here evens the stacks.  */
05067   yyssp++;
05068 
05069  yysetstate:
05070   *yyssp = yystate;
05071 
05072   if (yyss + yystacksize - 1 <= yyssp)
05073     {
05074       /* Get the current used size of the three stacks, in elements.  */
05075       YYSIZE_T yysize = yyssp - yyss + 1;
05076 
05077 #ifdef yyoverflow
05078       {
05079         /* Give user a chance to reallocate the stack.  Use copies of
05080            these so that the &'s don't force the real ones into
05081            memory.  */
05082         YYSTYPE *yyvs1 = yyvs;
05083         yytype_int16 *yyss1 = yyss;
05084 
05085         /* Each stack pointer address is followed by the size of the
05086            data in use in that stack, in bytes.  This used to be a
05087            conditional around just the two extra args, but that might
05088            be undefined if yyoverflow is a macro.  */
05089         yyoverflow (YY_("memory exhausted"),
05090                     &yyss1, yysize * sizeof (*yyssp),
05091                     &yyvs1, yysize * sizeof (*yyvsp),
05092                     &yystacksize);
05093 
05094         yyss = yyss1;
05095         yyvs = yyvs1;
05096       }
05097 #else /* no yyoverflow */
05098 # ifndef YYSTACK_RELOCATE
05099       goto yyexhaustedlab;
05100 # else
05101       /* Extend the stack our own way.  */
05102       if (YYMAXDEPTH <= yystacksize)
05103         goto yyexhaustedlab;
05104       yystacksize *= 2;
05105       if (YYMAXDEPTH < yystacksize)
05106         yystacksize = YYMAXDEPTH;
05107 
05108       {
05109         yytype_int16 *yyss1 = yyss;
05110         union yyalloc *yyptr =
05111           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
05112         if (! yyptr)
05113           goto yyexhaustedlab;
05114         YYSTACK_RELOCATE (yyss_alloc, yyss);
05115         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
05116 #  undef YYSTACK_RELOCATE
05117         if (yyss1 != yyssa)
05118           YYSTACK_FREE (yyss1);
05119       }
05120 # endif
05121 #endif /* no yyoverflow */
05122 
05123       yyssp = yyss + yysize - 1;
05124       yyvsp = yyvs + yysize - 1;
05125 
05126       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
05127                   (unsigned long int) yystacksize));
05128 
05129       if (yyss + yystacksize - 1 <= yyssp)
05130         YYABORT;
05131     }
05132 
05133   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
05134 
05135   if (yystate == YYFINAL)
05136     YYACCEPT;
05137 
05138   goto yybackup;
05139 
05140 /*-----------.
05141 | yybackup.  |
05142 `-----------*/
05143 yybackup:
05144 
05145   /* Do appropriate processing given the current state.  Read a
05146      lookahead token if we need one and don't already have one.  */
05147 
05148   /* First try to decide what to do without reference to lookahead token.  */
05149   yyn = yypact[yystate];
05150   if (yypact_value_is_default (yyn))
05151     goto yydefault;
05152 
05153   /* Not known => get a lookahead token if don't already have one.  */
05154 
05155   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
05156   if (yychar == YYEMPTY)
05157     {
05158       YYDPRINTF ((stderr, "Reading a token: "));
05159       yychar = YYLEX;
05160     }
05161 
05162   if (yychar <= YYEOF)
05163     {
05164       yychar = yytoken = YYEOF;
05165       YYDPRINTF ((stderr, "Now at end of input.\n"));
05166     }
05167   else
05168     {
05169       yytoken = YYTRANSLATE (yychar);
05170       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
05171     }
05172 
05173   /* If the proper action on seeing token YYTOKEN is to reduce or to
05174      detect an error, take that action.  */
05175   yyn += yytoken;
05176   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
05177     goto yydefault;
05178   yyn = yytable[yyn];
05179   if (yyn <= 0)
05180     {
05181       if (yytable_value_is_error (yyn))
05182         goto yyerrlab;
05183       yyn = -yyn;
05184       goto yyreduce;
05185     }
05186 
05187   /* Count tokens shifted since error; after three, turn off error
05188      status.  */
05189   if (yyerrstatus)
05190     yyerrstatus--;
05191 
05192   /* Shift the lookahead token.  */
05193   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
05194 
05195   /* Discard the shifted token.  */
05196   yychar = YYEMPTY;
05197 
05198   yystate = yyn;
05199   *++yyvsp = yylval;
05200 
05201   goto yynewstate;
05202 
05203 
05204 /*-----------------------------------------------------------.
05205 | yydefault -- do the default action for the current state.  |
05206 `-----------------------------------------------------------*/
05207 yydefault:
05208   yyn = yydefact[yystate];
05209   if (yyn == 0)
05210     goto yyerrlab;
05211   goto yyreduce;
05212 
05213 
05214 /*-----------------------------.
05215 | yyreduce -- Do a reduction.  |
05216 `-----------------------------*/
05217 yyreduce:
05218   /* yyn is the number of a rule to reduce with.  */
05219   yylen = yyr2[yyn];
05220 
05221   /* If YYLEN is nonzero, implement the default value of the action:
05222      `$$ = $1'.
05223 
05224      Otherwise, the following line sets YYVAL to garbage.
05225      This behavior is undocumented and Bison
05226      users should not rely upon it.  Assigning to YYVAL
05227      unconditionally makes the parser a bit smaller, and it avoids a
05228      GCC warning that YYVAL may be used uninitialized.  */
05229   yyval = yyvsp[1-yylen];
05230 
05231 
05232   YY_REDUCE_PRINT (yyn);
05233   switch (yyn)
05234     {
05235         case 2:
05236 
05237 /* Line 1806 of yacc.c  */
05238 #line 863 "parse.y"
05239     {
05240                         lex_state = EXPR_BEG;
05241                     /*%%%*/
05242                         local_push(compile_for_eval || rb_parse_in_main());
05243                     /*%
05244                         local_push(0);
05245                     %*/
05246                     }
05247     break;
05248 
05249   case 3:
05250 
05251 /* Line 1806 of yacc.c  */
05252 #line 872 "parse.y"
05253     {
05254                     /*%%%*/
05255                         if ((yyvsp[(2) - (2)].node) && !compile_for_eval) {
05256                             /* last expression should not be void */
05257                             if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node));
05258                             else {
05259                                 NODE *node = (yyvsp[(2) - (2)].node);
05260                                 while (node->nd_next) {
05261                                     node = node->nd_next;
05262                                 }
05263                                 void_expr(node->nd_head);
05264                             }
05265                         }
05266                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node)));
05267                     /*%
05268                         $$ = $2;
05269                         parser->result = dispatch1(program, $$);
05270                     %*/
05271                         local_pop();
05272                     }
05273     break;
05274 
05275   case 4:
05276 
05277 /* Line 1806 of yacc.c  */
05278 #line 895 "parse.y"
05279     {
05280                     /*%%%*/
05281                         void_stmts((yyvsp[(1) - (2)].node));
05282                         fixup_nodes(&deferred_nodes);
05283                     /*%
05284                     %*/
05285                         (yyval.node) = (yyvsp[(1) - (2)].node);
05286                     }
05287     break;
05288 
05289   case 5:
05290 
05291 /* Line 1806 of yacc.c  */
05292 #line 906 "parse.y"
05293     {
05294                     /*%%%*/
05295                         (yyval.node) = NEW_BEGIN(0);
05296                     /*%
05297                         $$ = dispatch2(stmts_add, dispatch0(stmts_new),
05298                                                   dispatch0(void_stmt));
05299                     %*/
05300                     }
05301     break;
05302 
05303   case 6:
05304 
05305 /* Line 1806 of yacc.c  */
05306 #line 915 "parse.y"
05307     {
05308                     /*%%%*/
05309                         (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
05310                     /*%
05311                         $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
05312                     %*/
05313                     }
05314     break;
05315 
05316   case 7:
05317 
05318 /* Line 1806 of yacc.c  */
05319 #line 923 "parse.y"
05320     {
05321                     /*%%%*/
05322                         (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
05323                     /*%
05324                         $$ = dispatch2(stmts_add, $1, $3);
05325                     %*/
05326                     }
05327     break;
05328 
05329   case 8:
05330 
05331 /* Line 1806 of yacc.c  */
05332 #line 931 "parse.y"
05333     {
05334                         (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
05335                     }
05336     break;
05337 
05338   case 10:
05339 
05340 /* Line 1806 of yacc.c  */
05341 #line 938 "parse.y"
05342     {
05343                     /*%%%*/
05344                         /* local_push(0); */
05345                     /*%
05346                     %*/
05347                     }
05348     break;
05349 
05350   case 11:
05351 
05352 /* Line 1806 of yacc.c  */
05353 #line 945 "parse.y"
05354     {
05355                     /*%%%*/
05356                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05357                                                             (yyvsp[(4) - (5)].node));
05358                         /* NEW_PREEXE($4)); */
05359                         /* local_pop(); */
05360                         (yyval.node) = NEW_BEGIN(0);
05361                     /*%
05362                         $$ = dispatch1(BEGIN, $4);
05363                     %*/
05364                     }
05365     break;
05366 
05367   case 12:
05368 
05369 /* Line 1806 of yacc.c  */
05370 #line 962 "parse.y"
05371     {
05372                     /*%%%*/
05373                         (yyval.node) = (yyvsp[(1) - (4)].node);
05374                         if ((yyvsp[(2) - (4)].node)) {
05375                             (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node));
05376                         }
05377                         else if ((yyvsp[(3) - (4)].node)) {
05378                             rb_warn0("else without rescue is useless");
05379                             (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node));
05380                         }
05381                         if ((yyvsp[(4) - (4)].node)) {
05382                             if ((yyval.node)) {
05383                                 (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node));
05384                             }
05385                             else {
05386                                 (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL());
05387                             }
05388                         }
05389                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
05390                     /*%
05391                         $$ = dispatch4(bodystmt,
05392                                        escape_Qundef($1),
05393                                        escape_Qundef($2),
05394                                        escape_Qundef($3),
05395                                        escape_Qundef($4));
05396                     %*/
05397                     }
05398     break;
05399 
05400   case 13:
05401 
05402 /* Line 1806 of yacc.c  */
05403 #line 992 "parse.y"
05404     {
05405                     /*%%%*/
05406                         void_stmts((yyvsp[(1) - (2)].node));
05407                         fixup_nodes(&deferred_nodes);
05408                     /*%
05409                     %*/
05410                         (yyval.node) = (yyvsp[(1) - (2)].node);
05411                     }
05412     break;
05413 
05414   case 14:
05415 
05416 /* Line 1806 of yacc.c  */
05417 #line 1003 "parse.y"
05418     {
05419                     /*%%%*/
05420                         (yyval.node) = NEW_BEGIN(0);
05421                     /*%
05422                         $$ = dispatch2(stmts_add, dispatch0(stmts_new),
05423                                                   dispatch0(void_stmt));
05424                     %*/
05425                     }
05426     break;
05427 
05428   case 15:
05429 
05430 /* Line 1806 of yacc.c  */
05431 #line 1012 "parse.y"
05432     {
05433                     /*%%%*/
05434                         (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
05435                     /*%
05436                         $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
05437                     %*/
05438                     }
05439     break;
05440 
05441   case 16:
05442 
05443 /* Line 1806 of yacc.c  */
05444 #line 1020 "parse.y"
05445     {
05446                     /*%%%*/
05447                         (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
05448                     /*%
05449                         $$ = dispatch2(stmts_add, $1, $3);
05450                     %*/
05451                     }
05452     break;
05453 
05454   case 17:
05455 
05456 /* Line 1806 of yacc.c  */
05457 #line 1028 "parse.y"
05458     {
05459                         (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
05460                     }
05461     break;
05462 
05463   case 18:
05464 
05465 /* Line 1806 of yacc.c  */
05466 #line 1034 "parse.y"
05467     {
05468                         (yyval.node) = (yyvsp[(1) - (1)].node);
05469                     }
05470     break;
05471 
05472   case 19:
05473 
05474 /* Line 1806 of yacc.c  */
05475 #line 1038 "parse.y"
05476     {
05477                         yyerror("BEGIN is permitted only at toplevel");
05478                     /*%%%*/
05479                         /* local_push(0); */
05480                     /*%
05481                     %*/
05482                     }
05483     break;
05484 
05485   case 20:
05486 
05487 /* Line 1806 of yacc.c  */
05488 #line 1046 "parse.y"
05489     {
05490                     /*%%%*/
05491                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05492                                                             (yyvsp[(4) - (5)].node));
05493                         /* NEW_PREEXE($4)); */
05494                         /* local_pop(); */
05495                         (yyval.node) = NEW_BEGIN(0);
05496                     /*%
05497                         $$ = dispatch1(BEGIN, $4);
05498                     %*/
05499                     }
05500     break;
05501 
05502   case 21:
05503 
05504 /* Line 1806 of yacc.c  */
05505 #line 1058 "parse.y"
05506     {lex_state = EXPR_FNAME;}
05507     break;
05508 
05509   case 22:
05510 
05511 /* Line 1806 of yacc.c  */
05512 #line 1059 "parse.y"
05513     {
05514                     /*%%%*/
05515                         (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
05516                     /*%
05517                         $$ = dispatch2(alias, $2, $4);
05518                     %*/
05519                     }
05520     break;
05521 
05522   case 23:
05523 
05524 /* Line 1806 of yacc.c  */
05525 #line 1067 "parse.y"
05526     {
05527                     /*%%%*/
05528                         (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
05529                     /*%
05530                         $$ = dispatch2(var_alias, $2, $3);
05531                     %*/
05532                     }
05533     break;
05534 
05535   case 24:
05536 
05537 /* Line 1806 of yacc.c  */
05538 #line 1075 "parse.y"
05539     {
05540                     /*%%%*/
05541                         char buf[2];
05542                         buf[0] = '$';
05543                         buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth;
05544                         (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2));
05545                     /*%
05546                         $$ = dispatch2(var_alias, $2, $3);
05547                     %*/
05548                     }
05549     break;
05550 
05551   case 25:
05552 
05553 /* Line 1806 of yacc.c  */
05554 #line 1086 "parse.y"
05555     {
05556                     /*%%%*/
05557                         yyerror("can't make alias for the number variables");
05558                         (yyval.node) = NEW_BEGIN(0);
05559                     /*%
05560                         $$ = dispatch2(var_alias, $2, $3);
05561                         $$ = dispatch1(alias_error, $$);
05562                     %*/
05563                     }
05564     break;
05565 
05566   case 26:
05567 
05568 /* Line 1806 of yacc.c  */
05569 #line 1096 "parse.y"
05570     {
05571                     /*%%%*/
05572                         (yyval.node) = (yyvsp[(2) - (2)].node);
05573                     /*%
05574                         $$ = dispatch1(undef, $2);
05575                     %*/
05576                     }
05577     break;
05578 
05579   case 27:
05580 
05581 /* Line 1806 of yacc.c  */
05582 #line 1104 "parse.y"
05583     {
05584                     /*%%%*/
05585                         (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
05586                         fixpos((yyval.node), (yyvsp[(3) - (3)].node));
05587                     /*%
05588                         $$ = dispatch2(if_mod, $3, $1);
05589                     %*/
05590                     }
05591     break;
05592 
05593   case 28:
05594 
05595 /* Line 1806 of yacc.c  */
05596 #line 1113 "parse.y"
05597     {
05598                     /*%%%*/
05599                         (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
05600                         fixpos((yyval.node), (yyvsp[(3) - (3)].node));
05601                     /*%
05602                         $$ = dispatch2(unless_mod, $3, $1);
05603                     %*/
05604                     }
05605     break;
05606 
05607   case 29:
05608 
05609 /* Line 1806 of yacc.c  */
05610 #line 1122 "parse.y"
05611     {
05612                     /*%%%*/
05613                         if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
05614                             (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
05615                         }
05616                         else {
05617                             (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
05618                         }
05619                     /*%
05620                         $$ = dispatch2(while_mod, $3, $1);
05621                     %*/
05622                     }
05623     break;
05624 
05625   case 30:
05626 
05627 /* Line 1806 of yacc.c  */
05628 #line 1135 "parse.y"
05629     {
05630                     /*%%%*/
05631                         if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
05632                             (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
05633                         }
05634                         else {
05635                             (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
05636                         }
05637                     /*%
05638                         $$ = dispatch2(until_mod, $3, $1);
05639                     %*/
05640                     }
05641     break;
05642 
05643   case 31:
05644 
05645 /* Line 1806 of yacc.c  */
05646 #line 1148 "parse.y"
05647     {
05648                     /*%%%*/
05649                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0);
05650                         (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0);
05651                     /*%
05652                         $$ = dispatch2(rescue_mod, $1, $3);
05653                     %*/
05654                     }
05655     break;
05656 
05657   case 32:
05658 
05659 /* Line 1806 of yacc.c  */
05660 #line 1157 "parse.y"
05661     {
05662                         if (in_def || in_single) {
05663                             rb_warn0("END in method; use at_exit");
05664                         }
05665                     /*%%%*/
05666                         (yyval.node) = NEW_POSTEXE(NEW_NODE(
05667                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */));
05668                     /*%
05669                         $$ = dispatch1(END, $3);
05670                     %*/
05671                     }
05672     break;
05673 
05674   case 34:
05675 
05676 /* Line 1806 of yacc.c  */
05677 #line 1170 "parse.y"
05678     {
05679                     /*%%%*/
05680                         value_expr((yyvsp[(3) - (3)].node));
05681                         (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
05682                         (yyval.node) = (yyvsp[(1) - (3)].node);
05683                     /*%
05684                         $$ = dispatch2(massign, $1, $3);
05685                     %*/
05686                     }
05687     break;
05688 
05689   case 35:
05690 
05691 /* Line 1806 of yacc.c  */
05692 #line 1180 "parse.y"
05693     {
05694                         value_expr((yyvsp[(3) - (3)].node));
05695                         (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
05696                     }
05697     break;
05698 
05699   case 36:
05700 
05701 /* Line 1806 of yacc.c  */
05702 #line 1185 "parse.y"
05703     {
05704                     /*%%%*/
05705                         NODE *args;
05706 
05707                         value_expr((yyvsp[(6) - (6)].node));
05708                         if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
05709                         args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
05710                         if ((yyvsp[(5) - (6)].id) == tOROP) {
05711                             (yyvsp[(5) - (6)].id) = 0;
05712                         }
05713                         else if ((yyvsp[(5) - (6)].id) == tANDOP) {
05714                             (yyvsp[(5) - (6)].id) = 1;
05715                         }
05716                         (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
05717                         fixpos((yyval.node), (yyvsp[(1) - (6)].node));
05718                     /*%
05719                         $$ = dispatch2(aref_field, $1, escape_Qundef($3));
05720                         $$ = dispatch3(opassign, $$, $5, $6);
05721                     %*/
05722                     }
05723     break;
05724 
05725   case 37:
05726 
05727 /* Line 1806 of yacc.c  */
05728 #line 1206 "parse.y"
05729     {
05730                         value_expr((yyvsp[(5) - (5)].node));
05731                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05732                     }
05733     break;
05734 
05735   case 38:
05736 
05737 /* Line 1806 of yacc.c  */
05738 #line 1211 "parse.y"
05739     {
05740                         value_expr((yyvsp[(5) - (5)].node));
05741                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05742                     }
05743     break;
05744 
05745   case 39:
05746 
05747 /* Line 1806 of yacc.c  */
05748 #line 1216 "parse.y"
05749     {
05750                     /*%%%*/
05751                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
05752                         (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05753                     /*%
05754                         $$ = dispatch2(const_path_field, $1, $3);
05755                         $$ = dispatch3(opassign, $$, $4, $5);
05756                     %*/
05757                     }
05758     break;
05759 
05760   case 40:
05761 
05762 /* Line 1806 of yacc.c  */
05763 #line 1226 "parse.y"
05764     {
05765                         value_expr((yyvsp[(5) - (5)].node));
05766                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
05767                     }
05768     break;
05769 
05770   case 41:
05771 
05772 /* Line 1806 of yacc.c  */
05773 #line 1231 "parse.y"
05774     {
05775                     /*%%%*/
05776                         rb_backref_error((yyvsp[(1) - (3)].node));
05777                         (yyval.node) = NEW_BEGIN(0);
05778                     /*%
05779                         $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
05780                         $$ = dispatch1(assign_error, $$);
05781                     %*/
05782                     }
05783     break;
05784 
05785   case 42:
05786 
05787 /* Line 1806 of yacc.c  */
05788 #line 1241 "parse.y"
05789     {
05790                     /*%%%*/
05791                         value_expr((yyvsp[(3) - (3)].node));
05792                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05793                     /*%
05794                         $$ = dispatch2(assign, $1, $3);
05795                     %*/
05796                     }
05797     break;
05798 
05799   case 43:
05800 
05801 /* Line 1806 of yacc.c  */
05802 #line 1250 "parse.y"
05803     {
05804                     /*%%%*/
05805                         (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
05806                         (yyval.node) = (yyvsp[(1) - (3)].node);
05807                     /*%
05808                         $$ = dispatch2(massign, $1, $3);
05809                     %*/
05810                     }
05811     break;
05812 
05813   case 45:
05814 
05815 /* Line 1806 of yacc.c  */
05816 #line 1262 "parse.y"
05817     {
05818                     /*%%%*/
05819                         value_expr((yyvsp[(3) - (3)].node));
05820                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05821                     /*%
05822                         $$ = dispatch2(assign, $1, $3);
05823                     %*/
05824                     }
05825     break;
05826 
05827   case 46:
05828 
05829 /* Line 1806 of yacc.c  */
05830 #line 1271 "parse.y"
05831     {
05832                     /*%%%*/
05833                         value_expr((yyvsp[(3) - (3)].node));
05834                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05835                     /*%
05836                         $$ = dispatch2(assign, $1, $3);
05837                     %*/
05838                     }
05839     break;
05840 
05841   case 48:
05842 
05843 /* Line 1806 of yacc.c  */
05844 #line 1284 "parse.y"
05845     {
05846                     /*%%%*/
05847                         (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05848                     /*%
05849                         $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
05850                     %*/
05851                     }
05852     break;
05853 
05854   case 49:
05855 
05856 /* Line 1806 of yacc.c  */
05857 #line 1292 "parse.y"
05858     {
05859                     /*%%%*/
05860                         (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
05861                     /*%
05862                         $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
05863                     %*/
05864                     }
05865     break;
05866 
05867   case 50:
05868 
05869 /* Line 1806 of yacc.c  */
05870 #line 1300 "parse.y"
05871     {
05872                     /*%%%*/
05873                         (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!');
05874                     /*%
05875                         $$ = dispatch2(unary, ripper_intern("not"), $3);
05876                     %*/
05877                     }
05878     break;
05879 
05880   case 51:
05881 
05882 /* Line 1806 of yacc.c  */
05883 #line 1308 "parse.y"
05884     {
05885                     /*%%%*/
05886                         (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
05887                     /*%
05888                         $$ = dispatch2(unary, ripper_id2sym('!'), $2);
05889                     %*/
05890                     }
05891     break;
05892 
05893   case 53:
05894 
05895 /* Line 1806 of yacc.c  */
05896 #line 1319 "parse.y"
05897     {
05898                     /*%%%*/
05899                         value_expr((yyvsp[(1) - (1)].node));
05900                         (yyval.node) = (yyvsp[(1) - (1)].node);
05901                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
05902                     /*%
05903                         $$ = $1;
05904                     %*/
05905                     }
05906     break;
05907 
05908   case 57:
05909 
05910 /* Line 1806 of yacc.c  */
05911 #line 1336 "parse.y"
05912     {
05913                     /*%%%*/
05914                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
05915                     /*%
05916                         $$ = dispatch3(call, $1, $2, $3);
05917                         $$ = method_arg($$, $4);
05918                     %*/
05919                     }
05920     break;
05921 
05922   case 58:
05923 
05924 /* Line 1806 of yacc.c  */
05925 #line 1347 "parse.y"
05926     {
05927                         (yyvsp[(1) - (1)].vars) = dyna_push();
05928                     /*%%%*/
05929                         (yyval.num) = ruby_sourceline;
05930                     /*%
05931                     %*/
05932                     }
05933     break;
05934 
05935   case 59:
05936 
05937 /* Line 1806 of yacc.c  */
05938 #line 1357 "parse.y"
05939     {
05940                     /*%%%*/
05941                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
05942                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
05943                     /*%
05944                         $$ = dispatch2(brace_block, escape_Qundef($3), $4);
05945                     %*/
05946                         dyna_pop((yyvsp[(1) - (5)].vars));
05947                     }
05948     break;
05949 
05950   case 60:
05951 
05952 /* Line 1806 of yacc.c  */
05953 #line 1369 "parse.y"
05954     {
05955                     /*%%%*/
05956                         (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
05957                         nd_set_line((yyval.node), tokline);
05958                     /*%
05959                     %*/
05960                     }
05961     break;
05962 
05963   case 61:
05964 
05965 /* Line 1806 of yacc.c  */
05966 #line 1379 "parse.y"
05967     {
05968                     /*%%%*/
05969                         (yyval.node) = (yyvsp[(1) - (2)].node);
05970                         (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
05971                     /*%
05972                         $$ = dispatch2(command, $1, $2);
05973                     %*/
05974                     }
05975     break;
05976 
05977   case 62:
05978 
05979 /* Line 1806 of yacc.c  */
05980 #line 1388 "parse.y"
05981     {
05982                     /*%%%*/
05983                         block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node));
05984                         (yyvsp[(1) - (3)].node)->nd_args = (yyvsp[(2) - (3)].node);
05985                         (yyvsp[(3) - (3)].node)->nd_iter = (yyvsp[(1) - (3)].node);
05986                         (yyval.node) = (yyvsp[(3) - (3)].node);
05987                         fixpos((yyval.node), (yyvsp[(1) - (3)].node));
05988                     /*%
05989                         $$ = dispatch2(command, $1, $2);
05990                         $$ = method_add_block($$, $3);
05991                     %*/
05992                     }
05993     break;
05994 
05995   case 63:
05996 
05997 /* Line 1806 of yacc.c  */
05998 #line 1401 "parse.y"
05999     {
06000                     /*%%%*/
06001                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
06002                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
06003                     /*%
06004                         $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
06005                     %*/
06006                     }
06007     break;
06008 
06009   case 64:
06010 
06011 /* Line 1806 of yacc.c  */
06012 #line 1410 "parse.y"
06013     {
06014                     /*%%%*/
06015                         block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
06016                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
06017                         (yyval.node) = (yyvsp[(5) - (5)].node);
06018                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
06019                     /*%
06020                         $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
06021                         $$ = method_add_block($$, $5);
06022                     %*/
06023                    }
06024     break;
06025 
06026   case 65:
06027 
06028 /* Line 1806 of yacc.c  */
06029 #line 1422 "parse.y"
06030     {
06031                     /*%%%*/
06032                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
06033                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
06034                     /*%
06035                         $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
06036                     %*/
06037                     }
06038     break;
06039 
06040   case 66:
06041 
06042 /* Line 1806 of yacc.c  */
06043 #line 1431 "parse.y"
06044     {
06045                     /*%%%*/
06046                         block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
06047                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
06048                         (yyval.node) = (yyvsp[(5) - (5)].node);
06049                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
06050                     /*%
06051                         $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
06052                         $$ = method_add_block($$, $5);
06053                     %*/
06054                    }
06055     break;
06056 
06057   case 67:
06058 
06059 /* Line 1806 of yacc.c  */
06060 #line 1443 "parse.y"
06061     {
06062                     /*%%%*/
06063                         (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
06064                         fixpos((yyval.node), (yyvsp[(2) - (2)].node));
06065                     /*%
06066                         $$ = dispatch1(super, $2);
06067                     %*/
06068                     }
06069     break;
06070 
06071   case 68:
06072 
06073 /* Line 1806 of yacc.c  */
06074 #line 1452 "parse.y"
06075     {
06076                     /*%%%*/
06077                         (yyval.node) = new_yield((yyvsp[(2) - (2)].node));
06078                         fixpos((yyval.node), (yyvsp[(2) - (2)].node));
06079                     /*%
06080                         $$ = dispatch1(yield, $2);
06081                     %*/
06082                     }
06083     break;
06084 
06085   case 69:
06086 
06087 /* Line 1806 of yacc.c  */
06088 #line 1461 "parse.y"
06089     {
06090                     /*%%%*/
06091                         (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node)));
06092                     /*%
06093                         $$ = dispatch1(return, $2);
06094                     %*/
06095                     }
06096     break;
06097 
06098   case 70:
06099 
06100 /* Line 1806 of yacc.c  */
06101 #line 1469 "parse.y"
06102     {
06103                     /*%%%*/
06104                         (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node)));
06105                     /*%
06106                         $$ = dispatch1(break, $2);
06107                     %*/
06108                     }
06109     break;
06110 
06111   case 71:
06112 
06113 /* Line 1806 of yacc.c  */
06114 #line 1477 "parse.y"
06115     {
06116                     /*%%%*/
06117                         (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node)));
06118                     /*%
06119                         $$ = dispatch1(next, $2);
06120                     %*/
06121                     }
06122     break;
06123 
06124   case 73:
06125 
06126 /* Line 1806 of yacc.c  */
06127 #line 1488 "parse.y"
06128     {
06129                     /*%%%*/
06130                         (yyval.node) = (yyvsp[(2) - (3)].node);
06131                     /*%
06132                         $$ = dispatch1(mlhs_paren, $2);
06133                     %*/
06134                     }
06135     break;
06136 
06137   case 75:
06138 
06139 /* Line 1806 of yacc.c  */
06140 #line 1499 "parse.y"
06141     {
06142                     /*%%%*/
06143                         (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0);
06144                     /*%
06145                         $$ = dispatch1(mlhs_paren, $2);
06146                     %*/
06147                     }
06148     break;
06149 
06150   case 76:
06151 
06152 /* Line 1806 of yacc.c  */
06153 #line 1509 "parse.y"
06154     {
06155                     /*%%%*/
06156                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
06157                     /*%
06158                         $$ = $1;
06159                     %*/
06160                     }
06161     break;
06162 
06163   case 77:
06164 
06165 /* Line 1806 of yacc.c  */
06166 #line 1517 "parse.y"
06167     {
06168                     /*%%%*/
06169                         (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0);
06170                     /*%
06171                         $$ = mlhs_add($1, $2);
06172                     %*/
06173                     }
06174     break;
06175 
06176   case 78:
06177 
06178 /* Line 1806 of yacc.c  */
06179 #line 1525 "parse.y"
06180     {
06181                     /*%%%*/
06182                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
06183                     /*%
06184                         $$ = mlhs_add_star($1, $3);
06185                     %*/
06186                     }
06187     break;
06188 
06189   case 79:
06190 
06191 /* Line 1806 of yacc.c  */
06192 #line 1533 "parse.y"
06193     {
06194                     /*%%%*/
06195                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node)));
06196                     /*%
06197                         $1 = mlhs_add_star($1, $3);
06198                         $$ = mlhs_add($1, $5);
06199                     %*/
06200                     }
06201     break;
06202 
06203   case 80:
06204 
06205 /* Line 1806 of yacc.c  */
06206 #line 1542 "parse.y"
06207     {
06208                     /*%%%*/
06209                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1);
06210                     /*%
06211                         $$ = mlhs_add_star($1, Qnil);
06212                     %*/
06213                     }
06214     break;
06215 
06216   case 81:
06217 
06218 /* Line 1806 of yacc.c  */
06219 #line 1550 "parse.y"
06220     {
06221                     /*%%%*/
06222                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node)));
06223                     /*%
06224                         $1 = mlhs_add_star($1, Qnil);
06225                         $$ = mlhs_add($1, $4);
06226                     %*/
06227                     }
06228     break;
06229 
06230   case 82:
06231 
06232 /* Line 1806 of yacc.c  */
06233 #line 1559 "parse.y"
06234     {
06235                     /*%%%*/
06236                         (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node));
06237                     /*%
06238                         $$ = mlhs_add_star(mlhs_new(), $2);
06239                     %*/
06240                     }
06241     break;
06242 
06243   case 83:
06244 
06245 /* Line 1806 of yacc.c  */
06246 #line 1567 "parse.y"
06247     {
06248                     /*%%%*/
06249                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node)));
06250                     /*%
06251                         $2 = mlhs_add_star(mlhs_new(), $2);
06252                         $$ = mlhs_add($2, $4);
06253                     %*/
06254                     }
06255     break;
06256 
06257   case 84:
06258 
06259 /* Line 1806 of yacc.c  */
06260 #line 1576 "parse.y"
06261     {
06262                     /*%%%*/
06263                         (yyval.node) = NEW_MASGN(0, -1);
06264                     /*%
06265                         $$ = mlhs_add_star(mlhs_new(), Qnil);
06266                     %*/
06267                     }
06268     break;
06269 
06270   case 85:
06271 
06272 /* Line 1806 of yacc.c  */
06273 #line 1584 "parse.y"
06274     {
06275                     /*%%%*/
06276                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
06277                     /*%
06278                         $$ = mlhs_add_star(mlhs_new(), Qnil);
06279                         $$ = mlhs_add($$, $3);
06280                     %*/
06281                     }
06282     break;
06283 
06284   case 87:
06285 
06286 /* Line 1806 of yacc.c  */
06287 #line 1596 "parse.y"
06288     {
06289                     /*%%%*/
06290                         (yyval.node) = (yyvsp[(2) - (3)].node);
06291                     /*%
06292                         $$ = dispatch1(mlhs_paren, $2);
06293                     %*/
06294                     }
06295     break;
06296 
06297   case 88:
06298 
06299 /* Line 1806 of yacc.c  */
06300 #line 1606 "parse.y"
06301     {
06302                     /*%%%*/
06303                         (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node));
06304                     /*%
06305                         $$ = mlhs_add(mlhs_new(), $1);
06306                     %*/
06307                     }
06308     break;
06309 
06310   case 89:
06311 
06312 /* Line 1806 of yacc.c  */
06313 #line 1614 "parse.y"
06314     {
06315                     /*%%%*/
06316                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
06317                     /*%
06318                         $$ = mlhs_add($1, $2);
06319                     %*/
06320                     }
06321     break;
06322 
06323   case 90:
06324 
06325 /* Line 1806 of yacc.c  */
06326 #line 1624 "parse.y"
06327     {
06328                     /*%%%*/
06329                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
06330                     /*%
06331                         $$ = mlhs_add(mlhs_new(), $1);
06332                     %*/
06333                     }
06334     break;
06335 
06336   case 91:
06337 
06338 /* Line 1806 of yacc.c  */
06339 #line 1632 "parse.y"
06340     {
06341                     /*%%%*/
06342                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
06343                     /*%
06344                         $$ = mlhs_add($1, $3);
06345                     %*/
06346                     }
06347     break;
06348 
06349   case 92:
06350 
06351 /* Line 1806 of yacc.c  */
06352 #line 1642 "parse.y"
06353     {
06354                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06355                     }
06356     break;
06357 
06358   case 93:
06359 
06360 /* Line 1806 of yacc.c  */
06361 #line 1646 "parse.y"
06362     {
06363                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06364                     }
06365     break;
06366 
06367   case 94:
06368 
06369 /* Line 1806 of yacc.c  */
06370 #line 1650 "parse.y"
06371     {
06372                     /*%%%*/
06373                         (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
06374                     /*%
06375                         $$ = dispatch2(aref_field, $1, escape_Qundef($3));
06376                     %*/
06377                     }
06378     break;
06379 
06380   case 95:
06381 
06382 /* Line 1806 of yacc.c  */
06383 #line 1658 "parse.y"
06384     {
06385                     /*%%%*/
06386                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06387                     /*%
06388                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06389                     %*/
06390                     }
06391     break;
06392 
06393   case 96:
06394 
06395 /* Line 1806 of yacc.c  */
06396 #line 1666 "parse.y"
06397     {
06398                     /*%%%*/
06399                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06400                     /*%
06401                         $$ = dispatch2(const_path_field, $1, $3);
06402                     %*/
06403                     }
06404     break;
06405 
06406   case 97:
06407 
06408 /* Line 1806 of yacc.c  */
06409 #line 1674 "parse.y"
06410     {
06411                     /*%%%*/
06412                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06413                     /*%
06414                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06415                     %*/
06416                     }
06417     break;
06418 
06419   case 98:
06420 
06421 /* Line 1806 of yacc.c  */
06422 #line 1682 "parse.y"
06423     {
06424                     /*%%%*/
06425                         if (in_def || in_single)
06426                             yyerror("dynamic constant assignment");
06427                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
06428                     /*%
06429                         if (in_def || in_single)
06430                             yyerror("dynamic constant assignment");
06431                         $$ = dispatch2(const_path_field, $1, $3);
06432                     %*/
06433                     }
06434     break;
06435 
06436   case 99:
06437 
06438 /* Line 1806 of yacc.c  */
06439 #line 1694 "parse.y"
06440     {
06441                     /*%%%*/
06442                         if (in_def || in_single)
06443                             yyerror("dynamic constant assignment");
06444                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
06445                     /*%
06446                         $$ = dispatch1(top_const_field, $2);
06447                     %*/
06448                     }
06449     break;
06450 
06451   case 100:
06452 
06453 /* Line 1806 of yacc.c  */
06454 #line 1704 "parse.y"
06455     {
06456                     /*%%%*/
06457                         rb_backref_error((yyvsp[(1) - (1)].node));
06458                         (yyval.node) = NEW_BEGIN(0);
06459                     /*%
06460                         $$ = dispatch1(var_field, $1);
06461                         $$ = dispatch1(assign_error, $$);
06462                     %*/
06463                     }
06464     break;
06465 
06466   case 101:
06467 
06468 /* Line 1806 of yacc.c  */
06469 #line 1716 "parse.y"
06470     {
06471                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06472                     /*%%%*/
06473                         if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
06474                     /*%
06475                         $$ = dispatch1(var_field, $$);
06476                     %*/
06477                     }
06478     break;
06479 
06480   case 102:
06481 
06482 /* Line 1806 of yacc.c  */
06483 #line 1725 "parse.y"
06484     {
06485                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
06486                     /*%%%*/
06487                         if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
06488                     /*%
06489                         $$ = dispatch1(var_field, $$);
06490                     %*/
06491                     }
06492     break;
06493 
06494   case 103:
06495 
06496 /* Line 1806 of yacc.c  */
06497 #line 1734 "parse.y"
06498     {
06499                     /*%%%*/
06500                         (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
06501                     /*%
06502                         $$ = dispatch2(aref_field, $1, escape_Qundef($3));
06503                     %*/
06504                     }
06505     break;
06506 
06507   case 104:
06508 
06509 /* Line 1806 of yacc.c  */
06510 #line 1742 "parse.y"
06511     {
06512                     /*%%%*/
06513                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06514                     /*%
06515                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06516                     %*/
06517                     }
06518     break;
06519 
06520   case 105:
06521 
06522 /* Line 1806 of yacc.c  */
06523 #line 1750 "parse.y"
06524     {
06525                     /*%%%*/
06526                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06527                     /*%
06528                         $$ = dispatch3(field, $1, ripper_intern("::"), $3);
06529                     %*/
06530                     }
06531     break;
06532 
06533   case 106:
06534 
06535 /* Line 1806 of yacc.c  */
06536 #line 1758 "parse.y"
06537     {
06538                     /*%%%*/
06539                         (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06540                     /*%
06541                         $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
06542                     %*/
06543                     }
06544     break;
06545 
06546   case 107:
06547 
06548 /* Line 1806 of yacc.c  */
06549 #line 1766 "parse.y"
06550     {
06551                     /*%%%*/
06552                         if (in_def || in_single)
06553                             yyerror("dynamic constant assignment");
06554                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
06555                     /*%
06556                         $$ = dispatch2(const_path_field, $1, $3);
06557                         if (in_def || in_single) {
06558                             $$ = dispatch1(assign_error, $$);
06559                         }
06560                     %*/
06561                     }
06562     break;
06563 
06564   case 108:
06565 
06566 /* Line 1806 of yacc.c  */
06567 #line 1779 "parse.y"
06568     {
06569                     /*%%%*/
06570                         if (in_def || in_single)
06571                             yyerror("dynamic constant assignment");
06572                         (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
06573                     /*%
06574                         $$ = dispatch1(top_const_field, $2);
06575                         if (in_def || in_single) {
06576                             $$ = dispatch1(assign_error, $$);
06577                         }
06578                     %*/
06579                     }
06580     break;
06581 
06582   case 109:
06583 
06584 /* Line 1806 of yacc.c  */
06585 #line 1792 "parse.y"
06586     {
06587                     /*%%%*/
06588                         rb_backref_error((yyvsp[(1) - (1)].node));
06589                         (yyval.node) = NEW_BEGIN(0);
06590                     /*%
06591                         $$ = dispatch1(assign_error, $1);
06592                     %*/
06593                     }
06594     break;
06595 
06596   case 110:
06597 
06598 /* Line 1806 of yacc.c  */
06599 #line 1803 "parse.y"
06600     {
06601                     /*%%%*/
06602                         yyerror("class/module name must be CONSTANT");
06603                     /*%
06604                         $$ = dispatch1(class_name_error, $1);
06605                     %*/
06606                     }
06607     break;
06608 
06609   case 112:
06610 
06611 /* Line 1806 of yacc.c  */
06612 #line 1814 "parse.y"
06613     {
06614                     /*%%%*/
06615                         (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
06616                     /*%
06617                         $$ = dispatch1(top_const_ref, $2);
06618                     %*/
06619                     }
06620     break;
06621 
06622   case 113:
06623 
06624 /* Line 1806 of yacc.c  */
06625 #line 1822 "parse.y"
06626     {
06627                     /*%%%*/
06628                         (yyval.node) = NEW_COLON2(0, (yyval.node));
06629                     /*%
06630                         $$ = dispatch1(const_ref, $1);
06631                     %*/
06632                     }
06633     break;
06634 
06635   case 114:
06636 
06637 /* Line 1806 of yacc.c  */
06638 #line 1830 "parse.y"
06639     {
06640                     /*%%%*/
06641                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
06642                     /*%
06643                         $$ = dispatch2(const_path_ref, $1, $3);
06644                     %*/
06645                     }
06646     break;
06647 
06648   case 118:
06649 
06650 /* Line 1806 of yacc.c  */
06651 #line 1843 "parse.y"
06652     {
06653                         lex_state = EXPR_ENDFN;
06654                         (yyval.id) = (yyvsp[(1) - (1)].id);
06655                     }
06656     break;
06657 
06658   case 119:
06659 
06660 /* Line 1806 of yacc.c  */
06661 #line 1848 "parse.y"
06662     {
06663                         lex_state = EXPR_ENDFN;
06664                     /*%%%*/
06665                         (yyval.id) = (yyvsp[(1) - (1)].id);
06666                     /*%
06667                         $$ = $1;
06668                     %*/
06669                     }
06670     break;
06671 
06672   case 122:
06673 
06674 /* Line 1806 of yacc.c  */
06675 #line 1863 "parse.y"
06676     {
06677                     /*%%%*/
06678                         (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
06679                     /*%
06680                         $$ = dispatch1(symbol_literal, $1);
06681                     %*/
06682                     }
06683     break;
06684 
06685   case 124:
06686 
06687 /* Line 1806 of yacc.c  */
06688 #line 1874 "parse.y"
06689     {
06690                     /*%%%*/
06691                         (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node));
06692                     /*%
06693                         $$ = rb_ary_new3(1, $1);
06694                     %*/
06695                     }
06696     break;
06697 
06698   case 125:
06699 
06700 /* Line 1806 of yacc.c  */
06701 #line 1881 "parse.y"
06702     {lex_state = EXPR_FNAME;}
06703     break;
06704 
06705   case 126:
06706 
06707 /* Line 1806 of yacc.c  */
06708 #line 1882 "parse.y"
06709     {
06710                     /*%%%*/
06711                         (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node)));
06712                     /*%
06713                         rb_ary_push($1, $4);
06714                     %*/
06715                     }
06716     break;
06717 
06718   case 127:
06719 
06720 /* Line 1806 of yacc.c  */
06721 #line 1891 "parse.y"
06722     { ifndef_ripper((yyval.id) = '|'); }
06723     break;
06724 
06725   case 128:
06726 
06727 /* Line 1806 of yacc.c  */
06728 #line 1892 "parse.y"
06729     { ifndef_ripper((yyval.id) = '^'); }
06730     break;
06731 
06732   case 129:
06733 
06734 /* Line 1806 of yacc.c  */
06735 #line 1893 "parse.y"
06736     { ifndef_ripper((yyval.id) = '&'); }
06737     break;
06738 
06739   case 130:
06740 
06741 /* Line 1806 of yacc.c  */
06742 #line 1894 "parse.y"
06743     { ifndef_ripper((yyval.id) = tCMP); }
06744     break;
06745 
06746   case 131:
06747 
06748 /* Line 1806 of yacc.c  */
06749 #line 1895 "parse.y"
06750     { ifndef_ripper((yyval.id) = tEQ); }
06751     break;
06752 
06753   case 132:
06754 
06755 /* Line 1806 of yacc.c  */
06756 #line 1896 "parse.y"
06757     { ifndef_ripper((yyval.id) = tEQQ); }
06758     break;
06759 
06760   case 133:
06761 
06762 /* Line 1806 of yacc.c  */
06763 #line 1897 "parse.y"
06764     { ifndef_ripper((yyval.id) = tMATCH); }
06765     break;
06766 
06767   case 134:
06768 
06769 /* Line 1806 of yacc.c  */
06770 #line 1898 "parse.y"
06771     { ifndef_ripper((yyval.id) = tNMATCH); }
06772     break;
06773 
06774   case 135:
06775 
06776 /* Line 1806 of yacc.c  */
06777 #line 1899 "parse.y"
06778     { ifndef_ripper((yyval.id) = '>'); }
06779     break;
06780 
06781   case 136:
06782 
06783 /* Line 1806 of yacc.c  */
06784 #line 1900 "parse.y"
06785     { ifndef_ripper((yyval.id) = tGEQ); }
06786     break;
06787 
06788   case 137:
06789 
06790 /* Line 1806 of yacc.c  */
06791 #line 1901 "parse.y"
06792     { ifndef_ripper((yyval.id) = '<'); }
06793     break;
06794 
06795   case 138:
06796 
06797 /* Line 1806 of yacc.c  */
06798 #line 1902 "parse.y"
06799     { ifndef_ripper((yyval.id) = tLEQ); }
06800     break;
06801 
06802   case 139:
06803 
06804 /* Line 1806 of yacc.c  */
06805 #line 1903 "parse.y"
06806     { ifndef_ripper((yyval.id) = tNEQ); }
06807     break;
06808 
06809   case 140:
06810 
06811 /* Line 1806 of yacc.c  */
06812 #line 1904 "parse.y"
06813     { ifndef_ripper((yyval.id) = tLSHFT); }
06814     break;
06815 
06816   case 141:
06817 
06818 /* Line 1806 of yacc.c  */
06819 #line 1905 "parse.y"
06820     { ifndef_ripper((yyval.id) = tRSHFT); }
06821     break;
06822 
06823   case 142:
06824 
06825 /* Line 1806 of yacc.c  */
06826 #line 1906 "parse.y"
06827     { ifndef_ripper((yyval.id) = '+'); }
06828     break;
06829 
06830   case 143:
06831 
06832 /* Line 1806 of yacc.c  */
06833 #line 1907 "parse.y"
06834     { ifndef_ripper((yyval.id) = '-'); }
06835     break;
06836 
06837   case 144:
06838 
06839 /* Line 1806 of yacc.c  */
06840 #line 1908 "parse.y"
06841     { ifndef_ripper((yyval.id) = '*'); }
06842     break;
06843 
06844   case 145:
06845 
06846 /* Line 1806 of yacc.c  */
06847 #line 1909 "parse.y"
06848     { ifndef_ripper((yyval.id) = '*'); }
06849     break;
06850 
06851   case 146:
06852 
06853 /* Line 1806 of yacc.c  */
06854 #line 1910 "parse.y"
06855     { ifndef_ripper((yyval.id) = '/'); }
06856     break;
06857 
06858   case 147:
06859 
06860 /* Line 1806 of yacc.c  */
06861 #line 1911 "parse.y"
06862     { ifndef_ripper((yyval.id) = '%'); }
06863     break;
06864 
06865   case 148:
06866 
06867 /* Line 1806 of yacc.c  */
06868 #line 1912 "parse.y"
06869     { ifndef_ripper((yyval.id) = tPOW); }
06870     break;
06871 
06872   case 149:
06873 
06874 /* Line 1806 of yacc.c  */
06875 #line 1913 "parse.y"
06876     { ifndef_ripper((yyval.id) = tDSTAR); }
06877     break;
06878 
06879   case 150:
06880 
06881 /* Line 1806 of yacc.c  */
06882 #line 1914 "parse.y"
06883     { ifndef_ripper((yyval.id) = '!'); }
06884     break;
06885 
06886   case 151:
06887 
06888 /* Line 1806 of yacc.c  */
06889 #line 1915 "parse.y"
06890     { ifndef_ripper((yyval.id) = '~'); }
06891     break;
06892 
06893   case 152:
06894 
06895 /* Line 1806 of yacc.c  */
06896 #line 1916 "parse.y"
06897     { ifndef_ripper((yyval.id) = tUPLUS); }
06898     break;
06899 
06900   case 153:
06901 
06902 /* Line 1806 of yacc.c  */
06903 #line 1917 "parse.y"
06904     { ifndef_ripper((yyval.id) = tUMINUS); }
06905     break;
06906 
06907   case 154:
06908 
06909 /* Line 1806 of yacc.c  */
06910 #line 1918 "parse.y"
06911     { ifndef_ripper((yyval.id) = tAREF); }
06912     break;
06913 
06914   case 155:
06915 
06916 /* Line 1806 of yacc.c  */
06917 #line 1919 "parse.y"
06918     { ifndef_ripper((yyval.id) = tASET); }
06919     break;
06920 
06921   case 156:
06922 
06923 /* Line 1806 of yacc.c  */
06924 #line 1920 "parse.y"
06925     { ifndef_ripper((yyval.id) = '`'); }
06926     break;
06927 
06928   case 198:
06929 
06930 /* Line 1806 of yacc.c  */
06931 #line 1938 "parse.y"
06932     {
06933                     /*%%%*/
06934                         value_expr((yyvsp[(3) - (3)].node));
06935                         (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
06936                     /*%
06937                         $$ = dispatch2(assign, $1, $3);
06938                     %*/
06939                     }
06940     break;
06941 
06942   case 199:
06943 
06944 /* Line 1806 of yacc.c  */
06945 #line 1947 "parse.y"
06946     {
06947                     /*%%%*/
06948                         value_expr((yyvsp[(3) - (5)].node));
06949                         (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
06950                         (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node));
06951                     /*%
06952                         $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
06953                     %*/
06954                     }
06955     break;
06956 
06957   case 200:
06958 
06959 /* Line 1806 of yacc.c  */
06960 #line 1957 "parse.y"
06961     {
06962                         value_expr((yyvsp[(3) - (3)].node));
06963                         (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
06964                     }
06965     break;
06966 
06967   case 201:
06968 
06969 /* Line 1806 of yacc.c  */
06970 #line 1962 "parse.y"
06971     {
06972                     /*%%%*/
06973                         value_expr((yyvsp[(3) - (5)].node));
06974                         (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
06975                     /*%
06976                         $3 = dispatch2(rescue_mod, $3, $5);
06977                     %*/
06978                         (yyval.node) = new_op_assign((yyvsp[(1) - (5)].node), (yyvsp[(2) - (5)].id), (yyvsp[(3) - (5)].node));
06979                     }
06980     break;
06981 
06982   case 202:
06983 
06984 /* Line 1806 of yacc.c  */
06985 #line 1972 "parse.y"
06986     {
06987                     /*%%%*/
06988                         NODE *args;
06989 
06990                         value_expr((yyvsp[(6) - (6)].node));
06991                         if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
06992                         if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) {
06993                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
06994                         }
06995                         else {
06996                             args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
06997                         }
06998                         if ((yyvsp[(5) - (6)].id) == tOROP) {
06999                             (yyvsp[(5) - (6)].id) = 0;
07000                         }
07001                         else if ((yyvsp[(5) - (6)].id) == tANDOP) {
07002                             (yyvsp[(5) - (6)].id) = 1;
07003                         }
07004                         (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
07005                         fixpos((yyval.node), (yyvsp[(1) - (6)].node));
07006                     /*%
07007                         $1 = dispatch2(aref_field, $1, escape_Qundef($3));
07008                         $$ = dispatch3(opassign, $1, $5, $6);
07009                     %*/
07010                     }
07011     break;
07012 
07013   case 203:
07014 
07015 /* Line 1806 of yacc.c  */
07016 #line 1998 "parse.y"
07017     {
07018                         value_expr((yyvsp[(5) - (5)].node));
07019                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
07020                     }
07021     break;
07022 
07023   case 204:
07024 
07025 /* Line 1806 of yacc.c  */
07026 #line 2003 "parse.y"
07027     {
07028                         value_expr((yyvsp[(5) - (5)].node));
07029                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
07030                     }
07031     break;
07032 
07033   case 205:
07034 
07035 /* Line 1806 of yacc.c  */
07036 #line 2008 "parse.y"
07037     {
07038                         value_expr((yyvsp[(5) - (5)].node));
07039                         (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
07040                     }
07041     break;
07042 
07043   case 206:
07044 
07045 /* Line 1806 of yacc.c  */
07046 #line 2013 "parse.y"
07047     {
07048                     /*%%%*/
07049                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
07050                         (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
07051                     /*%
07052                         $$ = dispatch2(const_path_field, $1, $3);
07053                         $$ = dispatch3(opassign, $$, $4, $5);
07054                     %*/
07055                     }
07056     break;
07057 
07058   case 207:
07059 
07060 /* Line 1806 of yacc.c  */
07061 #line 2023 "parse.y"
07062     {
07063                     /*%%%*/
07064                         (yyval.node) = NEW_COLON3((yyvsp[(2) - (4)].id));
07065                         (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
07066                     /*%
07067                         $$ = dispatch1(top_const_field, $2);
07068                         $$ = dispatch3(opassign, $$, $3, $4);
07069                     %*/
07070                     }
07071     break;
07072 
07073   case 208:
07074 
07075 /* Line 1806 of yacc.c  */
07076 #line 2033 "parse.y"
07077     {
07078                     /*%%%*/
07079                         rb_backref_error((yyvsp[(1) - (3)].node));
07080                         (yyval.node) = NEW_BEGIN(0);
07081                     /*%
07082                         $$ = dispatch1(var_field, $1);
07083                         $$ = dispatch3(opassign, $$, $2, $3);
07084                         $$ = dispatch1(assign_error, $$);
07085                     %*/
07086                     }
07087     break;
07088 
07089   case 209:
07090 
07091 /* Line 1806 of yacc.c  */
07092 #line 2044 "parse.y"
07093     {
07094                     /*%%%*/
07095                         value_expr((yyvsp[(1) - (3)].node));
07096                         value_expr((yyvsp[(3) - (3)].node));
07097                         (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07098                         if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
07099                             (yyvsp[(3) - (3)].node) && nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
07100                             deferred_nodes = list_append(deferred_nodes, (yyval.node));
07101                         }
07102                     /*%
07103                         $$ = dispatch2(dot2, $1, $3);
07104                     %*/
07105                     }
07106     break;
07107 
07108   case 210:
07109 
07110 /* Line 1806 of yacc.c  */
07111 #line 2058 "parse.y"
07112     {
07113                     /*%%%*/
07114                         value_expr((yyvsp[(1) - (3)].node));
07115                         value_expr((yyvsp[(3) - (3)].node));
07116                         (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07117                         if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
07118                             (yyvsp[(3) - (3)].node) && nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
07119                             deferred_nodes = list_append(deferred_nodes, (yyval.node));
07120                         }
07121                     /*%
07122                         $$ = dispatch2(dot3, $1, $3);
07123                     %*/
07124                     }
07125     break;
07126 
07127   case 211:
07128 
07129 /* Line 1806 of yacc.c  */
07130 #line 2072 "parse.y"
07131     {
07132                     /*%%%*/
07133                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '+', (yyvsp[(3) - (3)].node));
07134                     /*%
07135                         $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
07136                     %*/
07137                     }
07138     break;
07139 
07140   case 212:
07141 
07142 /* Line 1806 of yacc.c  */
07143 #line 2080 "parse.y"
07144     {
07145                     /*%%%*/
07146                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '-', (yyvsp[(3) - (3)].node));
07147                     /*%
07148                         $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
07149                     %*/
07150                     }
07151     break;
07152 
07153   case 213:
07154 
07155 /* Line 1806 of yacc.c  */
07156 #line 2088 "parse.y"
07157     {
07158                     /*%%%*/
07159                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '*', (yyvsp[(3) - (3)].node));
07160                     /*%
07161                         $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
07162                     %*/
07163                     }
07164     break;
07165 
07166   case 214:
07167 
07168 /* Line 1806 of yacc.c  */
07169 #line 2096 "parse.y"
07170     {
07171                     /*%%%*/
07172                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '/', (yyvsp[(3) - (3)].node));
07173                     /*%
07174                         $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
07175                     %*/
07176                     }
07177     break;
07178 
07179   case 215:
07180 
07181 /* Line 1806 of yacc.c  */
07182 #line 2104 "parse.y"
07183     {
07184                     /*%%%*/
07185                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node));
07186                     /*%
07187                         $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
07188                     %*/
07189                     }
07190     break;
07191 
07192   case 216:
07193 
07194 /* Line 1806 of yacc.c  */
07195 #line 2112 "parse.y"
07196     {
07197                     /*%%%*/
07198                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node));
07199                     /*%
07200                         $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
07201                     %*/
07202                     }
07203     break;
07204 
07205   case 217:
07206 
07207 /* Line 1806 of yacc.c  */
07208 #line 2120 "parse.y"
07209     {
07210                     /*%%%*/
07211                         (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
07212                     /*%
07213                         $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
07214                         $$ = dispatch2(unary, ripper_intern("-@"), $$);
07215                     %*/
07216                     }
07217     break;
07218 
07219   case 218:
07220 
07221 /* Line 1806 of yacc.c  */
07222 #line 2129 "parse.y"
07223     {
07224                     /*%%%*/
07225                         (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS);
07226                     /*%
07227                         $$ = dispatch2(unary, ripper_intern("+@"), $2);
07228                     %*/
07229                     }
07230     break;
07231 
07232   case 219:
07233 
07234 /* Line 1806 of yacc.c  */
07235 #line 2137 "parse.y"
07236     {
07237                     /*%%%*/
07238                         (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS);
07239                     /*%
07240                         $$ = dispatch2(unary, ripper_intern("-@"), $2);
07241                     %*/
07242                     }
07243     break;
07244 
07245   case 220:
07246 
07247 /* Line 1806 of yacc.c  */
07248 #line 2145 "parse.y"
07249     {
07250                     /*%%%*/
07251                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '|', (yyvsp[(3) - (3)].node));
07252                     /*%
07253                         $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
07254                     %*/
07255                     }
07256     break;
07257 
07258   case 221:
07259 
07260 /* Line 1806 of yacc.c  */
07261 #line 2153 "parse.y"
07262     {
07263                     /*%%%*/
07264                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '^', (yyvsp[(3) - (3)].node));
07265                     /*%
07266                         $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
07267                     %*/
07268                     }
07269     break;
07270 
07271   case 222:
07272 
07273 /* Line 1806 of yacc.c  */
07274 #line 2161 "parse.y"
07275     {
07276                     /*%%%*/
07277                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node));
07278                     /*%
07279                         $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
07280                     %*/
07281                     }
07282     break;
07283 
07284   case 223:
07285 
07286 /* Line 1806 of yacc.c  */
07287 #line 2169 "parse.y"
07288     {
07289                     /*%%%*/
07290                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node));
07291                     /*%
07292                         $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
07293                     %*/
07294                     }
07295     break;
07296 
07297   case 224:
07298 
07299 /* Line 1806 of yacc.c  */
07300 #line 2177 "parse.y"
07301     {
07302                     /*%%%*/
07303                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node));
07304                     /*%
07305                         $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
07306                     %*/
07307                     }
07308     break;
07309 
07310   case 225:
07311 
07312 /* Line 1806 of yacc.c  */
07313 #line 2185 "parse.y"
07314     {
07315                     /*%%%*/
07316                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node));
07317                     /*%
07318                         $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
07319                     %*/
07320                     }
07321     break;
07322 
07323   case 226:
07324 
07325 /* Line 1806 of yacc.c  */
07326 #line 2193 "parse.y"
07327     {
07328                     /*%%%*/
07329                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node));
07330                     /*%
07331                         $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
07332                     %*/
07333                     }
07334     break;
07335 
07336   case 227:
07337 
07338 /* Line 1806 of yacc.c  */
07339 #line 2201 "parse.y"
07340     {
07341                     /*%%%*/
07342                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node));
07343                     /*%
07344                         $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
07345                     %*/
07346                     }
07347     break;
07348 
07349   case 228:
07350 
07351 /* Line 1806 of yacc.c  */
07352 #line 2209 "parse.y"
07353     {
07354                     /*%%%*/
07355                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node));
07356                     /*%
07357                         $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
07358                     %*/
07359                     }
07360     break;
07361 
07362   case 229:
07363 
07364 /* Line 1806 of yacc.c  */
07365 #line 2217 "parse.y"
07366     {
07367                     /*%%%*/
07368                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node));
07369                     /*%
07370                         $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
07371                     %*/
07372                     }
07373     break;
07374 
07375   case 230:
07376 
07377 /* Line 1806 of yacc.c  */
07378 #line 2225 "parse.y"
07379     {
07380                     /*%%%*/
07381                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node));
07382                     /*%
07383                         $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
07384                     %*/
07385                     }
07386     break;
07387 
07388   case 231:
07389 
07390 /* Line 1806 of yacc.c  */
07391 #line 2233 "parse.y"
07392     {
07393                     /*%%%*/
07394                         (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07395                         if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].node)->nd_lit, T_REGEXP)) {
07396                             (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node));
07397                         }
07398                     /*%
07399                         $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
07400                     %*/
07401                     }
07402     break;
07403 
07404   case 232:
07405 
07406 /* Line 1806 of yacc.c  */
07407 #line 2244 "parse.y"
07408     {
07409                     /*%%%*/
07410                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node));
07411                     /*%
07412                         $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
07413                     %*/
07414                     }
07415     break;
07416 
07417   case 233:
07418 
07419 /* Line 1806 of yacc.c  */
07420 #line 2252 "parse.y"
07421     {
07422                     /*%%%*/
07423                         (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
07424                     /*%
07425                         $$ = dispatch2(unary, ID2SYM('!'), $2);
07426                     %*/
07427                     }
07428     break;
07429 
07430   case 234:
07431 
07432 /* Line 1806 of yacc.c  */
07433 #line 2260 "parse.y"
07434     {
07435                     /*%%%*/
07436                         (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~');
07437                     /*%
07438                         $$ = dispatch2(unary, ID2SYM('~'), $2);
07439                     %*/
07440                     }
07441     break;
07442 
07443   case 235:
07444 
07445 /* Line 1806 of yacc.c  */
07446 #line 2268 "parse.y"
07447     {
07448                     /*%%%*/
07449                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node));
07450                     /*%
07451                         $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
07452                     %*/
07453                     }
07454     break;
07455 
07456   case 236:
07457 
07458 /* Line 1806 of yacc.c  */
07459 #line 2276 "parse.y"
07460     {
07461                     /*%%%*/
07462                         (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node));
07463                     /*%
07464                         $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
07465                     %*/
07466                     }
07467     break;
07468 
07469   case 237:
07470 
07471 /* Line 1806 of yacc.c  */
07472 #line 2284 "parse.y"
07473     {
07474                     /*%%%*/
07475                         (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07476                     /*%
07477                         $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
07478                     %*/
07479                     }
07480     break;
07481 
07482   case 238:
07483 
07484 /* Line 1806 of yacc.c  */
07485 #line 2292 "parse.y"
07486     {
07487                     /*%%%*/
07488                         (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07489                     /*%
07490                         $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
07491                     %*/
07492                     }
07493     break;
07494 
07495   case 239:
07496 
07497 /* Line 1806 of yacc.c  */
07498 #line 2299 "parse.y"
07499     {in_defined = 1;}
07500     break;
07501 
07502   case 240:
07503 
07504 /* Line 1806 of yacc.c  */
07505 #line 2300 "parse.y"
07506     {
07507                     /*%%%*/
07508                         in_defined = 0;
07509                         (yyval.node) = new_defined((yyvsp[(4) - (4)].node));
07510                     /*%
07511                         in_defined = 0;
07512                         $$ = dispatch1(defined, $4);
07513                     %*/
07514                     }
07515     break;
07516 
07517   case 241:
07518 
07519 /* Line 1806 of yacc.c  */
07520 #line 2310 "parse.y"
07521     {
07522                     /*%%%*/
07523                         value_expr((yyvsp[(1) - (6)].node));
07524                         (yyval.node) = NEW_IF(cond((yyvsp[(1) - (6)].node)), (yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
07525                         fixpos((yyval.node), (yyvsp[(1) - (6)].node));
07526                     /*%
07527                         $$ = dispatch3(ifop, $1, $3, $6);
07528                     %*/
07529                     }
07530     break;
07531 
07532   case 242:
07533 
07534 /* Line 1806 of yacc.c  */
07535 #line 2320 "parse.y"
07536     {
07537                         (yyval.node) = (yyvsp[(1) - (1)].node);
07538                     }
07539     break;
07540 
07541   case 243:
07542 
07543 /* Line 1806 of yacc.c  */
07544 #line 2326 "parse.y"
07545     {
07546                     /*%%%*/
07547                         value_expr((yyvsp[(1) - (1)].node));
07548                         (yyval.node) = (yyvsp[(1) - (1)].node);
07549                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
07550                     /*%
07551                         $$ = $1;
07552                     %*/
07553                     }
07554     break;
07555 
07556   case 245:
07557 
07558 /* Line 1806 of yacc.c  */
07559 #line 2339 "parse.y"
07560     {
07561                         (yyval.node) = (yyvsp[(1) - (2)].node);
07562                     }
07563     break;
07564 
07565   case 246:
07566 
07567 /* Line 1806 of yacc.c  */
07568 #line 2343 "parse.y"
07569     {
07570                     /*%%%*/
07571                         (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
07572                     /*%
07573                         $$ = arg_add_assocs($1, $3);
07574                     %*/
07575                     }
07576     break;
07577 
07578   case 247:
07579 
07580 /* Line 1806 of yacc.c  */
07581 #line 2351 "parse.y"
07582     {
07583                     /*%%%*/
07584                         (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
07585                     /*%
07586                         $$ = arg_add_assocs(arg_new(), $1);
07587                     %*/
07588                     }
07589     break;
07590 
07591   case 248:
07592 
07593 /* Line 1806 of yacc.c  */
07594 #line 2361 "parse.y"
07595     {
07596                     /*%%%*/
07597                         (yyval.node) = (yyvsp[(2) - (3)].node);
07598                     /*%
07599                         $$ = dispatch1(arg_paren, escape_Qundef($2));
07600                     %*/
07601                     }
07602     break;
07603 
07604   case 253:
07605 
07606 /* Line 1806 of yacc.c  */
07607 #line 2377 "parse.y"
07608     {
07609                       (yyval.node) = (yyvsp[(1) - (2)].node);
07610                     }
07611     break;
07612 
07613   case 254:
07614 
07615 /* Line 1806 of yacc.c  */
07616 #line 2381 "parse.y"
07617     {
07618                     /*%%%*/
07619                         (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
07620                     /*%
07621                         $$ = arg_add_assocs($1, $3);
07622                     %*/
07623                     }
07624     break;
07625 
07626   case 255:
07627 
07628 /* Line 1806 of yacc.c  */
07629 #line 2389 "parse.y"
07630     {
07631                     /*%%%*/
07632                         (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
07633                     /*%
07634                         $$ = arg_add_assocs(arg_new(), $1);
07635                     %*/
07636                     }
07637     break;
07638 
07639   case 256:
07640 
07641 /* Line 1806 of yacc.c  */
07642 #line 2399 "parse.y"
07643     {
07644                     /*%%%*/
07645                         value_expr((yyvsp[(1) - (1)].node));
07646                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
07647                     /*%
07648                         $$ = arg_add(arg_new(), $1);
07649                     %*/
07650                     }
07651     break;
07652 
07653   case 257:
07654 
07655 /* Line 1806 of yacc.c  */
07656 #line 2408 "parse.y"
07657     {
07658                     /*%%%*/
07659                         (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
07660                     /*%
07661                         $$ = arg_add_optblock($1, $2);
07662                     %*/
07663                     }
07664     break;
07665 
07666   case 258:
07667 
07668 /* Line 1806 of yacc.c  */
07669 #line 2416 "parse.y"
07670     {
07671                     /*%%%*/
07672                         (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
07673                         (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node));
07674                     /*%
07675                         $$ = arg_add_assocs(arg_new(), $1);
07676                         $$ = arg_add_optblock($$, $2);
07677                     %*/
07678                     }
07679     break;
07680 
07681   case 259:
07682 
07683 /* Line 1806 of yacc.c  */
07684 #line 2426 "parse.y"
07685     {
07686                     /*%%%*/
07687                         (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
07688                         (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node));
07689                     /*%
07690                         $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
07691                     %*/
07692                     }
07693     break;
07694 
07695   case 261:
07696 
07697 /* Line 1806 of yacc.c  */
07698 #line 2443 "parse.y"
07699     {
07700                         (yyval.val) = cmdarg_stack;
07701                         CMDARG_PUSH(1);
07702                     }
07703     break;
07704 
07705   case 262:
07706 
07707 /* Line 1806 of yacc.c  */
07708 #line 2448 "parse.y"
07709     {
07710                         /* CMDARG_POP() */
07711                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07712                         (yyval.node) = (yyvsp[(2) - (2)].node);
07713                     }
07714     break;
07715 
07716   case 263:
07717 
07718 /* Line 1806 of yacc.c  */
07719 #line 2456 "parse.y"
07720     {
07721                     /*%%%*/
07722                         (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node));
07723                     /*%
07724                         $$ = $2;
07725                     %*/
07726                     }
07727     break;
07728 
07729   case 264:
07730 
07731 /* Line 1806 of yacc.c  */
07732 #line 2466 "parse.y"
07733     {
07734                         (yyval.node) = (yyvsp[(2) - (2)].node);
07735                     }
07736     break;
07737 
07738   case 265:
07739 
07740 /* Line 1806 of yacc.c  */
07741 #line 2470 "parse.y"
07742     {
07743                         (yyval.node) = 0;
07744                     }
07745     break;
07746 
07747   case 266:
07748 
07749 /* Line 1806 of yacc.c  */
07750 #line 2476 "parse.y"
07751     {
07752                     /*%%%*/
07753                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
07754                     /*%
07755                         $$ = arg_add(arg_new(), $1);
07756                     %*/
07757                     }
07758     break;
07759 
07760   case 267:
07761 
07762 /* Line 1806 of yacc.c  */
07763 #line 2484 "parse.y"
07764     {
07765                     /*%%%*/
07766                         (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
07767                     /*%
07768                         $$ = arg_add_star(arg_new(), $2);
07769                     %*/
07770                     }
07771     break;
07772 
07773   case 268:
07774 
07775 /* Line 1806 of yacc.c  */
07776 #line 2492 "parse.y"
07777     {
07778                     /*%%%*/
07779                         NODE *n1;
07780                         if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
07781                             (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
07782                         }
07783                         else {
07784                             (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07785                         }
07786                     /*%
07787                         $$ = arg_add($1, $3);
07788                     %*/
07789                     }
07790     break;
07791 
07792   case 269:
07793 
07794 /* Line 1806 of yacc.c  */
07795 #line 2506 "parse.y"
07796     {
07797                     /*%%%*/
07798                         NODE *n1;
07799                         if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
07800                             (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
07801                         }
07802                         else {
07803                             (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
07804                         }
07805                     /*%
07806                         $$ = arg_add_star($1, $4);
07807                     %*/
07808                     }
07809     break;
07810 
07811   case 272:
07812 
07813 /* Line 1806 of yacc.c  */
07814 #line 2526 "parse.y"
07815     {
07816                     /*%%%*/
07817                         NODE *n1;
07818                         if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
07819                             (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
07820                         }
07821                         else {
07822                             (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
07823                         }
07824                     /*%
07825                         $$ = mrhs_add(args2mrhs($1), $3);
07826                     %*/
07827                     }
07828     break;
07829 
07830   case 273:
07831 
07832 /* Line 1806 of yacc.c  */
07833 #line 2540 "parse.y"
07834     {
07835                     /*%%%*/
07836                         NODE *n1;
07837                         if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY &&
07838                             (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
07839                             (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
07840                         }
07841                         else {
07842                             (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
07843                         }
07844                     /*%
07845                         $$ = mrhs_add_star(args2mrhs($1), $4);
07846                     %*/
07847                     }
07848     break;
07849 
07850   case 274:
07851 
07852 /* Line 1806 of yacc.c  */
07853 #line 2555 "parse.y"
07854     {
07855                     /*%%%*/
07856                         (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
07857                     /*%
07858                         $$ = mrhs_add_star(mrhs_new(), $2);
07859                     %*/
07860                     }
07861     break;
07862 
07863   case 285:
07864 
07865 /* Line 1806 of yacc.c  */
07866 #line 2575 "parse.y"
07867     {
07868                     /*%%%*/
07869                         (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
07870                     /*%
07871                         $$ = method_arg(dispatch1(fcall, $1), arg_new());
07872                     %*/
07873                     }
07874     break;
07875 
07876   case 286:
07877 
07878 /* Line 1806 of yacc.c  */
07879 #line 2583 "parse.y"
07880     {
07881                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07882                         cmdarg_stack = 0;
07883                     /*%%%*/
07884                         (yyval.num) = ruby_sourceline;
07885                     /*%
07886                     %*/
07887                     }
07888     break;
07889 
07890   case 287:
07891 
07892 /* Line 1806 of yacc.c  */
07893 #line 2593 "parse.y"
07894     {
07895                         cmdarg_stack = (yyvsp[(1) - (4)].val);
07896                     /*%%%*/
07897                         if ((yyvsp[(3) - (4)].node) == NULL) {
07898                             (yyval.node) = NEW_NIL();
07899                         }
07900                         else {
07901                             if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE ||
07902                                 nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE)
07903                                 nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num));
07904                             (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node));
07905                         }
07906                         nd_set_line((yyval.node), (yyvsp[(2) - (4)].num));
07907                     /*%
07908                         $$ = dispatch1(begin, $3);
07909                     %*/
07910                     }
07911     break;
07912 
07913   case 288:
07914 
07915 /* Line 1806 of yacc.c  */
07916 #line 2610 "parse.y"
07917     {lex_state = EXPR_ENDARG;}
07918     break;
07919 
07920   case 289:
07921 
07922 /* Line 1806 of yacc.c  */
07923 #line 2611 "parse.y"
07924     {
07925                     /*%%%*/
07926                         (yyval.node) = 0;
07927                     /*%
07928                         $$ = dispatch1(paren, 0);
07929                     %*/
07930                     }
07931     break;
07932 
07933   case 290:
07934 
07935 /* Line 1806 of yacc.c  */
07936 #line 2619 "parse.y"
07937     {
07938                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07939                         cmdarg_stack = 0;
07940                     }
07941     break;
07942 
07943   case 291:
07944 
07945 /* Line 1806 of yacc.c  */
07946 #line 2623 "parse.y"
07947     {lex_state = EXPR_ENDARG;}
07948     break;
07949 
07950   case 292:
07951 
07952 /* Line 1806 of yacc.c  */
07953 #line 2624 "parse.y"
07954     {
07955                         cmdarg_stack = (yyvsp[(1) - (5)].val);
07956                     /*%%%*/
07957                         (yyval.node) = (yyvsp[(3) - (5)].node);
07958                     /*%
07959                         $$ = dispatch1(paren, $3);
07960                     %*/
07961                     }
07962     break;
07963 
07964   case 293:
07965 
07966 /* Line 1806 of yacc.c  */
07967 #line 2633 "parse.y"
07968     {
07969                     /*%%%*/
07970                         (yyval.node) = (yyvsp[(2) - (3)].node);
07971                     /*%
07972                         $$ = dispatch1(paren, $2);
07973                     %*/
07974                     }
07975     break;
07976 
07977   case 294:
07978 
07979 /* Line 1806 of yacc.c  */
07980 #line 2641 "parse.y"
07981     {
07982                     /*%%%*/
07983                         (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
07984                     /*%
07985                         $$ = dispatch2(const_path_ref, $1, $3);
07986                     %*/
07987                     }
07988     break;
07989 
07990   case 295:
07991 
07992 /* Line 1806 of yacc.c  */
07993 #line 2649 "parse.y"
07994     {
07995                     /*%%%*/
07996                         (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
07997                     /*%
07998                         $$ = dispatch1(top_const_ref, $2);
07999                     %*/
08000                     }
08001     break;
08002 
08003   case 296:
08004 
08005 /* Line 1806 of yacc.c  */
08006 #line 2657 "parse.y"
08007     {
08008                     /*%%%*/
08009                         if ((yyvsp[(2) - (3)].node) == 0) {
08010                             (yyval.node) = NEW_ZARRAY(); /* zero length array*/
08011                         }
08012                         else {
08013                             (yyval.node) = (yyvsp[(2) - (3)].node);
08014                         }
08015                     /*%
08016                         $$ = dispatch1(array, escape_Qundef($2));
08017                     %*/
08018                     }
08019     break;
08020 
08021   case 297:
08022 
08023 /* Line 1806 of yacc.c  */
08024 #line 2670 "parse.y"
08025     {
08026                     /*%%%*/
08027                         (yyval.node) = NEW_HASH((yyvsp[(2) - (3)].node));
08028                     /*%
08029                         $$ = dispatch1(hash, escape_Qundef($2));
08030                     %*/
08031                     }
08032     break;
08033 
08034   case 298:
08035 
08036 /* Line 1806 of yacc.c  */
08037 #line 2678 "parse.y"
08038     {
08039                     /*%%%*/
08040                         (yyval.node) = NEW_RETURN(0);
08041                     /*%
08042                         $$ = dispatch0(return0);
08043                     %*/
08044                     }
08045     break;
08046 
08047   case 299:
08048 
08049 /* Line 1806 of yacc.c  */
08050 #line 2686 "parse.y"
08051     {
08052                     /*%%%*/
08053                         (yyval.node) = new_yield((yyvsp[(3) - (4)].node));
08054                     /*%
08055                         $$ = dispatch1(yield, dispatch1(paren, $3));
08056                     %*/
08057                     }
08058     break;
08059 
08060   case 300:
08061 
08062 /* Line 1806 of yacc.c  */
08063 #line 2694 "parse.y"
08064     {
08065                     /*%%%*/
08066                         (yyval.node) = NEW_YIELD(0);
08067                     /*%
08068                         $$ = dispatch1(yield, dispatch1(paren, arg_new()));
08069                     %*/
08070                     }
08071     break;
08072 
08073   case 301:
08074 
08075 /* Line 1806 of yacc.c  */
08076 #line 2702 "parse.y"
08077     {
08078                     /*%%%*/
08079                         (yyval.node) = NEW_YIELD(0);
08080                     /*%
08081                         $$ = dispatch0(yield0);
08082                     %*/
08083                     }
08084     break;
08085 
08086   case 302:
08087 
08088 /* Line 1806 of yacc.c  */
08089 #line 2709 "parse.y"
08090     {in_defined = 1;}
08091     break;
08092 
08093   case 303:
08094 
08095 /* Line 1806 of yacc.c  */
08096 #line 2710 "parse.y"
08097     {
08098                     /*%%%*/
08099                         in_defined = 0;
08100                         (yyval.node) = new_defined((yyvsp[(5) - (6)].node));
08101                     /*%
08102                         in_defined = 0;
08103                         $$ = dispatch1(defined, $5);
08104                     %*/
08105                     }
08106     break;
08107 
08108   case 304:
08109 
08110 /* Line 1806 of yacc.c  */
08111 #line 2720 "parse.y"
08112     {
08113                     /*%%%*/
08114                         (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!');
08115                     /*%
08116                         $$ = dispatch2(unary, ripper_intern("not"), $3);
08117                     %*/
08118                     }
08119     break;
08120 
08121   case 305:
08122 
08123 /* Line 1806 of yacc.c  */
08124 #line 2728 "parse.y"
08125     {
08126                     /*%%%*/
08127                         (yyval.node) = call_uni_op(cond(NEW_NIL()), '!');
08128                     /*%
08129                         $$ = dispatch2(unary, ripper_intern("not"), Qnil);
08130                     %*/
08131                     }
08132     break;
08133 
08134   case 306:
08135 
08136 /* Line 1806 of yacc.c  */
08137 #line 2736 "parse.y"
08138     {
08139                     /*%%%*/
08140                         (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
08141                         (yyval.node) = (yyvsp[(2) - (2)].node);
08142                     /*%
08143                         $$ = method_arg(dispatch1(fcall, $1), arg_new());
08144                         $$ = method_add_block($$, $2);
08145                     %*/
08146                     }
08147     break;
08148 
08149   case 308:
08150 
08151 /* Line 1806 of yacc.c  */
08152 #line 2747 "parse.y"
08153     {
08154                     /*%%%*/
08155                         block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
08156                         (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
08157                         (yyval.node) = (yyvsp[(2) - (2)].node);
08158                     /*%
08159                         $$ = method_add_block($1, $2);
08160                     %*/
08161                     }
08162     break;
08163 
08164   case 309:
08165 
08166 /* Line 1806 of yacc.c  */
08167 #line 2757 "parse.y"
08168     {
08169                         (yyval.node) = (yyvsp[(2) - (2)].node);
08170                     }
08171     break;
08172 
08173   case 310:
08174 
08175 /* Line 1806 of yacc.c  */
08176 #line 2764 "parse.y"
08177     {
08178                     /*%%%*/
08179                         (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
08180                         fixpos((yyval.node), (yyvsp[(2) - (6)].node));
08181                     /*%
08182                         $$ = dispatch3(if, $2, $4, escape_Qundef($5));
08183                     %*/
08184                     }
08185     break;
08186 
08187   case 311:
08188 
08189 /* Line 1806 of yacc.c  */
08190 #line 2776 "parse.y"
08191     {
08192                     /*%%%*/
08193                         (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
08194                         fixpos((yyval.node), (yyvsp[(2) - (6)].node));
08195                     /*%
08196                         $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
08197                     %*/
08198                     }
08199     break;
08200 
08201   case 312:
08202 
08203 /* Line 1806 of yacc.c  */
08204 #line 2784 "parse.y"
08205     {COND_PUSH(1);}
08206     break;
08207 
08208   case 313:
08209 
08210 /* Line 1806 of yacc.c  */
08211 #line 2784 "parse.y"
08212     {COND_POP();}
08213     break;
08214 
08215   case 314:
08216 
08217 /* Line 1806 of yacc.c  */
08218 #line 2787 "parse.y"
08219     {
08220                     /*%%%*/
08221                         (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
08222                         fixpos((yyval.node), (yyvsp[(3) - (7)].node));
08223                     /*%
08224                         $$ = dispatch2(while, $3, $6);
08225                     %*/
08226                     }
08227     break;
08228 
08229   case 315:
08230 
08231 /* Line 1806 of yacc.c  */
08232 #line 2795 "parse.y"
08233     {COND_PUSH(1);}
08234     break;
08235 
08236   case 316:
08237 
08238 /* Line 1806 of yacc.c  */
08239 #line 2795 "parse.y"
08240     {COND_POP();}
08241     break;
08242 
08243   case 317:
08244 
08245 /* Line 1806 of yacc.c  */
08246 #line 2798 "parse.y"
08247     {
08248                     /*%%%*/
08249                         (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
08250                         fixpos((yyval.node), (yyvsp[(3) - (7)].node));
08251                     /*%
08252                         $$ = dispatch2(until, $3, $6);
08253                     %*/
08254                     }
08255     break;
08256 
08257   case 318:
08258 
08259 /* Line 1806 of yacc.c  */
08260 #line 2809 "parse.y"
08261     {
08262                     /*%%%*/
08263                         (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
08264                         fixpos((yyval.node), (yyvsp[(2) - (5)].node));
08265                     /*%
08266                         $$ = dispatch2(case, $2, $4);
08267                     %*/
08268                     }
08269     break;
08270 
08271   case 319:
08272 
08273 /* Line 1806 of yacc.c  */
08274 #line 2818 "parse.y"
08275     {
08276                     /*%%%*/
08277                         (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node));
08278                     /*%
08279                         $$ = dispatch2(case, Qnil, $3);
08280                     %*/
08281                     }
08282     break;
08283 
08284   case 320:
08285 
08286 /* Line 1806 of yacc.c  */
08287 #line 2826 "parse.y"
08288     {COND_PUSH(1);}
08289     break;
08290 
08291   case 321:
08292 
08293 /* Line 1806 of yacc.c  */
08294 #line 2828 "parse.y"
08295     {COND_POP();}
08296     break;
08297 
08298   case 322:
08299 
08300 /* Line 1806 of yacc.c  */
08301 #line 2831 "parse.y"
08302     {
08303                     /*%%%*/
08304                         /*
08305                          *  for a, b, c in e
08306                          *  #=>
08307                          *  e.each{|*x| a, b, c = x
08308                          *
08309                          *  for a in e
08310                          *  #=>
08311                          *  e.each{|x| a, = x}
08312                          */
08313                         ID id = internal_id();
08314                         ID *tbl = ALLOC_N(ID, 2);
08315                         NODE *m = NEW_ARGS_AUX(0, 0);
08316                         NODE *args, *scope;
08317 
08318                         if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) {
08319                             /* if args.length == 1 && args[0].kind_of?(Array)
08320                              *   args = args[0]
08321                              * end
08322                              */
08323                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
08324                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
08325                             m->nd_next = block_append(
08326                                 NEW_IF(
08327                                     NEW_NODE(NODE_AND,
08328                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
08329                                                       idEq, one),
08330                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
08331                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
08332                                              0),
08333                                     NEW_DASGN_CURR(id,
08334                                                    NEW_CALL(NEW_DVAR(id), idAREF, zero)),
08335                                     0),
08336                                 node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id)));
08337 
08338                             args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08339                         }
08340                         else {
08341                             if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN ||
08342                                 nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN ||
08343                                 nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) {
08344                                 (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id);
08345                                 m->nd_plen = 1;
08346                                 m->nd_next = (yyvsp[(2) - (9)].node);
08347                                 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
08348                             }
08349                             else {
08350                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id));
08351                                 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08352                             }
08353                         }
08354                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args);
08355                         tbl[0] = 1; tbl[1] = id;
08356                         (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope);
08357                         fixpos((yyval.node), (yyvsp[(2) - (9)].node));
08358                     /*%
08359                         $$ = dispatch3(for, $2, $5, $8);
08360                     %*/
08361                     }
08362     break;
08363 
08364   case 323:
08365 
08366 /* Line 1806 of yacc.c  */
08367 #line 2892 "parse.y"
08368     {
08369                         if (in_def || in_single)
08370                             yyerror("class definition in method body");
08371                         local_push(0);
08372                     /*%%%*/
08373                         (yyval.num) = ruby_sourceline;
08374                     /*%
08375                     %*/
08376                     }
08377     break;
08378 
08379   case 324:
08380 
08381 /* Line 1806 of yacc.c  */
08382 #line 2903 "parse.y"
08383     {
08384                     /*%%%*/
08385                         (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node));
08386                         nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
08387                     /*%
08388                         $$ = dispatch3(class, $2, $3, $5);
08389                     %*/
08390                         local_pop();
08391                     }
08392     break;
08393 
08394   case 325:
08395 
08396 /* Line 1806 of yacc.c  */
08397 #line 2913 "parse.y"
08398     {
08399                         (yyval.num) = in_def;
08400                         in_def = 0;
08401                     }
08402     break;
08403 
08404   case 326:
08405 
08406 /* Line 1806 of yacc.c  */
08407 #line 2918 "parse.y"
08408     {
08409                         (yyval.num) = in_single;
08410                         in_single = 0;
08411                         local_push(0);
08412                     }
08413     break;
08414 
08415   case 327:
08416 
08417 /* Line 1806 of yacc.c  */
08418 #line 2925 "parse.y"
08419     {
08420                     /*%%%*/
08421                         (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node));
08422                         fixpos((yyval.node), (yyvsp[(3) - (8)].node));
08423                     /*%
08424                         $$ = dispatch2(sclass, $3, $7);
08425                     %*/
08426                         local_pop();
08427                         in_def = (yyvsp[(4) - (8)].num);
08428                         in_single = (yyvsp[(6) - (8)].num);
08429                     }
08430     break;
08431 
08432   case 328:
08433 
08434 /* Line 1806 of yacc.c  */
08435 #line 2937 "parse.y"
08436     {
08437                         if (in_def || in_single)
08438                             yyerror("module definition in method body");
08439                         local_push(0);
08440                     /*%%%*/
08441                         (yyval.num) = ruby_sourceline;
08442                     /*%
08443                     %*/
08444                     }
08445     break;
08446 
08447   case 329:
08448 
08449 /* Line 1806 of yacc.c  */
08450 #line 2948 "parse.y"
08451     {
08452                     /*%%%*/
08453                         (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
08454                         nd_set_line((yyval.node), (yyvsp[(3) - (5)].num));
08455                     /*%
08456                         $$ = dispatch2(module, $2, $4);
08457                     %*/
08458                         local_pop();
08459                     }
08460     break;
08461 
08462   case 330:
08463 
08464 /* Line 1806 of yacc.c  */
08465 #line 2958 "parse.y"
08466     {
08467                         (yyval.id) = cur_mid;
08468                         cur_mid = (yyvsp[(2) - (2)].id);
08469                         in_def++;
08470                         local_push(0);
08471                     }
08472     break;
08473 
08474   case 331:
08475 
08476 /* Line 1806 of yacc.c  */
08477 #line 2967 "parse.y"
08478     {
08479                     /*%%%*/
08480                         NODE *body = remove_begin((yyvsp[(5) - (6)].node));
08481                         reduce_nodes(&body);
08482                         (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE);
08483                         nd_set_line((yyval.node), (yyvsp[(1) - (6)].num));
08484                     /*%
08485                         $$ = dispatch3(def, $2, $4, $5);
08486                     %*/
08487                         local_pop();
08488                         in_def--;
08489                         cur_mid = (yyvsp[(3) - (6)].id);
08490                     }
08491     break;
08492 
08493   case 332:
08494 
08495 /* Line 1806 of yacc.c  */
08496 #line 2980 "parse.y"
08497     {lex_state = EXPR_FNAME;}
08498     break;
08499 
08500   case 333:
08501 
08502 /* Line 1806 of yacc.c  */
08503 #line 2981 "parse.y"
08504     {
08505                         in_single++;
08506                         lex_state = EXPR_ENDFN; /* force for args */
08507                         local_push(0);
08508                     }
08509     break;
08510 
08511   case 334:
08512 
08513 /* Line 1806 of yacc.c  */
08514 #line 2989 "parse.y"
08515     {
08516                     /*%%%*/
08517                         NODE *body = remove_begin((yyvsp[(8) - (9)].node));
08518                         reduce_nodes(&body);
08519                         (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body);
08520                         nd_set_line((yyval.node), (yyvsp[(1) - (9)].num));
08521                     /*%
08522                         $$ = dispatch5(defs, $2, $3, $5, $7, $8);
08523                     %*/
08524                         local_pop();
08525                         in_single--;
08526                     }
08527     break;
08528 
08529   case 335:
08530 
08531 /* Line 1806 of yacc.c  */
08532 #line 3002 "parse.y"
08533     {
08534                     /*%%%*/
08535                         (yyval.node) = NEW_BREAK(0);
08536                     /*%
08537                         $$ = dispatch1(break, arg_new());
08538                     %*/
08539                     }
08540     break;
08541 
08542   case 336:
08543 
08544 /* Line 1806 of yacc.c  */
08545 #line 3010 "parse.y"
08546     {
08547                     /*%%%*/
08548                         (yyval.node) = NEW_NEXT(0);
08549                     /*%
08550                         $$ = dispatch1(next, arg_new());
08551                     %*/
08552                     }
08553     break;
08554 
08555   case 337:
08556 
08557 /* Line 1806 of yacc.c  */
08558 #line 3018 "parse.y"
08559     {
08560                     /*%%%*/
08561                         (yyval.node) = NEW_REDO();
08562                     /*%
08563                         $$ = dispatch0(redo);
08564                     %*/
08565                     }
08566     break;
08567 
08568   case 338:
08569 
08570 /* Line 1806 of yacc.c  */
08571 #line 3026 "parse.y"
08572     {
08573                     /*%%%*/
08574                         (yyval.node) = NEW_RETRY();
08575                     /*%
08576                         $$ = dispatch0(retry);
08577                     %*/
08578                     }
08579     break;
08580 
08581   case 339:
08582 
08583 /* Line 1806 of yacc.c  */
08584 #line 3036 "parse.y"
08585     {
08586                     /*%%%*/
08587                         value_expr((yyvsp[(1) - (1)].node));
08588                         (yyval.node) = (yyvsp[(1) - (1)].node);
08589                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
08590                     /*%
08591                         $$ = $1;
08592                     %*/
08593                     }
08594     break;
08595 
08596   case 340:
08597 
08598 /* Line 1806 of yacc.c  */
08599 #line 3048 "parse.y"
08600     {
08601                         token_info_push("begin");
08602                     }
08603     break;
08604 
08605   case 341:
08606 
08607 /* Line 1806 of yacc.c  */
08608 #line 3054 "parse.y"
08609     {
08610                         token_info_push("if");
08611                     }
08612     break;
08613 
08614   case 342:
08615 
08616 /* Line 1806 of yacc.c  */
08617 #line 3060 "parse.y"
08618     {
08619                         token_info_push("unless");
08620                     }
08621     break;
08622 
08623   case 343:
08624 
08625 /* Line 1806 of yacc.c  */
08626 #line 3066 "parse.y"
08627     {
08628                         token_info_push("while");
08629                     }
08630     break;
08631 
08632   case 344:
08633 
08634 /* Line 1806 of yacc.c  */
08635 #line 3072 "parse.y"
08636     {
08637                         token_info_push("until");
08638                     }
08639     break;
08640 
08641   case 345:
08642 
08643 /* Line 1806 of yacc.c  */
08644 #line 3078 "parse.y"
08645     {
08646                         token_info_push("case");
08647                     }
08648     break;
08649 
08650   case 346:
08651 
08652 /* Line 1806 of yacc.c  */
08653 #line 3084 "parse.y"
08654     {
08655                         token_info_push("for");
08656                     }
08657     break;
08658 
08659   case 347:
08660 
08661 /* Line 1806 of yacc.c  */
08662 #line 3090 "parse.y"
08663     {
08664                         token_info_push("class");
08665                     }
08666     break;
08667 
08668   case 348:
08669 
08670 /* Line 1806 of yacc.c  */
08671 #line 3096 "parse.y"
08672     {
08673                         token_info_push("module");
08674                     }
08675     break;
08676 
08677   case 349:
08678 
08679 /* Line 1806 of yacc.c  */
08680 #line 3102 "parse.y"
08681     {
08682                         token_info_push("def");
08683                     /*%%%*/
08684                         (yyval.num) = ruby_sourceline;
08685                     /*%
08686                     %*/
08687                     }
08688     break;
08689 
08690   case 350:
08691 
08692 /* Line 1806 of yacc.c  */
08693 #line 3112 "parse.y"
08694     {
08695                         token_info_pop("end");
08696                     }
08697     break;
08698 
08699   case 357:
08700 
08701 /* Line 1806 of yacc.c  */
08702 #line 3142 "parse.y"
08703     {
08704                     /*%%%*/
08705                         (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
08706                         fixpos((yyval.node), (yyvsp[(2) - (5)].node));
08707                     /*%
08708                         $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
08709                     %*/
08710                     }
08711     break;
08712 
08713   case 359:
08714 
08715 /* Line 1806 of yacc.c  */
08716 #line 3154 "parse.y"
08717     {
08718                     /*%%%*/
08719                         (yyval.node) = (yyvsp[(2) - (2)].node);
08720                     /*%
08721                         $$ = dispatch1(else, $2);
08722                     %*/
08723                     }
08724     break;
08725 
08726   case 362:
08727 
08728 /* Line 1806 of yacc.c  */
08729 #line 3168 "parse.y"
08730     {
08731                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
08732                     /*%%%*/
08733                     /*%
08734                         $$ = dispatch1(mlhs_paren, $$);
08735                     %*/
08736                     }
08737     break;
08738 
08739   case 363:
08740 
08741 /* Line 1806 of yacc.c  */
08742 #line 3176 "parse.y"
08743     {
08744                     /*%%%*/
08745                         (yyval.node) = (yyvsp[(2) - (3)].node);
08746                     /*%
08747                         $$ = dispatch1(mlhs_paren, $2);
08748                     %*/
08749                     }
08750     break;
08751 
08752   case 364:
08753 
08754 /* Line 1806 of yacc.c  */
08755 #line 3186 "parse.y"
08756     {
08757                     /*%%%*/
08758                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
08759                     /*%
08760                         $$ = mlhs_add(mlhs_new(), $1);
08761                     %*/
08762                     }
08763     break;
08764 
08765   case 365:
08766 
08767 /* Line 1806 of yacc.c  */
08768 #line 3194 "parse.y"
08769     {
08770                     /*%%%*/
08771                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
08772                     /*%
08773                         $$ = mlhs_add($1, $3);
08774                     %*/
08775                     }
08776     break;
08777 
08778   case 366:
08779 
08780 /* Line 1806 of yacc.c  */
08781 #line 3204 "parse.y"
08782     {
08783                     /*%%%*/
08784                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
08785                     /*%
08786                         $$ = $1;
08787                     %*/
08788                     }
08789     break;
08790 
08791   case 367:
08792 
08793 /* Line 1806 of yacc.c  */
08794 #line 3212 "parse.y"
08795     {
08796                         (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0);
08797                     /*%%%*/
08798                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node));
08799                     /*%
08800                         $$ = mlhs_add_star($1, $$);
08801                     %*/
08802                     }
08803     break;
08804 
08805   case 368:
08806 
08807 /* Line 1806 of yacc.c  */
08808 #line 3221 "parse.y"
08809     {
08810                         (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0);
08811                     /*%%%*/
08812                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node)));
08813                     /*%
08814                         $$ = mlhs_add_star($1, $$);
08815                     %*/
08816                     }
08817     break;
08818 
08819   case 369:
08820 
08821 /* Line 1806 of yacc.c  */
08822 #line 3230 "parse.y"
08823     {
08824                     /*%%%*/
08825                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1);
08826                     /*%
08827                         $$ = mlhs_add_star($1, Qnil);
08828                     %*/
08829                     }
08830     break;
08831 
08832   case 370:
08833 
08834 /* Line 1806 of yacc.c  */
08835 #line 3238 "parse.y"
08836     {
08837                     /*%%%*/
08838                         (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node)));
08839                     /*%
08840                         $$ = mlhs_add_star($1, $5);
08841                     %*/
08842                     }
08843     break;
08844 
08845   case 371:
08846 
08847 /* Line 1806 of yacc.c  */
08848 #line 3246 "parse.y"
08849     {
08850                         (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0);
08851                     /*%%%*/
08852                         (yyval.node) = NEW_MASGN(0, (yyval.node));
08853                     /*%
08854                         $$ = mlhs_add_star(mlhs_new(), $$);
08855                     %*/
08856                     }
08857     break;
08858 
08859   case 372:
08860 
08861 /* Line 1806 of yacc.c  */
08862 #line 3255 "parse.y"
08863     {
08864                         (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0);
08865                     /*%%%*/
08866                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node)));
08867                     /*%
08868                       #if 0
08869                       TODO: Check me
08870                       #endif
08871                         $$ = mlhs_add_star($$, $4);
08872                     %*/
08873                     }
08874     break;
08875 
08876   case 373:
08877 
08878 /* Line 1806 of yacc.c  */
08879 #line 3267 "parse.y"
08880     {
08881                     /*%%%*/
08882                         (yyval.node) = NEW_MASGN(0, -1);
08883                     /*%
08884                         $$ = mlhs_add_star(mlhs_new(), Qnil);
08885                     %*/
08886                     }
08887     break;
08888 
08889   case 374:
08890 
08891 /* Line 1806 of yacc.c  */
08892 #line 3275 "parse.y"
08893     {
08894                     /*%%%*/
08895                         (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
08896                     /*%
08897                         $$ = mlhs_add_star(mlhs_new(), Qnil);
08898                     %*/
08899                     }
08900     break;
08901 
08902   case 375:
08903 
08904 /* Line 1806 of yacc.c  */
08905 #line 3286 "parse.y"
08906     {
08907                         (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
08908                     }
08909     break;
08910 
08911   case 376:
08912 
08913 /* Line 1806 of yacc.c  */
08914 #line 3290 "parse.y"
08915     {
08916                         (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
08917                     }
08918     break;
08919 
08920   case 377:
08921 
08922 /* Line 1806 of yacc.c  */
08923 #line 3294 "parse.y"
08924     {
08925                         (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
08926                     }
08927     break;
08928 
08929   case 378:
08930 
08931 /* Line 1806 of yacc.c  */
08932 #line 3298 "parse.y"
08933     {
08934                         (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
08935                     }
08936     break;
08937 
08938   case 379:
08939 
08940 /* Line 1806 of yacc.c  */
08941 #line 3304 "parse.y"
08942     {
08943                         (yyval.node) = (yyvsp[(2) - (2)].node);
08944                     }
08945     break;
08946 
08947   case 380:
08948 
08949 /* Line 1806 of yacc.c  */
08950 #line 3308 "parse.y"
08951     {
08952                         (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
08953                     }
08954     break;
08955 
08956   case 381:
08957 
08958 /* Line 1806 of yacc.c  */
08959 #line 3314 "parse.y"
08960     {
08961                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
08962                     }
08963     break;
08964 
08965   case 382:
08966 
08967 /* Line 1806 of yacc.c  */
08968 #line 3318 "parse.y"
08969     {
08970                         (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
08971                     }
08972     break;
08973 
08974   case 383:
08975 
08976 /* Line 1806 of yacc.c  */
08977 #line 3322 "parse.y"
08978     {
08979                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
08980                     }
08981     break;
08982 
08983   case 384:
08984 
08985 /* Line 1806 of yacc.c  */
08986 #line 3326 "parse.y"
08987     {
08988                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
08989                     }
08990     break;
08991 
08992   case 385:
08993 
08994 /* Line 1806 of yacc.c  */
08995 #line 3330 "parse.y"
08996     {
08997                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
08998                     }
08999     break;
09000 
09001   case 386:
09002 
09003 /* Line 1806 of yacc.c  */
09004 #line 3334 "parse.y"
09005     {
09006                         (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
09007                     /*%%%*/
09008                     /*%
09009                         dispatch1(excessed_comma, $$);
09010                     %*/
09011                     }
09012     break;
09013 
09014   case 387:
09015 
09016 /* Line 1806 of yacc.c  */
09017 #line 3342 "parse.y"
09018     {
09019                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
09020                     }
09021     break;
09022 
09023   case 388:
09024 
09025 /* Line 1806 of yacc.c  */
09026 #line 3346 "parse.y"
09027     {
09028                         (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
09029                     }
09030     break;
09031 
09032   case 389:
09033 
09034 /* Line 1806 of yacc.c  */
09035 #line 3350 "parse.y"
09036     {
09037                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
09038                     }
09039     break;
09040 
09041   case 390:
09042 
09043 /* Line 1806 of yacc.c  */
09044 #line 3354 "parse.y"
09045     {
09046                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
09047                     }
09048     break;
09049 
09050   case 391:
09051 
09052 /* Line 1806 of yacc.c  */
09053 #line 3358 "parse.y"
09054     {
09055                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
09056                     }
09057     break;
09058 
09059   case 392:
09060 
09061 /* Line 1806 of yacc.c  */
09062 #line 3362 "parse.y"
09063     {
09064                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
09065                     }
09066     break;
09067 
09068   case 393:
09069 
09070 /* Line 1806 of yacc.c  */
09071 #line 3366 "parse.y"
09072     {
09073                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
09074                     }
09075     break;
09076 
09077   case 394:
09078 
09079 /* Line 1806 of yacc.c  */
09080 #line 3370 "parse.y"
09081     {
09082                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
09083                     }
09084     break;
09085 
09086   case 395:
09087 
09088 /* Line 1806 of yacc.c  */
09089 #line 3374 "parse.y"
09090     {
09091                         (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
09092                     }
09093     break;
09094 
09095   case 397:
09096 
09097 /* Line 1806 of yacc.c  */
09098 #line 3381 "parse.y"
09099     {
09100                         command_start = TRUE;
09101                     }
09102     break;
09103 
09104   case 398:
09105 
09106 /* Line 1806 of yacc.c  */
09107 #line 3387 "parse.y"
09108     {
09109                     /*%%%*/
09110                         (yyval.node) = 0;
09111                     /*%
09112                         $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09113                                           escape_Qundef($2));
09114                     %*/
09115                     }
09116     break;
09117 
09118   case 399:
09119 
09120 /* Line 1806 of yacc.c  */
09121 #line 3396 "parse.y"
09122     {
09123                     /*%%%*/
09124                         (yyval.node) = 0;
09125                     /*%
09126                         $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09127                                           Qnil);
09128                     %*/
09129                     }
09130     break;
09131 
09132   case 400:
09133 
09134 /* Line 1806 of yacc.c  */
09135 #line 3405 "parse.y"
09136     {
09137                     /*%%%*/
09138                         (yyval.node) = (yyvsp[(2) - (4)].node);
09139                     /*%
09140                         $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
09141                     %*/
09142                     }
09143     break;
09144 
09145   case 401:
09146 
09147 /* Line 1806 of yacc.c  */
09148 #line 3416 "parse.y"
09149     {
09150                       (yyval.node) = 0;
09151                     }
09152     break;
09153 
09154   case 402:
09155 
09156 /* Line 1806 of yacc.c  */
09157 #line 3420 "parse.y"
09158     {
09159                     /*%%%*/
09160                         (yyval.node) = 0;
09161                     /*%
09162                         $$ = $3;
09163                     %*/
09164                     }
09165     break;
09166 
09167   case 405:
09168 
09169 /* Line 1806 of yacc.c  */
09170 #line 3446 "parse.y"
09171     {
09172                         new_bv(get_id((yyvsp[(1) - (1)].id)));
09173                     /*%%%*/
09174                     /*%
09175                         $$ = get_value($1);
09176                     %*/
09177                     }
09178     break;
09179 
09180   case 406:
09181 
09182 /* Line 1806 of yacc.c  */
09183 #line 3454 "parse.y"
09184     {
09185                         (yyval.node) = 0;
09186                     }
09187     break;
09188 
09189   case 407:
09190 
09191 /* Line 1806 of yacc.c  */
09192 #line 3459 "parse.y"
09193     {
09194                         (yyval.vars) = dyna_push();
09195                     }
09196     break;
09197 
09198   case 408:
09199 
09200 /* Line 1806 of yacc.c  */
09201 #line 3462 "parse.y"
09202     {
09203                         (yyval.num) = lpar_beg;
09204                         lpar_beg = ++paren_nest;
09205                     }
09206     break;
09207 
09208   case 409:
09209 
09210 /* Line 1806 of yacc.c  */
09211 #line 3467 "parse.y"
09212     {
09213                         (yyval.num) = ruby_sourceline;
09214                     }
09215     break;
09216 
09217   case 410:
09218 
09219 /* Line 1806 of yacc.c  */
09220 #line 3470 "parse.y"
09221     {
09222                         (yyval.val) = cmdarg_stack;
09223                         cmdarg_stack = 0;
09224                     }
09225     break;
09226 
09227   case 411:
09228 
09229 /* Line 1806 of yacc.c  */
09230 #line 3475 "parse.y"
09231     {
09232                         lpar_beg = (yyvsp[(2) - (6)].num);
09233                         cmdarg_stack = (yyvsp[(5) - (6)].val);
09234                         CMDARG_LEXPOP();
09235                     /*%%%*/
09236                         (yyval.node) = NEW_LAMBDA((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
09237                         nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
09238                     /*%
09239                         $$ = dispatch2(lambda, $3, $6);
09240                     %*/
09241                         dyna_pop((yyvsp[(1) - (6)].vars));
09242                     }
09243     break;
09244 
09245   case 412:
09246 
09247 /* Line 1806 of yacc.c  */
09248 #line 3490 "parse.y"
09249     {
09250                     /*%%%*/
09251                         (yyval.node) = (yyvsp[(2) - (4)].node);
09252                     /*%
09253                         $$ = dispatch1(paren, $2);
09254                     %*/
09255                     }
09256     break;
09257 
09258   case 413:
09259 
09260 /* Line 1806 of yacc.c  */
09261 #line 3498 "parse.y"
09262     {
09263                         (yyval.node) = (yyvsp[(1) - (1)].node);
09264                     }
09265     break;
09266 
09267   case 414:
09268 
09269 /* Line 1806 of yacc.c  */
09270 #line 3504 "parse.y"
09271     {
09272                         (yyval.node) = (yyvsp[(2) - (3)].node);
09273                     }
09274     break;
09275 
09276   case 415:
09277 
09278 /* Line 1806 of yacc.c  */
09279 #line 3508 "parse.y"
09280     {
09281                         (yyval.node) = (yyvsp[(2) - (3)].node);
09282                     }
09283     break;
09284 
09285   case 416:
09286 
09287 /* Line 1806 of yacc.c  */
09288 #line 3514 "parse.y"
09289     {
09290                         (yyvsp[(1) - (1)].vars) = dyna_push();
09291                     /*%%%*/
09292                         (yyval.num) = ruby_sourceline;
09293                     /*% %*/
09294                     }
09295     break;
09296 
09297   case 417:
09298 
09299 /* Line 1806 of yacc.c  */
09300 #line 3523 "parse.y"
09301     {
09302                     /*%%%*/
09303                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
09304                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
09305                     /*%
09306                         $$ = dispatch2(do_block, escape_Qundef($3), $4);
09307                     %*/
09308                         dyna_pop((yyvsp[(1) - (5)].vars));
09309                     }
09310     break;
09311 
09312   case 418:
09313 
09314 /* Line 1806 of yacc.c  */
09315 #line 3535 "parse.y"
09316     {
09317                     /*%%%*/
09318                         if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) {
09319                             compile_error(PARSER_ARG "block given to yield");
09320                         }
09321                         else {
09322                             block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
09323                         }
09324                         (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
09325                         (yyval.node) = (yyvsp[(2) - (2)].node);
09326                         fixpos((yyval.node), (yyvsp[(1) - (2)].node));
09327                     /*%
09328                         $$ = method_add_block($1, $2);
09329                     %*/
09330                     }
09331     break;
09332 
09333   case 419:
09334 
09335 /* Line 1806 of yacc.c  */
09336 #line 3551 "parse.y"
09337     {
09338                     /*%%%*/
09339                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
09340                     /*%
09341                         $$ = dispatch3(call, $1, $2, $3);
09342                         $$ = method_optarg($$, $4);
09343                     %*/
09344                     }
09345     break;
09346 
09347   case 420:
09348 
09349 /* Line 1806 of yacc.c  */
09350 #line 3560 "parse.y"
09351     {
09352                     /*%%%*/
09353                         block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
09354                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
09355                         (yyval.node) = (yyvsp[(5) - (5)].node);
09356                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
09357                     /*%
09358                         $$ = dispatch4(command_call, $1, $2, $3, $4);
09359                         $$ = method_add_block($$, $5);
09360                     %*/
09361                     }
09362     break;
09363 
09364   case 421:
09365 
09366 /* Line 1806 of yacc.c  */
09367 #line 3572 "parse.y"
09368     {
09369                     /*%%%*/
09370                         block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
09371                         (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
09372                         (yyval.node) = (yyvsp[(5) - (5)].node);
09373                         fixpos((yyval.node), (yyvsp[(1) - (5)].node));
09374                     /*%
09375                         $$ = dispatch4(command_call, $1, $2, $3, $4);
09376                         $$ = method_add_block($$, $5);
09377                     %*/
09378                     }
09379     break;
09380 
09381   case 422:
09382 
09383 /* Line 1806 of yacc.c  */
09384 #line 3586 "parse.y"
09385     {
09386                     /*%%%*/
09387                         (yyval.node) = (yyvsp[(1) - (2)].node);
09388                         (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
09389                     /*%
09390                         $$ = method_arg(dispatch1(fcall, $1), $2);
09391                     %*/
09392                     }
09393     break;
09394 
09395   case 423:
09396 
09397 /* Line 1806 of yacc.c  */
09398 #line 3595 "parse.y"
09399     {
09400                     /*%%%*/
09401                         (yyval.num) = ruby_sourceline;
09402                     /*% %*/
09403                     }
09404     break;
09405 
09406   case 424:
09407 
09408 /* Line 1806 of yacc.c  */
09409 #line 3601 "parse.y"
09410     {
09411                     /*%%%*/
09412                         (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
09413                         nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
09414                     /*%
09415                         $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
09416                         $$ = method_optarg($$, $5);
09417                     %*/
09418                     }
09419     break;
09420 
09421   case 425:
09422 
09423 /* Line 1806 of yacc.c  */
09424 #line 3611 "parse.y"
09425     {
09426                     /*%%%*/
09427                         (yyval.num) = ruby_sourceline;
09428                     /*% %*/
09429                     }
09430     break;
09431 
09432   case 426:
09433 
09434 /* Line 1806 of yacc.c  */
09435 #line 3617 "parse.y"
09436     {
09437                     /*%%%*/
09438                         (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
09439                         nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
09440                     /*%
09441                         $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
09442                         $$ = method_optarg($$, $5);
09443                     %*/
09444                     }
09445     break;
09446 
09447   case 427:
09448 
09449 /* Line 1806 of yacc.c  */
09450 #line 3627 "parse.y"
09451     {
09452                     /*%%%*/
09453                         (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0);
09454                     /*%
09455                         $$ = dispatch3(call, $1, ripper_intern("::"), $3);
09456                     %*/
09457                     }
09458     break;
09459 
09460   case 428:
09461 
09462 /* Line 1806 of yacc.c  */
09463 #line 3635 "parse.y"
09464     {
09465                     /*%%%*/
09466                         (yyval.num) = ruby_sourceline;
09467                     /*% %*/
09468                     }
09469     break;
09470 
09471   case 429:
09472 
09473 /* Line 1806 of yacc.c  */
09474 #line 3641 "parse.y"
09475     {
09476                     /*%%%*/
09477                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
09478                         nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
09479                     /*%
09480                         $$ = dispatch3(call, $1, ripper_id2sym('.'),
09481                                        ripper_intern("call"));
09482                         $$ = method_optarg($$, $4);
09483                     %*/
09484                     }
09485     break;
09486 
09487   case 430:
09488 
09489 /* Line 1806 of yacc.c  */
09490 #line 3652 "parse.y"
09491     {
09492                     /*%%%*/
09493                         (yyval.num) = ruby_sourceline;
09494                     /*% %*/
09495                     }
09496     break;
09497 
09498   case 431:
09499 
09500 /* Line 1806 of yacc.c  */
09501 #line 3658 "parse.y"
09502     {
09503                     /*%%%*/
09504                         (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
09505                         nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
09506                     /*%
09507                         $$ = dispatch3(call, $1, ripper_intern("::"),
09508                                        ripper_intern("call"));
09509                         $$ = method_optarg($$, $4);
09510                     %*/
09511                     }
09512     break;
09513 
09514   case 432:
09515 
09516 /* Line 1806 of yacc.c  */
09517 #line 3669 "parse.y"
09518     {
09519                     /*%%%*/
09520                         (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
09521                     /*%
09522                         $$ = dispatch1(super, $2);
09523                     %*/
09524                     }
09525     break;
09526 
09527   case 433:
09528 
09529 /* Line 1806 of yacc.c  */
09530 #line 3677 "parse.y"
09531     {
09532                     /*%%%*/
09533                         (yyval.node) = NEW_ZSUPER();
09534                     /*%
09535                         $$ = dispatch0(zsuper);
09536                     %*/
09537                     }
09538     break;
09539 
09540   case 434:
09541 
09542 /* Line 1806 of yacc.c  */
09543 #line 3685 "parse.y"
09544     {
09545                     /*%%%*/
09546                         if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF)
09547                             (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node));
09548                         else
09549                             (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node));
09550                         fixpos((yyval.node), (yyvsp[(1) - (4)].node));
09551                     /*%
09552                         $$ = dispatch2(aref, $1, escape_Qundef($3));
09553                     %*/
09554                     }
09555     break;
09556 
09557   case 435:
09558 
09559 /* Line 1806 of yacc.c  */
09560 #line 3699 "parse.y"
09561     {
09562                         (yyvsp[(1) - (1)].vars) = dyna_push();
09563                     /*%%%*/
09564                         (yyval.num) = ruby_sourceline;
09565                     /*%
09566                     %*/
09567                     }
09568     break;
09569 
09570   case 436:
09571 
09572 /* Line 1806 of yacc.c  */
09573 #line 3708 "parse.y"
09574     {
09575                     /*%%%*/
09576                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
09577                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
09578                     /*%
09579                         $$ = dispatch2(brace_block, escape_Qundef($3), $4);
09580                     %*/
09581                         dyna_pop((yyvsp[(1) - (5)].vars));
09582                     }
09583     break;
09584 
09585   case 437:
09586 
09587 /* Line 1806 of yacc.c  */
09588 #line 3718 "parse.y"
09589     {
09590                         (yyvsp[(1) - (1)].vars) = dyna_push();
09591                     /*%%%*/
09592                         (yyval.num) = ruby_sourceline;
09593                     /*%
09594                     %*/
09595                     }
09596     break;
09597 
09598   case 438:
09599 
09600 /* Line 1806 of yacc.c  */
09601 #line 3727 "parse.y"
09602     {
09603                     /*%%%*/
09604                         (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
09605                         nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
09606                     /*%
09607                         $$ = dispatch2(do_block, escape_Qundef($3), $4);
09608                     %*/
09609                         dyna_pop((yyvsp[(1) - (5)].vars));
09610                     }
09611     break;
09612 
09613   case 439:
09614 
09615 /* Line 1806 of yacc.c  */
09616 #line 3741 "parse.y"
09617     {
09618                     /*%%%*/
09619                         (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
09620                     /*%
09621                         $$ = dispatch3(when, $2, $4, escape_Qundef($5));
09622                     %*/
09623                     }
09624     break;
09625 
09626   case 442:
09627 
09628 /* Line 1806 of yacc.c  */
09629 #line 3757 "parse.y"
09630     {
09631                     /*%%%*/
09632                         if ((yyvsp[(3) - (6)].node)) {
09633                             (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO());
09634                             (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node));
09635                         }
09636                         (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
09637                         fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node));
09638                     /*%
09639                         $$ = dispatch4(rescue,
09640                                        escape_Qundef($2),
09641                                        escape_Qundef($3),
09642                                        escape_Qundef($5),
09643                                        escape_Qundef($6));
09644                     %*/
09645                     }
09646     break;
09647 
09648   case 444:
09649 
09650 /* Line 1806 of yacc.c  */
09651 #line 3777 "parse.y"
09652     {
09653                     /*%%%*/
09654                         (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
09655                     /*%
09656                         $$ = rb_ary_new3(1, $1);
09657                     %*/
09658                     }
09659     break;
09660 
09661   case 445:
09662 
09663 /* Line 1806 of yacc.c  */
09664 #line 3785 "parse.y"
09665     {
09666                     /*%%%*/
09667                         if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node);
09668                     /*%
09669                         $$ = $1;
09670                     %*/
09671                     }
09672     break;
09673 
09674   case 447:
09675 
09676 /* Line 1806 of yacc.c  */
09677 #line 3796 "parse.y"
09678     {
09679                         (yyval.node) = (yyvsp[(2) - (2)].node);
09680                     }
09681     break;
09682 
09683   case 449:
09684 
09685 /* Line 1806 of yacc.c  */
09686 #line 3803 "parse.y"
09687     {
09688                     /*%%%*/
09689                         (yyval.node) = (yyvsp[(2) - (2)].node);
09690                     /*%
09691                         $$ = dispatch1(ensure, $2);
09692                     %*/
09693                     }
09694     break;
09695 
09696   case 452:
09697 
09698 /* Line 1806 of yacc.c  */
09699 #line 3815 "parse.y"
09700     {
09701                     /*%%%*/
09702                         (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
09703                     /*%
09704                         $$ = dispatch1(symbol_literal, $1);
09705                     %*/
09706                     }
09707     break;
09708 
09709   case 454:
09710 
09711 /* Line 1806 of yacc.c  */
09712 #line 3826 "parse.y"
09713     {
09714                     /*%%%*/
09715                         NODE *node = (yyvsp[(1) - (1)].node);
09716                         if (!node) {
09717                             node = NEW_STR(STR_NEW0());
09718                         }
09719                         else {
09720                             node = evstr2dstr(node);
09721                         }
09722                         (yyval.node) = node;
09723                     /*%
09724                         $$ = $1;
09725                     %*/
09726                     }
09727     break;
09728 
09729   case 457:
09730 
09731 /* Line 1806 of yacc.c  */
09732 #line 3845 "parse.y"
09733     {
09734                     /*%%%*/
09735                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
09736                     /*%
09737                         $$ = dispatch2(string_concat, $1, $2);
09738                     %*/
09739                     }
09740     break;
09741 
09742   case 458:
09743 
09744 /* Line 1806 of yacc.c  */
09745 #line 3855 "parse.y"
09746     {
09747                     /*%%%*/
09748                         (yyval.node) = (yyvsp[(2) - (3)].node);
09749                     /*%
09750                         $$ = dispatch1(string_literal, $2);
09751                     %*/
09752                     }
09753     break;
09754 
09755   case 459:
09756 
09757 /* Line 1806 of yacc.c  */
09758 #line 3865 "parse.y"
09759     {
09760                     /*%%%*/
09761                         NODE *node = (yyvsp[(2) - (3)].node);
09762                         if (!node) {
09763                             node = NEW_XSTR(STR_NEW0());
09764                         }
09765                         else {
09766                             switch (nd_type(node)) {
09767                               case NODE_STR:
09768                                 nd_set_type(node, NODE_XSTR);
09769                                 break;
09770                               case NODE_DSTR:
09771                                 nd_set_type(node, NODE_DXSTR);
09772                                 break;
09773                               default:
09774                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09775                                 break;
09776                             }
09777                         }
09778                         (yyval.node) = node;
09779                     /*%
09780                         $$ = dispatch1(xstring_literal, $2);
09781                     %*/
09782                     }
09783     break;
09784 
09785   case 460:
09786 
09787 /* Line 1806 of yacc.c  */
09788 #line 3892 "parse.y"
09789     {
09790                     /*%%%*/
09791                         int options = (yyvsp[(3) - (3)].num);
09792                         NODE *node = (yyvsp[(2) - (3)].node);
09793                         NODE *list, *prev;
09794                         if (!node) {
09795                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09796                         }
09797                         else switch (nd_type(node)) {
09798                           case NODE_STR:
09799                             {
09800                                 VALUE src = node->nd_lit;
09801                                 nd_set_type(node, NODE_LIT);
09802                                 node->nd_lit = reg_compile(src, options);
09803                             }
09804                             break;
09805                           default:
09806                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09807                           case NODE_DSTR:
09808                             if (options & RE_OPTION_ONCE) {
09809                                 nd_set_type(node, NODE_DREGX_ONCE);
09810                             }
09811                             else {
09812                                 nd_set_type(node, NODE_DREGX);
09813                             }
09814                             node->nd_cflag = options & RE_OPTION_MASK;
09815                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09816                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09817                                 if (nd_type(list->nd_head) == NODE_STR) {
09818                                     VALUE tail = list->nd_head->nd_lit;
09819                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09820                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09821                                         if (!literal_concat0(parser, lit, tail)) {
09822                                             node = 0;
09823                                             break;
09824                                         }
09825                                         rb_str_resize(tail, 0);
09826                                         prev->nd_next = list->nd_next;
09827                                         rb_gc_force_recycle((VALUE)list->nd_head);
09828                                         rb_gc_force_recycle((VALUE)list);
09829                                         list = prev;
09830                                     }
09831                                     else {
09832                                         prev = list;
09833                                     }
09834                                 }
09835                                 else {
09836                                     prev = 0;
09837                                 }
09838                             }
09839                             if (!node->nd_next) {
09840                                 VALUE src = node->nd_lit;
09841                                 nd_set_type(node, NODE_LIT);
09842                                 node->nd_lit = reg_compile(src, options);
09843                             }
09844                             break;
09845                         }
09846                         (yyval.node) = node;
09847                     /*%
09848                         $$ = dispatch2(regexp_literal, $2, $3);
09849                     %*/
09850                     }
09851     break;
09852 
09853   case 461:
09854 
09855 /* Line 1806 of yacc.c  */
09856 #line 3957 "parse.y"
09857     {
09858                     /*%%%*/
09859                         (yyval.node) = NEW_ZARRAY();
09860                     /*%
09861                         $$ = dispatch0(words_new);
09862                         $$ = dispatch1(array, $$);
09863                     %*/
09864                     }
09865     break;
09866 
09867   case 462:
09868 
09869 /* Line 1806 of yacc.c  */
09870 #line 3966 "parse.y"
09871     {
09872                     /*%%%*/
09873                         (yyval.node) = (yyvsp[(2) - (3)].node);
09874                     /*%
09875                         $$ = dispatch1(array, $2);
09876                     %*/
09877                     }
09878     break;
09879 
09880   case 463:
09881 
09882 /* Line 1806 of yacc.c  */
09883 #line 3976 "parse.y"
09884     {
09885                     /*%%%*/
09886                         (yyval.node) = 0;
09887                     /*%
09888                         $$ = dispatch0(words_new);
09889                     %*/
09890                     }
09891     break;
09892 
09893   case 464:
09894 
09895 /* Line 1806 of yacc.c  */
09896 #line 3984 "parse.y"
09897     {
09898                     /*%%%*/
09899                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node)));
09900                     /*%
09901                         $$ = dispatch2(words_add, $1, $2);
09902                     %*/
09903                     }
09904     break;
09905 
09906   case 466:
09907 
09908 /* Line 1806 of yacc.c  */
09909 #line 4002 "parse.y"
09910     {
09911                     /*%%%*/
09912                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
09913                     /*%
09914                         $$ = dispatch2(word_add, $1, $2);
09915                     %*/
09916                     }
09917     break;
09918 
09919   case 467:
09920 
09921 /* Line 1806 of yacc.c  */
09922 #line 4012 "parse.y"
09923     {
09924                     /*%%%*/
09925                         (yyval.node) = NEW_ZARRAY();
09926                     /*%
09927                         $$ = dispatch0(symbols_new);
09928                         $$ = dispatch1(array, $$);
09929                     %*/
09930                     }
09931     break;
09932 
09933   case 468:
09934 
09935 /* Line 1806 of yacc.c  */
09936 #line 4021 "parse.y"
09937     {
09938                     /*%%%*/
09939                         (yyval.node) = (yyvsp[(2) - (3)].node);
09940                     /*%
09941                         $$ = dispatch1(array, $2);
09942                     %*/
09943                     }
09944     break;
09945 
09946   case 469:
09947 
09948 /* Line 1806 of yacc.c  */
09949 #line 4031 "parse.y"
09950     {
09951                     /*%%%*/
09952                         (yyval.node) = 0;
09953                     /*%
09954                         $$ = dispatch0(symbols_new);
09955                     %*/
09956                     }
09957     break;
09958 
09959   case 470:
09960 
09961 /* Line 1806 of yacc.c  */
09962 #line 4039 "parse.y"
09963     {
09964                     /*%%%*/
09965                         (yyvsp[(2) - (3)].node) = evstr2dstr((yyvsp[(2) - (3)].node));
09966                         if (nd_type((yyvsp[(2) - (3)].node)) == NODE_DSTR) {
09967                             nd_set_type((yyvsp[(2) - (3)].node), NODE_DSYM);
09968                         }
09969                         else {
09970                             nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
09971                             (yyvsp[(2) - (3)].node)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].node)->nd_lit);
09972                         }
09973                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
09974                     /*%
09975                         $$ = dispatch2(symbols_add, $1, $2);
09976                     %*/
09977                     }
09978     break;
09979 
09980   case 471:
09981 
09982 /* Line 1806 of yacc.c  */
09983 #line 4057 "parse.y"
09984     {
09985                     /*%%%*/
09986                         (yyval.node) = NEW_ZARRAY();
09987                     /*%
09988                         $$ = dispatch0(qwords_new);
09989                         $$ = dispatch1(array, $$);
09990                     %*/
09991                     }
09992     break;
09993 
09994   case 472:
09995 
09996 /* Line 1806 of yacc.c  */
09997 #line 4066 "parse.y"
09998     {
09999                     /*%%%*/
10000                         (yyval.node) = (yyvsp[(2) - (3)].node);
10001                     /*%
10002                         $$ = dispatch1(array, $2);
10003                     %*/
10004                     }
10005     break;
10006 
10007   case 473:
10008 
10009 /* Line 1806 of yacc.c  */
10010 #line 4076 "parse.y"
10011     {
10012                     /*%%%*/
10013                         (yyval.node) = NEW_ZARRAY();
10014                     /*%
10015                         $$ = dispatch0(qsymbols_new);
10016                         $$ = dispatch1(array, $$);
10017                     %*/
10018                     }
10019     break;
10020 
10021   case 474:
10022 
10023 /* Line 1806 of yacc.c  */
10024 #line 4085 "parse.y"
10025     {
10026                     /*%%%*/
10027                         (yyval.node) = (yyvsp[(2) - (3)].node);
10028                     /*%
10029                         $$ = dispatch1(array, $2);
10030                     %*/
10031                     }
10032     break;
10033 
10034   case 475:
10035 
10036 /* Line 1806 of yacc.c  */
10037 #line 4095 "parse.y"
10038     {
10039                     /*%%%*/
10040                         (yyval.node) = 0;
10041                     /*%
10042                         $$ = dispatch0(qwords_new);
10043                     %*/
10044                     }
10045     break;
10046 
10047   case 476:
10048 
10049 /* Line 1806 of yacc.c  */
10050 #line 4103 "parse.y"
10051     {
10052                     /*%%%*/
10053                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10054                     /*%
10055                         $$ = dispatch2(qwords_add, $1, $2);
10056                     %*/
10057                     }
10058     break;
10059 
10060   case 477:
10061 
10062 /* Line 1806 of yacc.c  */
10063 #line 4113 "parse.y"
10064     {
10065                     /*%%%*/
10066                         (yyval.node) = 0;
10067                     /*%
10068                         $$ = dispatch0(qsymbols_new);
10069                     %*/
10070                     }
10071     break;
10072 
10073   case 478:
10074 
10075 /* Line 1806 of yacc.c  */
10076 #line 4121 "parse.y"
10077     {
10078                     /*%%%*/
10079                         VALUE lit;
10080                         lit = (yyvsp[(2) - (3)].node)->nd_lit;
10081                         (yyvsp[(2) - (3)].node)->nd_lit = ID2SYM(rb_intern_str(lit));
10082                         nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
10083                         (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10084                     /*%
10085                         $$ = dispatch2(qsymbols_add, $1, $2);
10086                     %*/
10087                     }
10088     break;
10089 
10090   case 479:
10091 
10092 /* Line 1806 of yacc.c  */
10093 #line 4135 "parse.y"
10094     {
10095                     /*%%%*/
10096                         (yyval.node) = 0;
10097                     /*%
10098                         $$ = dispatch0(string_content);
10099                     %*/
10100                     }
10101     break;
10102 
10103   case 480:
10104 
10105 /* Line 1806 of yacc.c  */
10106 #line 4143 "parse.y"
10107     {
10108                     /*%%%*/
10109                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10110                     /*%
10111                         $$ = dispatch2(string_add, $1, $2);
10112                     %*/
10113                     }
10114     break;
10115 
10116   case 481:
10117 
10118 /* Line 1806 of yacc.c  */
10119 #line 4153 "parse.y"
10120     {
10121                     /*%%%*/
10122                         (yyval.node) = 0;
10123                     /*%
10124                         $$ = dispatch0(xstring_new);
10125                     %*/
10126                     }
10127     break;
10128 
10129   case 482:
10130 
10131 /* Line 1806 of yacc.c  */
10132 #line 4161 "parse.y"
10133     {
10134                     /*%%%*/
10135                         (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10136                     /*%
10137                         $$ = dispatch2(xstring_add, $1, $2);
10138                     %*/
10139                     }
10140     break;
10141 
10142   case 483:
10143 
10144 /* Line 1806 of yacc.c  */
10145 #line 4171 "parse.y"
10146     {
10147                     /*%%%*/
10148                         (yyval.node) = 0;
10149                     /*%
10150                         $$ = dispatch0(regexp_new);
10151                     %*/
10152                     }
10153     break;
10154 
10155   case 484:
10156 
10157 /* Line 1806 of yacc.c  */
10158 #line 4179 "parse.y"
10159     {
10160                     /*%%%*/
10161                         NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node);
10162                         if (!head) {
10163                             (yyval.node) = tail;
10164                         }
10165                         else if (!tail) {
10166                             (yyval.node) = head;
10167                         }
10168                         else {
10169                             switch (nd_type(head)) {
10170                               case NODE_STR:
10171                                 nd_set_type(head, NODE_DSTR);
10172                                 break;
10173                               case NODE_DSTR:
10174                                 break;
10175                               default:
10176                                 head = list_append(NEW_DSTR(Qnil), head);
10177                                 break;
10178                             }
10179                             (yyval.node) = list_append(head, tail);
10180                         }
10181                     /*%
10182                         $$ = dispatch2(regexp_add, $1, $2);
10183                     %*/
10184                     }
10185     break;
10186 
10187   case 486:
10188 
10189 /* Line 1806 of yacc.c  */
10190 #line 4209 "parse.y"
10191     {
10192                         (yyval.node) = lex_strterm;
10193                         lex_strterm = 0;
10194                         lex_state = EXPR_BEG;
10195                     }
10196     break;
10197 
10198   case 487:
10199 
10200 /* Line 1806 of yacc.c  */
10201 #line 4215 "parse.y"
10202     {
10203                     /*%%%*/
10204                         lex_strterm = (yyvsp[(2) - (3)].node);
10205                         (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node));
10206                     /*%
10207                         lex_strterm = $<node>2;
10208                         $$ = dispatch1(string_dvar, $3);
10209                     %*/
10210                     }
10211     break;
10212 
10213   case 488:
10214 
10215 /* Line 1806 of yacc.c  */
10216 #line 4225 "parse.y"
10217     {
10218                         (yyvsp[(1) - (1)].val) = cond_stack;
10219                         (yyval.val) = cmdarg_stack;
10220                         cond_stack = 0;
10221                         cmdarg_stack = 0;
10222                     }
10223     break;
10224 
10225   case 489:
10226 
10227 /* Line 1806 of yacc.c  */
10228 #line 4231 "parse.y"
10229     {
10230                         (yyval.node) = lex_strterm;
10231                         lex_strterm = 0;
10232                         lex_state = EXPR_BEG;
10233                     }
10234     break;
10235 
10236   case 490:
10237 
10238 /* Line 1806 of yacc.c  */
10239 #line 4236 "parse.y"
10240     {
10241                         (yyval.num) = brace_nest;
10242                         brace_nest = 0;
10243                     }
10244     break;
10245 
10246   case 491:
10247 
10248 /* Line 1806 of yacc.c  */
10249 #line 4241 "parse.y"
10250     {
10251                         cond_stack = (yyvsp[(1) - (6)].val);
10252                         cmdarg_stack = (yyvsp[(2) - (6)].val);
10253                         lex_strterm = (yyvsp[(3) - (6)].node);
10254                         brace_nest = (yyvsp[(4) - (6)].num);
10255                     /*%%%*/
10256                         if ((yyvsp[(5) - (6)].node)) (yyvsp[(5) - (6)].node)->flags &= ~NODE_FL_NEWLINE;
10257                         (yyval.node) = new_evstr((yyvsp[(5) - (6)].node));
10258                     /*%
10259                         $$ = dispatch1(string_embexpr, $5);
10260                     %*/
10261                     }
10262     break;
10263 
10264   case 492:
10265 
10266 /* Line 1806 of yacc.c  */
10267 #line 4256 "parse.y"
10268     {
10269                     /*%%%*/
10270                         (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id));
10271                     /*%
10272                         $$ = dispatch1(var_ref, $1);
10273                     %*/
10274                     }
10275     break;
10276 
10277   case 493:
10278 
10279 /* Line 1806 of yacc.c  */
10280 #line 4264 "parse.y"
10281     {
10282                     /*%%%*/
10283                         (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id));
10284                     /*%
10285                         $$ = dispatch1(var_ref, $1);
10286                     %*/
10287                     }
10288     break;
10289 
10290   case 494:
10291 
10292 /* Line 1806 of yacc.c  */
10293 #line 4272 "parse.y"
10294     {
10295                     /*%%%*/
10296                         (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id));
10297                     /*%
10298                         $$ = dispatch1(var_ref, $1);
10299                     %*/
10300                     }
10301     break;
10302 
10303   case 496:
10304 
10305 /* Line 1806 of yacc.c  */
10306 #line 4283 "parse.y"
10307     {
10308                         lex_state = EXPR_END;
10309                     /*%%%*/
10310                         (yyval.id) = (yyvsp[(2) - (2)].id);
10311                     /*%
10312                         $$ = dispatch1(symbol, $2);
10313                     %*/
10314                     }
10315     break;
10316 
10317   case 501:
10318 
10319 /* Line 1806 of yacc.c  */
10320 #line 4300 "parse.y"
10321     {
10322                         lex_state = EXPR_END;
10323                     /*%%%*/
10324                         (yyval.node) = dsym_node((yyvsp[(2) - (3)].node));
10325                     /*%
10326                         $$ = dispatch1(dyna_symbol, $2);
10327                     %*/
10328                     }
10329     break;
10330 
10331   case 503:
10332 
10333 /* Line 1806 of yacc.c  */
10334 #line 4312 "parse.y"
10335     {
10336                     /*%%%*/
10337                         (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10338                     /*%
10339                         $$ = dispatch2(unary, ripper_intern("-@"), $2);
10340                     %*/
10341                     }
10342     break;
10343 
10344   case 513:
10345 
10346 /* Line 1806 of yacc.c  */
10347 #line 4334 "parse.y"
10348     {ifndef_ripper((yyval.id) = keyword_nil);}
10349     break;
10350 
10351   case 514:
10352 
10353 /* Line 1806 of yacc.c  */
10354 #line 4335 "parse.y"
10355     {ifndef_ripper((yyval.id) = keyword_self);}
10356     break;
10357 
10358   case 515:
10359 
10360 /* Line 1806 of yacc.c  */
10361 #line 4336 "parse.y"
10362     {ifndef_ripper((yyval.id) = keyword_true);}
10363     break;
10364 
10365   case 516:
10366 
10367 /* Line 1806 of yacc.c  */
10368 #line 4337 "parse.y"
10369     {ifndef_ripper((yyval.id) = keyword_false);}
10370     break;
10371 
10372   case 517:
10373 
10374 /* Line 1806 of yacc.c  */
10375 #line 4338 "parse.y"
10376     {ifndef_ripper((yyval.id) = keyword__FILE__);}
10377     break;
10378 
10379   case 518:
10380 
10381 /* Line 1806 of yacc.c  */
10382 #line 4339 "parse.y"
10383     {ifndef_ripper((yyval.id) = keyword__LINE__);}
10384     break;
10385 
10386   case 519:
10387 
10388 /* Line 1806 of yacc.c  */
10389 #line 4340 "parse.y"
10390     {ifndef_ripper((yyval.id) = keyword__ENCODING__);}
10391     break;
10392 
10393   case 520:
10394 
10395 /* Line 1806 of yacc.c  */
10396 #line 4344 "parse.y"
10397     {
10398                     /*%%%*/
10399                         if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10400                     /*%
10401                         if (id_is_var(get_id($1))) {
10402                             $$ = dispatch1(var_ref, $1);
10403                         }
10404                         else {
10405                             $$ = dispatch1(vcall, $1);
10406                         }
10407                     %*/
10408                     }
10409     break;
10410 
10411   case 521:
10412 
10413 /* Line 1806 of yacc.c  */
10414 #line 4357 "parse.y"
10415     {
10416                     /*%%%*/
10417                         if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10418                     /*%
10419                         $$ = dispatch1(var_ref, $1);
10420                     %*/
10421                     }
10422     break;
10423 
10424   case 522:
10425 
10426 /* Line 1806 of yacc.c  */
10427 #line 4367 "parse.y"
10428     {
10429                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10430                     /*%%%*/
10431                     /*%
10432                         $$ = dispatch1(var_field, $$);
10433                     %*/
10434                     }
10435     break;
10436 
10437   case 523:
10438 
10439 /* Line 1806 of yacc.c  */
10440 #line 4375 "parse.y"
10441     {
10442                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10443                     /*%%%*/
10444                     /*%
10445                         $$ = dispatch1(var_field, $$);
10446                     %*/
10447                     }
10448     break;
10449 
10450   case 526:
10451 
10452 /* Line 1806 of yacc.c  */
10453 #line 4389 "parse.y"
10454     {
10455                     /*%%%*/
10456                         (yyval.node) = 0;
10457                     /*%
10458                         $$ = Qnil;
10459                     %*/
10460                     }
10461     break;
10462 
10463   case 527:
10464 
10465 /* Line 1806 of yacc.c  */
10466 #line 4397 "parse.y"
10467     {
10468                         lex_state = EXPR_BEG;
10469                         command_start = TRUE;
10470                     }
10471     break;
10472 
10473   case 528:
10474 
10475 /* Line 1806 of yacc.c  */
10476 #line 4402 "parse.y"
10477     {
10478                         (yyval.node) = (yyvsp[(3) - (4)].node);
10479                     }
10480     break;
10481 
10482   case 529:
10483 
10484 /* Line 1806 of yacc.c  */
10485 #line 4406 "parse.y"
10486     {
10487                     /*%%%*/
10488                         yyerrok;
10489                         (yyval.node) = 0;
10490                     /*%
10491                         yyerrok;
10492                         $$ = Qnil;
10493                     %*/
10494                     }
10495     break;
10496 
10497   case 530:
10498 
10499 /* Line 1806 of yacc.c  */
10500 #line 4418 "parse.y"
10501     {
10502                     /*%%%*/
10503                         (yyval.node) = (yyvsp[(2) - (3)].node);
10504                     /*%
10505                         $$ = dispatch1(paren, $2);
10506                     %*/
10507                         lex_state = EXPR_BEG;
10508                         command_start = TRUE;
10509                     }
10510     break;
10511 
10512   case 531:
10513 
10514 /* Line 1806 of yacc.c  */
10515 #line 4427 "parse.y"
10516     {
10517                         (yyval.num) = parser->parser_in_kwarg;
10518                         parser->parser_in_kwarg = 1;
10519                     }
10520     break;
10521 
10522   case 532:
10523 
10524 /* Line 1806 of yacc.c  */
10525 #line 4432 "parse.y"
10526     {
10527                         parser->parser_in_kwarg = (yyvsp[(1) - (3)].num);
10528                         (yyval.node) = (yyvsp[(2) - (3)].node);
10529                         lex_state = EXPR_BEG;
10530                         command_start = TRUE;
10531                     }
10532     break;
10533 
10534   case 533:
10535 
10536 /* Line 1806 of yacc.c  */
10537 #line 4441 "parse.y"
10538     {
10539                         (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
10540                     }
10541     break;
10542 
10543   case 534:
10544 
10545 /* Line 1806 of yacc.c  */
10546 #line 4445 "parse.y"
10547     {
10548                         (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
10549                     }
10550     break;
10551 
10552   case 535:
10553 
10554 /* Line 1806 of yacc.c  */
10555 #line 4449 "parse.y"
10556     {
10557                         (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
10558                     }
10559     break;
10560 
10561   case 536:
10562 
10563 /* Line 1806 of yacc.c  */
10564 #line 4453 "parse.y"
10565     {
10566                         (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
10567                     }
10568     break;
10569 
10570   case 537:
10571 
10572 /* Line 1806 of yacc.c  */
10573 #line 4459 "parse.y"
10574     {
10575                         (yyval.node) = (yyvsp[(2) - (2)].node);
10576                     }
10577     break;
10578 
10579   case 538:
10580 
10581 /* Line 1806 of yacc.c  */
10582 #line 4463 "parse.y"
10583     {
10584                         (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10585                     }
10586     break;
10587 
10588   case 539:
10589 
10590 /* Line 1806 of yacc.c  */
10591 #line 4469 "parse.y"
10592     {
10593                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
10594                     }
10595     break;
10596 
10597   case 540:
10598 
10599 /* Line 1806 of yacc.c  */
10600 #line 4473 "parse.y"
10601     {
10602                         (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
10603                     }
10604     break;
10605 
10606   case 541:
10607 
10608 /* Line 1806 of yacc.c  */
10609 #line 4477 "parse.y"
10610     {
10611                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
10612                     }
10613     break;
10614 
10615   case 542:
10616 
10617 /* Line 1806 of yacc.c  */
10618 #line 4481 "parse.y"
10619     {
10620                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10621                     }
10622     break;
10623 
10624   case 543:
10625 
10626 /* Line 1806 of yacc.c  */
10627 #line 4485 "parse.y"
10628     {
10629                         (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10630                     }
10631     break;
10632 
10633   case 544:
10634 
10635 /* Line 1806 of yacc.c  */
10636 #line 4489 "parse.y"
10637     {
10638                         (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10639                     }
10640     break;
10641 
10642   case 545:
10643 
10644 /* Line 1806 of yacc.c  */
10645 #line 4493 "parse.y"
10646     {
10647                         (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
10648                     }
10649     break;
10650 
10651   case 546:
10652 
10653 /* Line 1806 of yacc.c  */
10654 #line 4497 "parse.y"
10655     {
10656                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10657                     }
10658     break;
10659 
10660   case 547:
10661 
10662 /* Line 1806 of yacc.c  */
10663 #line 4501 "parse.y"
10664     {
10665                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10666                     }
10667     break;
10668 
10669   case 548:
10670 
10671 /* Line 1806 of yacc.c  */
10672 #line 4505 "parse.y"
10673     {
10674                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
10675                     }
10676     break;
10677 
10678   case 549:
10679 
10680 /* Line 1806 of yacc.c  */
10681 #line 4509 "parse.y"
10682     {
10683                         (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10684                     }
10685     break;
10686 
10687   case 550:
10688 
10689 /* Line 1806 of yacc.c  */
10690 #line 4513 "parse.y"
10691     {
10692                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
10693                     }
10694     break;
10695 
10696   case 551:
10697 
10698 /* Line 1806 of yacc.c  */
10699 #line 4517 "parse.y"
10700     {
10701                         (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10702                     }
10703     break;
10704 
10705   case 552:
10706 
10707 /* Line 1806 of yacc.c  */
10708 #line 4521 "parse.y"
10709     {
10710                         (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
10711                     }
10712     break;
10713 
10714   case 553:
10715 
10716 /* Line 1806 of yacc.c  */
10717 #line 4525 "parse.y"
10718     {
10719                         (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10720                         (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.node));
10721                     }
10722     break;
10723 
10724   case 554:
10725 
10726 /* Line 1806 of yacc.c  */
10727 #line 4532 "parse.y"
10728     {
10729                     /*%%%*/
10730                         yyerror("formal argument cannot be a constant");
10731                         (yyval.id) = 0;
10732                     /*%
10733                         $$ = dispatch1(param_error, $1);
10734                     %*/
10735                     }
10736     break;
10737 
10738   case 555:
10739 
10740 /* Line 1806 of yacc.c  */
10741 #line 4541 "parse.y"
10742     {
10743                     /*%%%*/
10744                         yyerror("formal argument cannot be an instance variable");
10745                         (yyval.id) = 0;
10746                     /*%
10747                         $$ = dispatch1(param_error, $1);
10748                     %*/
10749                     }
10750     break;
10751 
10752   case 556:
10753 
10754 /* Line 1806 of yacc.c  */
10755 #line 4550 "parse.y"
10756     {
10757                     /*%%%*/
10758                         yyerror("formal argument cannot be a global variable");
10759                         (yyval.id) = 0;
10760                     /*%
10761                         $$ = dispatch1(param_error, $1);
10762                     %*/
10763                     }
10764     break;
10765 
10766   case 557:
10767 
10768 /* Line 1806 of yacc.c  */
10769 #line 4559 "parse.y"
10770     {
10771                     /*%%%*/
10772                         yyerror("formal argument cannot be a class variable");
10773                         (yyval.id) = 0;
10774                     /*%
10775                         $$ = dispatch1(param_error, $1);
10776                     %*/
10777                     }
10778     break;
10779 
10780   case 559:
10781 
10782 /* Line 1806 of yacc.c  */
10783 #line 4571 "parse.y"
10784     {
10785                         formal_argument(get_id((yyvsp[(1) - (1)].id)));
10786                         (yyval.id) = (yyvsp[(1) - (1)].id);
10787                     }
10788     break;
10789 
10790   case 560:
10791 
10792 /* Line 1806 of yacc.c  */
10793 #line 4578 "parse.y"
10794     {
10795                         arg_var(get_id((yyvsp[(1) - (1)].id)));
10796                     /*%%%*/
10797                         (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1);
10798                     /*%
10799                         $$ = get_value($1);
10800                     %*/
10801                     }
10802     break;
10803 
10804   case 561:
10805 
10806 /* Line 1806 of yacc.c  */
10807 #line 4587 "parse.y"
10808     {
10809                         ID tid = internal_id();
10810                         arg_var(tid);
10811                     /*%%%*/
10812                         if (dyna_in_block()) {
10813                             (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid);
10814                         }
10815                         else {
10816                             (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid);
10817                         }
10818                         (yyval.node) = NEW_ARGS_AUX(tid, 1);
10819                         (yyval.node)->nd_next = (yyvsp[(2) - (3)].node);
10820                     /*%
10821                         $$ = dispatch1(mlhs_paren, $2);
10822                     %*/
10823                     }
10824     break;
10825 
10826   case 563:
10827 
10828 /* Line 1806 of yacc.c  */
10829 #line 4613 "parse.y"
10830     {
10831                     /*%%%*/
10832                         (yyval.node) = (yyvsp[(1) - (3)].node);
10833                         (yyval.node)->nd_plen++;
10834                         (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next);
10835                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node));
10836                     /*%
10837                         $$ = rb_ary_push($1, $3);
10838                     %*/
10839                     }
10840     break;
10841 
10842   case 564:
10843 
10844 /* Line 1806 of yacc.c  */
10845 #line 4627 "parse.y"
10846     {
10847                         arg_var(formal_argument(get_id((yyvsp[(1) - (1)].id))));
10848                         (yyval.id) = (yyvsp[(1) - (1)].id);
10849                     }
10850     break;
10851 
10852   case 565:
10853 
10854 /* Line 1806 of yacc.c  */
10855 #line 4634 "parse.y"
10856     {
10857                         (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10858                     /*%%%*/
10859                         (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10860                     /*%
10861                         $$ = rb_assoc_new($$, $2);
10862                     %*/
10863                     }
10864     break;
10865 
10866   case 566:
10867 
10868 /* Line 1806 of yacc.c  */
10869 #line 4643 "parse.y"
10870     {
10871                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), (NODE *)-1);
10872                     /*%%%*/
10873                         (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10874                     /*%
10875                         $$ = rb_assoc_new($$, 0);
10876                     %*/
10877                     }
10878     break;
10879 
10880   case 567:
10881 
10882 /* Line 1806 of yacc.c  */
10883 #line 4654 "parse.y"
10884     {
10885                         (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10886                     /*%%%*/
10887                         (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10888                     /*%
10889                         $$ = rb_assoc_new($$, $2);
10890                     %*/
10891                     }
10892     break;
10893 
10894   case 568:
10895 
10896 /* Line 1806 of yacc.c  */
10897 #line 4663 "parse.y"
10898     {
10899                         (yyval.node) = assignable((yyvsp[(1) - (1)].id), (NODE *)-1);
10900                     /*%%%*/
10901                         (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10902                     /*%
10903                         $$ = rb_assoc_new($$, 0);
10904                     %*/
10905                     }
10906     break;
10907 
10908   case 569:
10909 
10910 /* Line 1806 of yacc.c  */
10911 #line 4674 "parse.y"
10912     {
10913                     /*%%%*/
10914                         (yyval.node) = (yyvsp[(1) - (1)].node);
10915                     /*%
10916                         $$ = rb_ary_new3(1, $1);
10917                     %*/
10918                     }
10919     break;
10920 
10921   case 570:
10922 
10923 /* Line 1806 of yacc.c  */
10924 #line 4682 "parse.y"
10925     {
10926                     /*%%%*/
10927                         NODE *kws = (yyvsp[(1) - (3)].node);
10928 
10929                         while (kws->nd_next) {
10930                             kws = kws->nd_next;
10931                         }
10932                         kws->nd_next = (yyvsp[(3) - (3)].node);
10933                         (yyval.node) = (yyvsp[(1) - (3)].node);
10934                     /*%
10935                         $$ = rb_ary_push($1, $3);
10936                     %*/
10937                     }
10938     break;
10939 
10940   case 571:
10941 
10942 /* Line 1806 of yacc.c  */
10943 #line 4699 "parse.y"
10944     {
10945                     /*%%%*/
10946                         (yyval.node) = (yyvsp[(1) - (1)].node);
10947                     /*%
10948                         $$ = rb_ary_new3(1, $1);
10949                     %*/
10950                     }
10951     break;
10952 
10953   case 572:
10954 
10955 /* Line 1806 of yacc.c  */
10956 #line 4707 "parse.y"
10957     {
10958                     /*%%%*/
10959                         NODE *kws = (yyvsp[(1) - (3)].node);
10960 
10961                         while (kws->nd_next) {
10962                             kws = kws->nd_next;
10963                         }
10964                         kws->nd_next = (yyvsp[(3) - (3)].node);
10965                         (yyval.node) = (yyvsp[(1) - (3)].node);
10966                     /*%
10967                         $$ = rb_ary_push($1, $3);
10968                     %*/
10969                     }
10970     break;
10971 
10972   case 575:
10973 
10974 /* Line 1806 of yacc.c  */
10975 #line 4727 "parse.y"
10976     {
10977                         shadowing_lvar(get_id((yyvsp[(2) - (2)].id)));
10978                         (yyval.id) = (yyvsp[(2) - (2)].id);
10979                     }
10980     break;
10981 
10982   case 576:
10983 
10984 /* Line 1806 of yacc.c  */
10985 #line 4732 "parse.y"
10986     {
10987                         (yyval.id) = internal_id();
10988                     }
10989     break;
10990 
10991   case 577:
10992 
10993 /* Line 1806 of yacc.c  */
10994 #line 4738 "parse.y"
10995     {
10996                         arg_var(get_id((yyvsp[(1) - (3)].id)));
10997                         (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10998                     /*%%%*/
10999                         (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
11000                     /*%
11001                         $$ = rb_assoc_new($$, $3);
11002                     %*/
11003                     }
11004     break;
11005 
11006   case 578:
11007 
11008 /* Line 1806 of yacc.c  */
11009 #line 4750 "parse.y"
11010     {
11011                         arg_var(get_id((yyvsp[(1) - (3)].id)));
11012                         (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
11013                     /*%%%*/
11014                         (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
11015                     /*%
11016                         $$ = rb_assoc_new($$, $3);
11017                     %*/
11018                     }
11019     break;
11020 
11021   case 579:
11022 
11023 /* Line 1806 of yacc.c  */
11024 #line 4762 "parse.y"
11025     {
11026                     /*%%%*/
11027                         (yyval.node) = (yyvsp[(1) - (1)].node);
11028                     /*%
11029                         $$ = rb_ary_new3(1, $1);
11030                     %*/
11031                     }
11032     break;
11033 
11034   case 580:
11035 
11036 /* Line 1806 of yacc.c  */
11037 #line 4770 "parse.y"
11038     {
11039                     /*%%%*/
11040                         NODE *opts = (yyvsp[(1) - (3)].node);
11041 
11042                         while (opts->nd_next) {
11043                             opts = opts->nd_next;
11044                         }
11045                         opts->nd_next = (yyvsp[(3) - (3)].node);
11046                         (yyval.node) = (yyvsp[(1) - (3)].node);
11047                     /*%
11048                         $$ = rb_ary_push($1, $3);
11049                     %*/
11050                     }
11051     break;
11052 
11053   case 581:
11054 
11055 /* Line 1806 of yacc.c  */
11056 #line 4786 "parse.y"
11057     {
11058                     /*%%%*/
11059                         (yyval.node) = (yyvsp[(1) - (1)].node);
11060                     /*%
11061                         $$ = rb_ary_new3(1, $1);
11062                     %*/
11063                     }
11064     break;
11065 
11066   case 582:
11067 
11068 /* Line 1806 of yacc.c  */
11069 #line 4794 "parse.y"
11070     {
11071                     /*%%%*/
11072                         NODE *opts = (yyvsp[(1) - (3)].node);
11073 
11074                         while (opts->nd_next) {
11075                             opts = opts->nd_next;
11076                         }
11077                         opts->nd_next = (yyvsp[(3) - (3)].node);
11078                         (yyval.node) = (yyvsp[(1) - (3)].node);
11079                     /*%
11080                         $$ = rb_ary_push($1, $3);
11081                     %*/
11082                     }
11083     break;
11084 
11085   case 585:
11086 
11087 /* Line 1806 of yacc.c  */
11088 #line 4814 "parse.y"
11089     {
11090                     /*%%%*/
11091                         if (!is_local_id((yyvsp[(2) - (2)].id)))
11092                             yyerror("rest argument must be local variable");
11093                     /*% %*/
11094                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11095                     /*%%%*/
11096                         (yyval.id) = (yyvsp[(2) - (2)].id);
11097                     /*%
11098                         $$ = dispatch1(rest_param, $2);
11099                     %*/
11100                     }
11101     break;
11102 
11103   case 586:
11104 
11105 /* Line 1806 of yacc.c  */
11106 #line 4827 "parse.y"
11107     {
11108                     /*%%%*/
11109                         (yyval.id) = internal_id();
11110                         arg_var((yyval.id));
11111                     /*%
11112                         $$ = dispatch1(rest_param, Qnil);
11113                     %*/
11114                     }
11115     break;
11116 
11117   case 589:
11118 
11119 /* Line 1806 of yacc.c  */
11120 #line 4842 "parse.y"
11121     {
11122                     /*%%%*/
11123                         if (!is_local_id((yyvsp[(2) - (2)].id)))
11124                             yyerror("block argument must be local variable");
11125                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id)))
11126                             yyerror("duplicated block argument name");
11127                     /*% %*/
11128                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11129                     /*%%%*/
11130                         (yyval.id) = (yyvsp[(2) - (2)].id);
11131                     /*%
11132                         $$ = dispatch1(blockarg, $2);
11133                     %*/
11134                     }
11135     break;
11136 
11137   case 590:
11138 
11139 /* Line 1806 of yacc.c  */
11140 #line 4859 "parse.y"
11141     {
11142                         (yyval.id) = (yyvsp[(2) - (2)].id);
11143                     }
11144     break;
11145 
11146   case 591:
11147 
11148 /* Line 1806 of yacc.c  */
11149 #line 4863 "parse.y"
11150     {
11151                     /*%%%*/
11152                         (yyval.id) = 0;
11153                     /*%
11154                         $$ = Qundef;
11155                     %*/
11156                     }
11157     break;
11158 
11159   case 592:
11160 
11161 /* Line 1806 of yacc.c  */
11162 #line 4873 "parse.y"
11163     {
11164                     /*%%%*/
11165                         value_expr((yyvsp[(1) - (1)].node));
11166                         (yyval.node) = (yyvsp[(1) - (1)].node);
11167                         if (!(yyval.node)) (yyval.node) = NEW_NIL();
11168                     /*%
11169                         $$ = $1;
11170                     %*/
11171                     }
11172     break;
11173 
11174   case 593:
11175 
11176 /* Line 1806 of yacc.c  */
11177 #line 4882 "parse.y"
11178     {lex_state = EXPR_BEG;}
11179     break;
11180 
11181   case 594:
11182 
11183 /* Line 1806 of yacc.c  */
11184 #line 4883 "parse.y"
11185     {
11186                     /*%%%*/
11187                         if ((yyvsp[(3) - (4)].node) == 0) {
11188                             yyerror("can't define singleton method for ().");
11189                         }
11190                         else {
11191                             switch (nd_type((yyvsp[(3) - (4)].node))) {
11192                               case NODE_STR:
11193                               case NODE_DSTR:
11194                               case NODE_XSTR:
11195                               case NODE_DXSTR:
11196                               case NODE_DREGX:
11197                               case NODE_LIT:
11198                               case NODE_ARRAY:
11199                               case NODE_ZARRAY:
11200                                 yyerror("can't define singleton method for literals");
11201                               default:
11202                                 value_expr((yyvsp[(3) - (4)].node));
11203                                 break;
11204                             }
11205                         }
11206                         (yyval.node) = (yyvsp[(3) - (4)].node);
11207                     /*%
11208                         $$ = dispatch1(paren, $3);
11209                     %*/
11210                     }
11211     break;
11212 
11213   case 596:
11214 
11215 /* Line 1806 of yacc.c  */
11216 #line 4913 "parse.y"
11217     {
11218                     /*%%%*/
11219                         (yyval.node) = (yyvsp[(1) - (2)].node);
11220                     /*%
11221                         $$ = dispatch1(assoclist_from_args, $1);
11222                     %*/
11223                     }
11224     break;
11225 
11226   case 598:
11227 
11228 /* Line 1806 of yacc.c  */
11229 #line 4930 "parse.y"
11230     {
11231                     /*%%%*/
11232                         (yyval.node) = list_concat((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
11233                     /*%
11234                         $$ = rb_ary_push($1, $3);
11235                     %*/
11236                     }
11237     break;
11238 
11239   case 599:
11240 
11241 /* Line 1806 of yacc.c  */
11242 #line 4940 "parse.y"
11243     {
11244                     /*%%%*/
11245                         if (nd_type((yyvsp[(1) - (3)].node)) == NODE_STR) {
11246                             nd_set_type((yyvsp[(1) - (3)].node), NODE_LIT);
11247                             (yyvsp[(1) - (3)].node)->nd_lit = rb_fstring((yyvsp[(1) - (3)].node)->nd_lit);
11248                         }
11249                         (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node));
11250                     /*%
11251                         $$ = dispatch2(assoc_new, $1, $3);
11252                     %*/
11253                     }
11254     break;
11255 
11256   case 600:
11257 
11258 /* Line 1806 of yacc.c  */
11259 #line 4952 "parse.y"
11260     {
11261                     /*%%%*/
11262                         (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node));
11263                     /*%
11264                         $$ = dispatch2(assoc_new, $1, $2);
11265                     %*/
11266                     }
11267     break;
11268 
11269   case 601:
11270 
11271 /* Line 1806 of yacc.c  */
11272 #line 4960 "parse.y"
11273     {
11274                     /*%%%*/
11275                         (yyval.node) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].node));
11276                     /*%
11277                         $$ = dispatch1(assoc_splat, $2);
11278                     %*/
11279                     }
11280     break;
11281 
11282   case 623:
11283 
11284 /* Line 1806 of yacc.c  */
11285 #line 5018 "parse.y"
11286     {yyerrok;}
11287     break;
11288 
11289   case 626:
11290 
11291 /* Line 1806 of yacc.c  */
11292 #line 5023 "parse.y"
11293     {yyerrok;}
11294     break;
11295 
11296   case 627:
11297 
11298 /* Line 1806 of yacc.c  */
11299 #line 5027 "parse.y"
11300     {
11301                     /*%%%*/
11302                         (yyval.node) = 0;
11303                     /*%
11304                         $$ = Qundef;
11305                     %*/
11306                     }
11307     break;
11308 
11309 
11310 
11311 /* Line 1806 of yacc.c  */
11312 #line 11311 "parse.c"
11313       default: break;
11314     }
11315   /* User semantic actions sometimes alter yychar, and that requires
11316      that yytoken be updated with the new translation.  We take the
11317      approach of translating immediately before every use of yytoken.
11318      One alternative is translating here after every semantic action,
11319      but that translation would be missed if the semantic action invokes
11320      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11321      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
11322      incorrect destructor might then be invoked immediately.  In the
11323      case of YYERROR or YYBACKUP, subsequent parser actions might lead
11324      to an incorrect destructor call or verbose syntax error message
11325      before the lookahead is translated.  */
11326   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11327 
11328   YYPOPSTACK (yylen);
11329   yylen = 0;
11330   YY_STACK_PRINT (yyss, yyssp);
11331 
11332   *++yyvsp = yyval;
11333 
11334   /* Now `shift' the result of the reduction.  Determine what state
11335      that goes to, based on the state we popped back to and the rule
11336      number reduced by.  */
11337 
11338   yyn = yyr1[yyn];
11339 
11340   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11341   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11342     yystate = yytable[yystate];
11343   else
11344     yystate = yydefgoto[yyn - YYNTOKENS];
11345 
11346   goto yynewstate;
11347 
11348 
11349 /*------------------------------------.
11350 | yyerrlab -- here on detecting error |
11351 `------------------------------------*/
11352 yyerrlab:
11353   /* Make sure we have latest lookahead translation.  See comments at
11354      user semantic actions for why this is necessary.  */
11355   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11356 
11357   /* If not already recovering from an error, report this error.  */
11358   if (!yyerrstatus)
11359     {
11360       ++yynerrs;
11361 #if ! YYERROR_VERBOSE
11362       parser_yyerror (parser, YY_("syntax error"));
11363 #else
11364 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11365                                         yyssp, yytoken)
11366       {
11367         char const *yymsgp = YY_("syntax error");
11368         int yysyntax_error_status;
11369         yysyntax_error_status = YYSYNTAX_ERROR;
11370         if (yysyntax_error_status == 0)
11371           yymsgp = yymsg;
11372         else if (yysyntax_error_status == 1)
11373           {
11374             if (yymsg != yymsgbuf)
11375               YYSTACK_FREE (yymsg);
11376             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11377             if (!yymsg)
11378               {
11379                 yymsg = yymsgbuf;
11380                 yymsg_alloc = sizeof yymsgbuf;
11381                 yysyntax_error_status = 2;
11382               }
11383             else
11384               {
11385                 yysyntax_error_status = YYSYNTAX_ERROR;
11386                 yymsgp = yymsg;
11387               }
11388           }
11389         parser_yyerror (parser, yymsgp);
11390         if (yysyntax_error_status == 2)
11391           goto yyexhaustedlab;
11392       }
11393 # undef YYSYNTAX_ERROR
11394 #endif
11395     }
11396 
11397 
11398 
11399   if (yyerrstatus == 3)
11400     {
11401       /* If just tried and failed to reuse lookahead token after an
11402          error, discard it.  */
11403 
11404       if (yychar <= YYEOF)
11405         {
11406           /* Return failure if at end of input.  */
11407           if (yychar == YYEOF)
11408             YYABORT;
11409         }
11410       else
11411         {
11412           yydestruct ("Error: discarding",
11413                       yytoken, &yylval, parser);
11414           yychar = YYEMPTY;
11415         }
11416     }
11417 
11418   /* Else will try to reuse lookahead token after shifting the error
11419      token.  */
11420   goto yyerrlab1;
11421 
11422 
11423 /*---------------------------------------------------.
11424 | yyerrorlab -- error raised explicitly by YYERROR.  |
11425 `---------------------------------------------------*/
11426 yyerrorlab:
11427 
11428   /* Pacify compilers like GCC when the user code never invokes
11429      YYERROR and the label yyerrorlab therefore never appears in user
11430      code.  */
11431   if (/*CONSTCOND*/ 0)
11432      goto yyerrorlab;
11433 
11434   /* Do not reclaim the symbols of the rule which action triggered
11435      this YYERROR.  */
11436   YYPOPSTACK (yylen);
11437   yylen = 0;
11438   YY_STACK_PRINT (yyss, yyssp);
11439   yystate = *yyssp;
11440   goto yyerrlab1;
11441 
11442 
11443 /*-------------------------------------------------------------.
11444 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
11445 `-------------------------------------------------------------*/
11446 yyerrlab1:
11447   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
11448 
11449   for (;;)
11450     {
11451       yyn = yypact[yystate];
11452       if (!yypact_value_is_default (yyn))
11453         {
11454           yyn += YYTERROR;
11455           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11456             {
11457               yyn = yytable[yyn];
11458               if (0 < yyn)
11459                 break;
11460             }
11461         }
11462 
11463       /* Pop the current state because it cannot handle the error token.  */
11464       if (yyssp == yyss)
11465         YYABORT;
11466 
11467 
11468       yydestruct ("Error: popping",
11469                   yystos[yystate], yyvsp, parser);
11470       YYPOPSTACK (1);
11471       yystate = *yyssp;
11472       YY_STACK_PRINT (yyss, yyssp);
11473     }
11474 
11475   *++yyvsp = yylval;
11476 
11477 
11478   /* Shift the error token.  */
11479   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11480 
11481   yystate = yyn;
11482   goto yynewstate;
11483 
11484 
11485 /*-------------------------------------.
11486 | yyacceptlab -- YYACCEPT comes here.  |
11487 `-------------------------------------*/
11488 yyacceptlab:
11489   yyresult = 0;
11490   goto yyreturn;
11491 
11492 /*-----------------------------------.
11493 | yyabortlab -- YYABORT comes here.  |
11494 `-----------------------------------*/
11495 yyabortlab:
11496   yyresult = 1;
11497   goto yyreturn;
11498 
11499 #if !defined(yyoverflow) || YYERROR_VERBOSE
11500 /*-------------------------------------------------.
11501 | yyexhaustedlab -- memory exhaustion comes here.  |
11502 `-------------------------------------------------*/
11503 yyexhaustedlab:
11504   parser_yyerror (parser, YY_("memory exhausted"));
11505   yyresult = 2;
11506   /* Fall through.  */
11507 #endif
11508 
11509 yyreturn:
11510   if (yychar != YYEMPTY)
11511     {
11512       /* Make sure we have latest lookahead translation.  See comments at
11513          user semantic actions for why this is necessary.  */
11514       yytoken = YYTRANSLATE (yychar);
11515       yydestruct ("Cleanup: discarding lookahead",
11516                   yytoken, &yylval, parser);
11517     }
11518   /* Do not reclaim the symbols of the rule which action triggered
11519      this YYABORT or YYACCEPT.  */
11520   YYPOPSTACK (yylen);
11521   YY_STACK_PRINT (yyss, yyssp);
11522   while (yyssp != yyss)
11523     {
11524       yydestruct ("Cleanup: popping",
11525                   yystos[*yyssp], yyvsp, parser);
11526       YYPOPSTACK (1);
11527     }
11528 #ifndef yyoverflow
11529   if (yyss != yyssa)
11530     YYSTACK_FREE (yyss);
11531 #endif
11532 #if YYERROR_VERBOSE
11533   if (yymsg != yymsgbuf)
11534     YYSTACK_FREE (yymsg);
11535 #endif
11536   /* Make sure YYID is used.  */
11537   return YYID (yyresult);
11538 }
11539 
11540 
11541 
11542 /* Line 2067 of yacc.c  */
11543 #line 5035 "parse.y"
11544 
11545 # undef parser
11546 # undef yylex
11547 # undef yylval
11548 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
11549 
11550 static int parser_regx_options(struct parser_params*);
11551 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11552 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11553 static int parser_parse_string(struct parser_params*,NODE*);
11554 static int parser_here_document(struct parser_params*,NODE*);
11555 
11556 
11557 # define nextc()                      parser_nextc(parser)
11558 # define pushback(c)                  parser_pushback(parser, (c))
11559 # define newtok()                     parser_newtok(parser)
11560 # define tokspace(n)                  parser_tokspace(parser, (n))
11561 # define tokadd(c)                    parser_tokadd(parser, (c))
11562 # define tok_hex(numlen)              parser_tok_hex(parser, (numlen))
11563 # define read_escape(flags,e)         parser_read_escape(parser, (flags), (e))
11564 # define tokadd_escape(e)             parser_tokadd_escape(parser, (e))
11565 # define regx_options()               parser_regx_options(parser)
11566 # define tokadd_string(f,t,p,n,e)     parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11567 # define parse_string(n)              parser_parse_string(parser,(n))
11568 # define tokaddmbc(c, enc)            parser_tokaddmbc(parser, (c), (enc))
11569 # define here_document(n)             parser_here_document(parser,(n))
11570 # define heredoc_identifier()         parser_heredoc_identifier(parser)
11571 # define heredoc_restore(n)           parser_heredoc_restore(parser,(n))
11572 # define whole_match_p(e,l,i)         parser_whole_match_p(parser,(e),(l),(i))
11573 # define number_literal_suffix(f)     parser_number_literal_suffix(parser, (f))
11574 # define set_number_literal(v, t, f)  parser_set_number_literal(parser, (v), (t), (f))
11575 # define set_integer_literal(v, f)    parser_set_integer_literal(parser, (v), (f))
11576 
11577 #ifndef RIPPER
11578 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11579 # define set_yylval_num(x) (yylval.num = (x))
11580 # define set_yylval_id(x)  (yylval.id = (x))
11581 # define set_yylval_name(x)  (yylval.id = (x))
11582 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11583 # define set_yylval_node(x) (yylval.node = (x))
11584 # define yylval_id() (yylval.id)
11585 #else
11586 static inline VALUE
11587 ripper_yylval_id(ID x)
11588 {
11589     return (VALUE)NEW_LASGN(x, ID2SYM(x));
11590 }
11591 # define set_yylval_str(x) (void)(x)
11592 # define set_yylval_num(x) (void)(x)
11593 # define set_yylval_id(x)  (void)(x)
11594 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11595 # define set_yylval_literal(x) (void)(x)
11596 # define set_yylval_node(x) (void)(x)
11597 # define yylval_id() yylval.id
11598 #endif
11599 
11600 #ifndef RIPPER
11601 #define ripper_flush(p) (void)(p)
11602 #else
11603 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11604 
11605 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11606 
11607 static int
11608 ripper_has_scan_event(struct parser_params *parser)
11609 {
11610 
11611     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11612     return lex_p > parser->tokp;
11613 }
11614 
11615 static VALUE
11616 ripper_scan_event_val(struct parser_params *parser, int t)
11617 {
11618     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11619     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11620     ripper_flush(parser);
11621     return rval;
11622 }
11623 
11624 static void
11625 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11626 {
11627     if (!ripper_has_scan_event(parser)) return;
11628     yylval_rval = ripper_scan_event_val(parser, t);
11629 }
11630 
11631 static void
11632 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11633 {
11634     if (!ripper_has_scan_event(parser)) return;
11635     (void)ripper_scan_event_val(parser, t);
11636 }
11637 
11638 static void
11639 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11640 {
11641     int saved_line = ruby_sourceline;
11642     const char *saved_tokp = parser->tokp;
11643 
11644     ruby_sourceline = parser->delayed_line;
11645     parser->tokp = lex_pbeg + parser->delayed_col;
11646     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11647     parser->delayed = Qnil;
11648     ruby_sourceline = saved_line;
11649     parser->tokp = saved_tokp;
11650 }
11651 #endif /* RIPPER */
11652 
11653 #include "ruby/regex.h"
11654 #include "ruby/util.h"
11655 
11656 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11657    since ours (we hope) works properly with all combinations of
11658    machines, compilers, `char' and `unsigned char' argument types.
11659    (Per Bothner suggested the basic approach.)  */
11660 #undef SIGN_EXTEND_CHAR
11661 #if __STDC__
11662 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11663 #else  /* not __STDC__ */
11664 /* As in Harbison and Steele.  */
11665 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11666 #endif
11667 
11668 #define parser_encoding_name()  (current_enc->name)
11669 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,current_enc)
11670 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11671 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11672 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11673 
11674 #define parser_isascii() ISASCII(*(lex_p-1))
11675 
11676 #ifndef RIPPER
11677 static int
11678 token_info_get_column(struct parser_params *parser, const char *token)
11679 {
11680     int column = 1;
11681     const char *p, *pend = lex_p - strlen(token);
11682     for (p = lex_pbeg; p < pend; p++) {
11683         if (*p == '\t') {
11684             column = (((column - 1) / 8) + 1) * 8;
11685         }
11686         column++;
11687     }
11688     return column;
11689 }
11690 
11691 static int
11692 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11693 {
11694     const char *p, *pend = lex_p - strlen(token);
11695     for (p = lex_pbeg; p < pend; p++) {
11696         if (*p != ' ' && *p != '\t') {
11697             return 1;
11698         }
11699     }
11700     return 0;
11701 }
11702 
11703 #undef token_info_push
11704 static void
11705 token_info_push(struct parser_params *parser, const char *token)
11706 {
11707     token_info *ptinfo;
11708 
11709     if (!parser->parser_token_info_enabled) return;
11710     ptinfo = ALLOC(token_info);
11711     ptinfo->token = token;
11712     ptinfo->linenum = ruby_sourceline;
11713     ptinfo->column = token_info_get_column(parser, token);
11714     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11715     ptinfo->next = parser->parser_token_info;
11716 
11717     parser->parser_token_info = ptinfo;
11718 }
11719 
11720 #undef token_info_pop
11721 static void
11722 token_info_pop(struct parser_params *parser, const char *token)
11723 {
11724     int linenum;
11725     token_info *ptinfo = parser->parser_token_info;
11726 
11727     if (!ptinfo) return;
11728     parser->parser_token_info = ptinfo->next;
11729     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11730         goto finish;
11731     }
11732     linenum = ruby_sourceline;
11733     if (linenum == ptinfo->linenum) { /* SKIP */
11734         goto finish;
11735     }
11736     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11737         goto finish;
11738     }
11739     if (parser->parser_token_info_enabled) {
11740         rb_compile_warn(ruby_sourcefile, linenum,
11741                         "mismatched indentations at '%s' with '%s' at %d",
11742                         token, ptinfo->token, ptinfo->linenum);
11743     }
11744 
11745   finish:
11746     xfree(ptinfo);
11747 }
11748 #endif  /* RIPPER */
11749 
11750 static int
11751 parser_yyerror(struct parser_params *parser, const char *msg)
11752 {
11753 #ifndef RIPPER
11754     const int max_line_margin = 30;
11755     const char *p, *pe;
11756     char *buf;
11757     long len;
11758     int i;
11759 
11760     compile_error(PARSER_ARG "%s", msg);
11761     p = lex_p;
11762     while (lex_pbeg <= p) {
11763         if (*p == '\n') break;
11764         p--;
11765     }
11766     p++;
11767 
11768     pe = lex_p;
11769     while (pe < lex_pend) {
11770         if (*pe == '\n') break;
11771         pe++;
11772     }
11773 
11774     len = pe - p;
11775     if (len > 4) {
11776         char *p2;
11777         const char *pre = "", *post = "";
11778 
11779         if (len > max_line_margin * 2 + 10) {
11780             if (lex_p - p > max_line_margin) {
11781                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11782                 pre = "...";
11783             }
11784             if (pe - lex_p > max_line_margin) {
11785                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11786                 post = "...";
11787             }
11788             len = pe - p;
11789         }
11790         buf = ALLOCA_N(char, len+2);
11791         MEMCPY(buf, p, char, len);
11792         buf[len] = '\0';
11793         rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11794 
11795         i = (int)(lex_p - p);
11796         p2 = buf; pe = buf + len;
11797 
11798         while (p2 < pe) {
11799             if (*p2 != '\t') *p2 = ' ';
11800             p2++;
11801         }
11802         buf[i] = '^';
11803         buf[i+1] = '\0';
11804         rb_compile_error_append("%s%s", pre, buf);
11805     }
11806 #else
11807     dispatch1(parse_error, STR_NEW2(msg));
11808 #endif /* !RIPPER */
11809     return 0;
11810 }
11811 
11812 static void parser_prepare(struct parser_params *parser);
11813 
11814 #ifndef RIPPER
11815 static VALUE
11816 debug_lines(VALUE fname)
11817 {
11818     ID script_lines;
11819     CONST_ID(script_lines, "SCRIPT_LINES__");
11820     if (rb_const_defined_at(rb_cObject, script_lines)) {
11821         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11822         if (RB_TYPE_P(hash, T_HASH)) {
11823             VALUE lines = rb_ary_new();
11824             rb_hash_aset(hash, fname, lines);
11825             return lines;
11826         }
11827     }
11828     return 0;
11829 }
11830 
11831 static VALUE
11832 coverage(VALUE fname, int n)
11833 {
11834     VALUE coverages = rb_get_coverages();
11835     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11836         VALUE lines = rb_ary_new2(n);
11837         int i;
11838         RBASIC_CLEAR_CLASS(lines);
11839         for (i = 0; i < n; i++) RARRAY_ASET(lines, i, Qnil);
11840         RARRAY(lines)->as.heap.len = n;
11841         rb_hash_aset(coverages, fname, lines);
11842         return lines;
11843     }
11844     return 0;
11845 }
11846 
11847 static int
11848 e_option_supplied(struct parser_params *parser)
11849 {
11850     return strcmp(ruby_sourcefile, "-e") == 0;
11851 }
11852 
11853 static VALUE
11854 yycompile0(VALUE arg)
11855 {
11856     int n;
11857     NODE *tree;
11858     struct parser_params *parser = (struct parser_params *)arg;
11859 
11860     if (!compile_for_eval && rb_safe_level() == 0) {
11861         ruby_debug_lines = debug_lines(ruby_sourcefile_string);
11862         if (ruby_debug_lines && ruby_sourceline > 0) {
11863             VALUE str = STR_NEW0();
11864             n = ruby_sourceline;
11865             do {
11866                 rb_ary_push(ruby_debug_lines, str);
11867             } while (--n);
11868         }
11869 
11870         if (!e_option_supplied(parser)) {
11871             ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
11872         }
11873     }
11874     parser->last_cr_line = ruby_sourceline - 1;
11875 
11876     parser_prepare(parser);
11877     deferred_nodes = 0;
11878 #ifndef RIPPER
11879     parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
11880 #endif
11881 #ifndef RIPPER
11882     if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
11883         RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
11884                                 parser->parser_ruby_sourceline);
11885     }
11886 #endif
11887     n = yyparse((void*)parser);
11888 #ifndef RIPPER
11889     if (RUBY_DTRACE_PARSE_END_ENABLED()) {
11890         RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
11891                               parser->parser_ruby_sourceline);
11892     }
11893 #endif
11894     ruby_debug_lines = 0;
11895     ruby_coverage = 0;
11896     compile_for_eval = 0;
11897 
11898     lex_strterm = 0;
11899     lex_p = lex_pbeg = lex_pend = 0;
11900     lex_lastline = lex_nextline = 0;
11901     if (parser->nerr) {
11902         return 0;
11903     }
11904     tree = ruby_eval_tree;
11905     if (!tree) {
11906         tree = NEW_NIL();
11907     }
11908     else if (ruby_eval_tree_begin) {
11909         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11910     }
11911     return (VALUE)tree;
11912 }
11913 
11914 static NODE*
11915 yycompile(struct parser_params *parser, VALUE fname, int line)
11916 {
11917     ruby_sourcefile_string = rb_str_new_frozen(fname);
11918     ruby_sourcefile = RSTRING_PTR(fname);
11919     ruby_sourceline = line - 1;
11920     return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11921 }
11922 #endif /* !RIPPER */
11923 
11924 static rb_encoding *
11925 must_be_ascii_compatible(VALUE s)
11926 {
11927     rb_encoding *enc = rb_enc_get(s);
11928     if (!rb_enc_asciicompat(enc)) {
11929         rb_raise(rb_eArgError, "invalid source encoding");
11930     }
11931     return enc;
11932 }
11933 
11934 static VALUE
11935 lex_get_str(struct parser_params *parser, VALUE s)
11936 {
11937     char *beg, *end, *pend;
11938     rb_encoding *enc = must_be_ascii_compatible(s);
11939 
11940     beg = RSTRING_PTR(s);
11941     if (lex_gets_ptr) {
11942         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11943         beg += lex_gets_ptr;
11944     }
11945     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11946     end = beg;
11947     while (end < pend) {
11948         if (*end++ == '\n') break;
11949     }
11950     lex_gets_ptr = end - RSTRING_PTR(s);
11951     return rb_enc_str_new(beg, end - beg, enc);
11952 }
11953 
11954 static VALUE
11955 lex_getline(struct parser_params *parser)
11956 {
11957     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11958     if (NIL_P(line)) return line;
11959     must_be_ascii_compatible(line);
11960 #ifndef RIPPER
11961     if (ruby_debug_lines) {
11962         rb_enc_associate(line, current_enc);
11963         rb_ary_push(ruby_debug_lines, line);
11964     }
11965     if (ruby_coverage) {
11966         rb_ary_push(ruby_coverage, Qnil);
11967     }
11968 #endif
11969     return line;
11970 }
11971 
11972 #ifdef RIPPER
11973 static rb_data_type_t parser_data_type;
11974 #else
11975 static const rb_data_type_t parser_data_type;
11976 
11977 static NODE*
11978 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11979 {
11980     struct parser_params *parser;
11981     NODE *node;
11982 
11983     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11984     lex_gets = lex_get_str;
11985     lex_gets_ptr = 0;
11986     lex_input = s;
11987     lex_pbeg = lex_p = lex_pend = 0;
11988     compile_for_eval = rb_parse_in_eval();
11989 
11990     node = yycompile(parser, fname, line);
11991     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11992 
11993     return node;
11994 }
11995 
11996 NODE*
11997 rb_compile_string(const char *f, VALUE s, int line)
11998 {
11999     must_be_ascii_compatible(s);
12000     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
12001 }
12002 
12003 NODE*
12004 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12005 {
12006     return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12007 }
12008 
12009 NODE*
12010 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
12011 {
12012     must_be_ascii_compatible(s);
12013     return parser_compile_string(vparser, f, s, line);
12014 }
12015 
12016 NODE*
12017 rb_compile_cstr(const char *f, const char *s, int len, int line)
12018 {
12019     VALUE str = rb_str_new(s, len);
12020     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
12021 }
12022 
12023 NODE*
12024 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12025 {
12026     VALUE str = rb_str_new(s, len);
12027     return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12028 }
12029 
12030 static VALUE
12031 lex_io_gets(struct parser_params *parser, VALUE io)
12032 {
12033     return rb_io_gets(io);
12034 }
12035 
12036 NODE*
12037 rb_compile_file(const char *f, VALUE file, int start)
12038 {
12039     VALUE volatile vparser = rb_parser_new();
12040 
12041     return rb_parser_compile_file(vparser, f, file, start);
12042 }
12043 
12044 NODE*
12045 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12046 {
12047     return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12048 }
12049 
12050 NODE*
12051 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12052 {
12053     struct parser_params *parser;
12054     NODE *node;
12055 
12056     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12057     lex_gets = lex_io_gets;
12058     lex_input = file;
12059     lex_pbeg = lex_p = lex_pend = 0;
12060     compile_for_eval = rb_parse_in_eval();
12061 
12062     node = yycompile(parser, fname, start);
12063     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12064 
12065     return node;
12066 }
12067 #endif  /* !RIPPER */
12068 
12069 #define STR_FUNC_ESCAPE 0x01
12070 #define STR_FUNC_EXPAND 0x02
12071 #define STR_FUNC_REGEXP 0x04
12072 #define STR_FUNC_QWORDS 0x08
12073 #define STR_FUNC_SYMBOL 0x10
12074 #define STR_FUNC_INDENT 0x20
12075 
12076 enum string_type {
12077     str_squote = (0),
12078     str_dquote = (STR_FUNC_EXPAND),
12079     str_xquote = (STR_FUNC_EXPAND),
12080     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
12081     str_sword  = (STR_FUNC_QWORDS),
12082     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
12083     str_ssym   = (STR_FUNC_SYMBOL),
12084     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
12085 };
12086 
12087 static VALUE
12088 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12089 {
12090     VALUE str;
12091 
12092     str = rb_enc_str_new(p, n, enc);
12093     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12094         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
12095         }
12096         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12097             rb_enc_associate(str, rb_ascii8bit_encoding());
12098         }
12099     }
12100 
12101     return str;
12102 }
12103 
12104 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12105 #define lex_eol_p() (lex_p >= lex_pend)
12106 #define peek(c) peek_n((c), 0)
12107 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12108 
12109 static inline int
12110 parser_nextc(struct parser_params *parser)
12111 {
12112     int c;
12113 
12114     if (lex_p == lex_pend) {
12115         VALUE v = lex_nextline;
12116         lex_nextline = 0;
12117         if (!v) {
12118             if (parser->eofp)
12119                 return -1;
12120 
12121             if (!lex_input || NIL_P(v = lex_getline(parser))) {
12122                 parser->eofp = Qtrue;
12123                 lex_goto_eol(parser);
12124                 return -1;
12125             }
12126         }
12127         {
12128 #ifdef RIPPER
12129             if (parser->tokp < lex_pend) {
12130                 if (NIL_P(parser->delayed)) {
12131                     parser->delayed = rb_str_buf_new(1024);
12132                     rb_enc_associate(parser->delayed, current_enc);
12133                     rb_str_buf_cat(parser->delayed,
12134                                    parser->tokp, lex_pend - parser->tokp);
12135                     parser->delayed_line = ruby_sourceline;
12136                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12137                 }
12138                 else {
12139                     rb_str_buf_cat(parser->delayed,
12140                                    parser->tokp, lex_pend - parser->tokp);
12141                 }
12142             }
12143 #endif
12144             if (heredoc_end > 0) {
12145                 ruby_sourceline = heredoc_end;
12146                 heredoc_end = 0;
12147             }
12148             ruby_sourceline++;
12149             parser->line_count++;
12150             lex_pbeg = lex_p = RSTRING_PTR(v);
12151             lex_pend = lex_p + RSTRING_LEN(v);
12152             ripper_flush(parser);
12153             lex_lastline = v;
12154         }
12155     }
12156     c = (unsigned char)*lex_p++;
12157     if (c == '\r') {
12158         if (peek('\n')) {
12159             lex_p++;
12160             c = '\n';
12161         }
12162         else if (ruby_sourceline > parser->last_cr_line) {
12163             parser->last_cr_line = ruby_sourceline;
12164             rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space");
12165         }
12166     }
12167 
12168     return c;
12169 }
12170 
12171 static void
12172 parser_pushback(struct parser_params *parser, int c)
12173 {
12174     if (c == -1) return;
12175     lex_p--;
12176     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12177         lex_p--;
12178     }
12179 }
12180 
12181 #define was_bol() (lex_p == lex_pbeg + 1)
12182 
12183 #define tokfix() (tokenbuf[tokidx]='\0')
12184 #define tok() tokenbuf
12185 #define toklen() tokidx
12186 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12187 
12188 static char*
12189 parser_newtok(struct parser_params *parser)
12190 {
12191     tokidx = 0;
12192     tokline = ruby_sourceline;
12193     if (!tokenbuf) {
12194         toksiz = 60;
12195         tokenbuf = ALLOC_N(char, 60);
12196     }
12197     if (toksiz > 4096) {
12198         toksiz = 60;
12199         REALLOC_N(tokenbuf, char, 60);
12200     }
12201     return tokenbuf;
12202 }
12203 
12204 static char *
12205 parser_tokspace(struct parser_params *parser, int n)
12206 {
12207     tokidx += n;
12208 
12209     if (tokidx >= toksiz) {
12210         do {toksiz *= 2;} while (toksiz < tokidx);
12211         REALLOC_N(tokenbuf, char, toksiz);
12212     }
12213     return &tokenbuf[tokidx-n];
12214 }
12215 
12216 static void
12217 parser_tokadd(struct parser_params *parser, int c)
12218 {
12219     tokenbuf[tokidx++] = (char)c;
12220     if (tokidx >= toksiz) {
12221         toksiz *= 2;
12222         REALLOC_N(tokenbuf, char, toksiz);
12223     }
12224 }
12225 
12226 static int
12227 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12228 {
12229     int c;
12230 
12231     c = scan_hex(lex_p, 2, numlen);
12232     if (!*numlen) {
12233         yyerror("invalid hex escape");
12234         return 0;
12235     }
12236     lex_p += *numlen;
12237     return c;
12238 }
12239 
12240 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12241 
12242 /* return value is for ?\u3042 */
12243 static int
12244 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
12245                    int string_literal, int symbol_literal, int regexp_literal)
12246 {
12247     /*
12248      * If string_literal is true, then we allow multiple codepoints
12249      * in \u{}, and add the codepoints to the current token.
12250      * Otherwise we're parsing a character literal and return a single
12251      * codepoint without adding it
12252      */
12253 
12254     int codepoint;
12255     size_t numlen;
12256 
12257     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12258 
12259     if (peek('{')) {  /* handle \u{...} form */
12260         do {
12261             if (regexp_literal) { tokadd(*lex_p); }
12262             nextc();
12263             codepoint = scan_hex(lex_p, 6, &numlen);
12264             if (numlen == 0)  {
12265                 yyerror("invalid Unicode escape");
12266                 return 0;
12267             }
12268             if (codepoint > 0x10ffff) {
12269                 yyerror("invalid Unicode codepoint (too large)");
12270                 return 0;
12271             }
12272             lex_p += numlen;
12273             if (regexp_literal) {
12274                 tokcopy((int)numlen);
12275             }
12276             else if (codepoint >= 0x80) {
12277                 *encp = rb_utf8_encoding();
12278                 if (string_literal) tokaddmbc(codepoint, *encp);
12279             }
12280             else if (string_literal) {
12281                 tokadd(codepoint);
12282             }
12283         } while (string_literal && (peek(' ') || peek('\t')));
12284 
12285         if (!peek('}')) {
12286             yyerror("unterminated Unicode escape");
12287             return 0;
12288         }
12289 
12290         if (regexp_literal) { tokadd('}'); }
12291         nextc();
12292     }
12293     else {                      /* handle \uxxxx form */
12294         codepoint = scan_hex(lex_p, 4, &numlen);
12295         if (numlen < 4) {
12296             yyerror("invalid Unicode escape");
12297             return 0;
12298         }
12299         lex_p += 4;
12300         if (regexp_literal) {
12301             tokcopy(4);
12302         }
12303         else if (codepoint >= 0x80) {
12304             *encp = rb_utf8_encoding();
12305             if (string_literal) tokaddmbc(codepoint, *encp);
12306         }
12307         else if (string_literal) {
12308             tokadd(codepoint);
12309         }
12310     }
12311 
12312     return codepoint;
12313 }
12314 
12315 #define ESCAPE_CONTROL 1
12316 #define ESCAPE_META    2
12317 
12318 static int
12319 parser_read_escape(struct parser_params *parser, int flags,
12320                    rb_encoding **encp)
12321 {
12322     int c;
12323     size_t numlen;
12324 
12325     switch (c = nextc()) {
12326       case '\\':        /* Backslash */
12327         return c;
12328 
12329       case 'n': /* newline */
12330         return '\n';
12331 
12332       case 't': /* horizontal tab */
12333         return '\t';
12334 
12335       case 'r': /* carriage-return */
12336         return '\r';
12337 
12338       case 'f': /* form-feed */
12339         return '\f';
12340 
12341       case 'v': /* vertical tab */
12342         return '\13';
12343 
12344       case 'a': /* alarm(bell) */
12345         return '\007';
12346 
12347       case 'e': /* escape */
12348         return 033;
12349 
12350       case '0': case '1': case '2': case '3': /* octal constant */
12351       case '4': case '5': case '6': case '7':
12352         pushback(c);
12353         c = scan_oct(lex_p, 3, &numlen);
12354         lex_p += numlen;
12355         return c;
12356 
12357       case 'x': /* hex constant */
12358         c = tok_hex(&numlen);
12359         if (numlen == 0) return 0;
12360         return c;
12361 
12362       case 'b': /* backspace */
12363         return '\010';
12364 
12365       case 's': /* space */
12366         return ' ';
12367 
12368       case 'M':
12369         if (flags & ESCAPE_META) goto eof;
12370         if ((c = nextc()) != '-') {
12371             pushback(c);
12372             goto eof;
12373         }
12374         if ((c = nextc()) == '\\') {
12375             if (peek('u')) goto eof;
12376             return read_escape(flags|ESCAPE_META, encp) | 0x80;
12377         }
12378         else if (c == -1 || !ISASCII(c)) goto eof;
12379         else {
12380             return ((c & 0xff) | 0x80);
12381         }
12382 
12383       case 'C':
12384         if ((c = nextc()) != '-') {
12385             pushback(c);
12386             goto eof;
12387         }
12388       case 'c':
12389         if (flags & ESCAPE_CONTROL) goto eof;
12390         if ((c = nextc())== '\\') {
12391             if (peek('u')) goto eof;
12392             c = read_escape(flags|ESCAPE_CONTROL, encp);
12393         }
12394         else if (c == '?')
12395             return 0177;
12396         else if (c == -1 || !ISASCII(c)) goto eof;
12397         return c & 0x9f;
12398 
12399       eof:
12400       case -1:
12401         yyerror("Invalid escape character syntax");
12402         return '\0';
12403 
12404       default:
12405         return c;
12406     }
12407 }
12408 
12409 static void
12410 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
12411 {
12412     int len = rb_enc_codelen(c, enc);
12413     rb_enc_mbcput(c, tokspace(len), enc);
12414 }
12415 
12416 static int
12417 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
12418 {
12419     int c;
12420     int flags = 0;
12421     size_t numlen;
12422 
12423   first:
12424     switch (c = nextc()) {
12425       case '\n':
12426         return 0;               /* just ignore */
12427 
12428       case '0': case '1': case '2': case '3': /* octal constant */
12429       case '4': case '5': case '6': case '7':
12430         {
12431             ruby_scan_oct(--lex_p, 3, &numlen);
12432             if (numlen == 0) goto eof;
12433             lex_p += numlen;
12434             tokcopy((int)numlen + 1);
12435         }
12436         return 0;
12437 
12438       case 'x': /* hex constant */
12439         {
12440             tok_hex(&numlen);
12441             if (numlen == 0) return -1;
12442             tokcopy((int)numlen + 2);
12443         }
12444         return 0;
12445 
12446       case 'M':
12447         if (flags & ESCAPE_META) goto eof;
12448         if ((c = nextc()) != '-') {
12449             pushback(c);
12450             goto eof;
12451         }
12452         tokcopy(3);
12453         flags |= ESCAPE_META;
12454         goto escaped;
12455 
12456       case 'C':
12457         if (flags & ESCAPE_CONTROL) goto eof;
12458         if ((c = nextc()) != '-') {
12459             pushback(c);
12460             goto eof;
12461         }
12462         tokcopy(3);
12463         goto escaped;
12464 
12465       case 'c':
12466         if (flags & ESCAPE_CONTROL) goto eof;
12467         tokcopy(2);
12468         flags |= ESCAPE_CONTROL;
12469       escaped:
12470         if ((c = nextc()) == '\\') {
12471             goto first;
12472         }
12473         else if (c == -1) goto eof;
12474         tokadd(c);
12475         return 0;
12476 
12477       eof:
12478       case -1:
12479         yyerror("Invalid escape character syntax");
12480         return -1;
12481 
12482       default:
12483         tokadd('\\');
12484         tokadd(c);
12485     }
12486     return 0;
12487 }
12488 
12489 static int
12490 parser_regx_options(struct parser_params *parser)
12491 {
12492     int kcode = 0;
12493     int kopt = 0;
12494     int options = 0;
12495     int c, opt, kc;
12496 
12497     newtok();
12498     while (c = nextc(), ISALPHA(c)) {
12499         if (c == 'o') {
12500             options |= RE_OPTION_ONCE;
12501         }
12502         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12503             if (kc >= 0) {
12504                 if (kc != rb_ascii8bit_encindex()) kcode = c;
12505                 kopt = opt;
12506             }
12507             else {
12508                 options |= opt;
12509             }
12510         }
12511         else {
12512             tokadd(c);
12513         }
12514     }
12515     options |= kopt;
12516     pushback(c);
12517     if (toklen()) {
12518         tokfix();
12519         compile_error(PARSER_ARG "unknown regexp option%s - %s",
12520                       toklen() > 1 ? "s" : "", tok());
12521     }
12522     return options | RE_OPTION_ENCODING(kcode);
12523 }
12524 
12525 static void
12526 dispose_string(VALUE str)
12527 {
12528     rb_str_free(str);
12529     rb_gc_force_recycle(str);
12530 }
12531 
12532 static int
12533 parser_tokadd_mbchar(struct parser_params *parser, int c)
12534 {
12535     int len = parser_precise_mbclen();
12536     if (!MBCLEN_CHARFOUND_P(len)) {
12537         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12538         return -1;
12539     }
12540     tokadd(c);
12541     lex_p += --len;
12542     if (len > 0) tokcopy(len);
12543     return c;
12544 }
12545 
12546 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12547 
12548 static inline int
12549 simple_re_meta(int c)
12550 {
12551     switch (c) {
12552       case '$': case '*': case '+': case '.':
12553       case '?': case '^': case '|':
12554       case ')': case ']': case '}': case '>':
12555         return TRUE;
12556       default:
12557         return FALSE;
12558     }
12559 }
12560 
12561 static int
12562 parser_tokadd_string(struct parser_params *parser,
12563                      int func, int term, int paren, long *nest,
12564                      rb_encoding **encp)
12565 {
12566     int c;
12567     int has_nonascii = 0;
12568     rb_encoding *enc = *encp;
12569     char *errbuf = 0;
12570     static const char mixed_msg[] = "%s mixed within %s source";
12571 
12572 #define mixed_error(enc1, enc2) if (!errbuf) {  \
12573         size_t len = sizeof(mixed_msg) - 4;     \
12574         len += strlen(rb_enc_name(enc1));       \
12575         len += strlen(rb_enc_name(enc2));       \
12576         errbuf = ALLOCA_N(char, len);           \
12577         snprintf(errbuf, len, mixed_msg,        \
12578                  rb_enc_name(enc1),             \
12579                  rb_enc_name(enc2));            \
12580         yyerror(errbuf);                        \
12581     }
12582 #define mixed_escape(beg, enc1, enc2) do {      \
12583         const char *pos = lex_p;                \
12584         lex_p = (beg);                          \
12585         mixed_error((enc1), (enc2));            \
12586         lex_p = pos;                            \
12587     } while (0)
12588 
12589     while ((c = nextc()) != -1) {
12590         if (paren && c == paren) {
12591             ++*nest;
12592         }
12593         else if (c == term) {
12594             if (!nest || !*nest) {
12595                 pushback(c);
12596                 break;
12597             }
12598             --*nest;
12599         }
12600         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12601             int c2 = *lex_p;
12602             if (c2 == '$' || c2 == '@' || c2 == '{') {
12603                 pushback(c);
12604                 break;
12605             }
12606         }
12607         else if (c == '\\') {
12608             const char *beg = lex_p - 1;
12609             c = nextc();
12610             switch (c) {
12611               case '\n':
12612                 if (func & STR_FUNC_QWORDS) break;
12613                 if (func & STR_FUNC_EXPAND) continue;
12614                 tokadd('\\');
12615                 break;
12616 
12617               case '\\':
12618                 if (func & STR_FUNC_ESCAPE) tokadd(c);
12619                 break;
12620 
12621               case 'u':
12622                 if ((func & STR_FUNC_EXPAND) == 0) {
12623                     tokadd('\\');
12624                     break;
12625                 }
12626                 parser_tokadd_utf8(parser, &enc, 1,
12627                                    func & STR_FUNC_SYMBOL,
12628                                    func & STR_FUNC_REGEXP);
12629                 if (has_nonascii && enc != *encp) {
12630                     mixed_escape(beg, enc, *encp);
12631                 }
12632                 continue;
12633 
12634               default:
12635                 if (c == -1) return -1;
12636                 if (!ISASCII(c)) {
12637                     if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12638                     goto non_ascii;
12639                 }
12640                 if (func & STR_FUNC_REGEXP) {
12641                     if (c == term && !simple_re_meta(c)) {
12642                         tokadd(c);
12643                         continue;
12644                     }
12645                     pushback(c);
12646                     if ((c = tokadd_escape(&enc)) < 0)
12647                         return -1;
12648                     if (has_nonascii && enc != *encp) {
12649                         mixed_escape(beg, enc, *encp);
12650                     }
12651                     continue;
12652                 }
12653                 else if (func & STR_FUNC_EXPAND) {
12654                     pushback(c);
12655                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
12656                     c = read_escape(0, &enc);
12657                 }
12658                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12659                     /* ignore backslashed spaces in %w */
12660                 }
12661                 else if (c != term && !(paren && c == paren)) {
12662                     tokadd('\\');
12663                     pushback(c);
12664                     continue;
12665                 }
12666             }
12667         }
12668         else if (!parser_isascii()) {
12669           non_ascii:
12670             has_nonascii = 1;
12671             if (enc != *encp) {
12672                 mixed_error(enc, *encp);
12673                 continue;
12674             }
12675             if (tokadd_mbchar(c) == -1) return -1;
12676             continue;
12677         }
12678         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12679             pushback(c);
12680             break;
12681         }
12682         if (c & 0x80) {
12683             has_nonascii = 1;
12684             if (enc != *encp) {
12685                 mixed_error(enc, *encp);
12686                 continue;
12687             }
12688         }
12689         tokadd(c);
12690     }
12691     *encp = enc;
12692     return c;
12693 }
12694 
12695 #define NEW_STRTERM(func, term, paren) \
12696         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12697 
12698 #ifdef RIPPER
12699 static void
12700 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12701 {
12702     if (!NIL_P(parser->delayed)) {
12703         ptrdiff_t len = lex_p - parser->tokp;
12704         if (len > 0) {
12705             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12706         }
12707         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12708         parser->tokp = lex_p;
12709     }
12710 }
12711 
12712 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12713 #else
12714 #define flush_string_content(enc) ((void)(enc))
12715 #endif
12716 
12717 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12718 /* this can be shared with ripper, since it's independent from struct
12719  * parser_params. */
12720 #ifndef RIPPER
12721 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12722 #define SPECIAL_PUNCT(idx) ( \
12723         BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12724         BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12725         BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12726         BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12727         BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12728         BIT('0', idx))
12729 const unsigned int ruby_global_name_punct_bits[] = {
12730     SPECIAL_PUNCT(0),
12731     SPECIAL_PUNCT(1),
12732     SPECIAL_PUNCT(2),
12733 };
12734 #undef BIT
12735 #undef SPECIAL_PUNCT
12736 #endif
12737 
12738 static inline int
12739 is_global_name_punct(const int c)
12740 {
12741     if (c <= 0x20 || 0x7e < c) return 0;
12742     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12743 }
12744 
12745 static int
12746 parser_peek_variable_name(struct parser_params *parser)
12747 {
12748     int c;
12749     const char *p = lex_p;
12750 
12751     if (p + 1 >= lex_pend) return 0;
12752     c = *p++;
12753     switch (c) {
12754       case '$':
12755         if ((c = *p) == '-') {
12756             if (++p >= lex_pend) return 0;
12757             c = *p;
12758         }
12759         else if (is_global_name_punct(c) || ISDIGIT(c)) {
12760             return tSTRING_DVAR;
12761         }
12762         break;
12763       case '@':
12764         if ((c = *p) == '@') {
12765             if (++p >= lex_pend) return 0;
12766             c = *p;
12767         }
12768         break;
12769       case '{':
12770         lex_p = p;
12771         command_start = TRUE;
12772         return tSTRING_DBEG;
12773       default:
12774         return 0;
12775     }
12776     if (!ISASCII(c) || c == '_' || ISALPHA(c))
12777         return tSTRING_DVAR;
12778     return 0;
12779 }
12780 
12781 static int
12782 parser_parse_string(struct parser_params *parser, NODE *quote)
12783 {
12784     int func = (int)quote->nd_func;
12785     int term = nd_term(quote);
12786     int paren = nd_paren(quote);
12787     int c, space = 0;
12788     rb_encoding *enc = current_enc;
12789 
12790     if (func == -1) return tSTRING_END;
12791     c = nextc();
12792     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12793         do {c = nextc();} while (ISSPACE(c));
12794         space = 1;
12795     }
12796     if (c == term && !quote->nd_nest) {
12797         if (func & STR_FUNC_QWORDS) {
12798             quote->nd_func = -1;
12799             return ' ';
12800         }
12801         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12802         set_yylval_num(regx_options());
12803         return tREGEXP_END;
12804     }
12805     if (space) {
12806         pushback(c);
12807         return ' ';
12808     }
12809     newtok();
12810     if ((func & STR_FUNC_EXPAND) && c == '#') {
12811         int t = parser_peek_variable_name(parser);
12812         if (t) return t;
12813         tokadd('#');
12814         c = nextc();
12815     }
12816     pushback(c);
12817     if (tokadd_string(func, term, paren, &quote->nd_nest,
12818                       &enc) == -1) {
12819         ruby_sourceline = nd_line(quote);
12820         if (func & STR_FUNC_REGEXP) {
12821             if (parser->eofp)
12822                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
12823             return tREGEXP_END;
12824         }
12825         else {
12826             if (parser->eofp)
12827                 compile_error(PARSER_ARG "unterminated string meets end of file");
12828             return tSTRING_END;
12829         }
12830     }
12831 
12832     tokfix();
12833     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12834     flush_string_content(enc);
12835 
12836     return tSTRING_CONTENT;
12837 }
12838 
12839 static int
12840 parser_heredoc_identifier(struct parser_params *parser)
12841 {
12842     int c = nextc(), term, func = 0;
12843     long len;
12844 
12845     if (c == '-') {
12846         c = nextc();
12847         func = STR_FUNC_INDENT;
12848     }
12849     switch (c) {
12850       case '\'':
12851         func |= str_squote; goto quoted;
12852       case '"':
12853         func |= str_dquote; goto quoted;
12854       case '`':
12855         func |= str_xquote;
12856       quoted:
12857         newtok();
12858         tokadd(func);
12859         term = c;
12860         while ((c = nextc()) != -1 && c != term) {
12861             if (tokadd_mbchar(c) == -1) return 0;
12862         }
12863         if (c == -1) {
12864             compile_error(PARSER_ARG "unterminated here document identifier");
12865             return 0;
12866         }
12867         break;
12868 
12869       default:
12870         if (!parser_is_identchar()) {
12871             pushback(c);
12872             if (func & STR_FUNC_INDENT) {
12873                 pushback('-');
12874             }
12875             return 0;
12876         }
12877         newtok();
12878         term = '"';
12879         tokadd(func |= str_dquote);
12880         do {
12881             if (tokadd_mbchar(c) == -1) return 0;
12882         } while ((c = nextc()) != -1 && parser_is_identchar());
12883         pushback(c);
12884         break;
12885     }
12886 
12887     tokfix();
12888 #ifdef RIPPER
12889     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12890 #endif
12891     len = lex_p - lex_pbeg;
12892     lex_goto_eol(parser);
12893     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12894                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12895                                   len,                          /* nd_nth */
12896                                   lex_lastline);                /* nd_orig */
12897     nd_set_line(lex_strterm, ruby_sourceline);
12898     ripper_flush(parser);
12899     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12900 }
12901 
12902 static void
12903 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12904 {
12905     VALUE line;
12906 
12907     lex_strterm = 0;
12908     line = here->nd_orig;
12909     lex_lastline = line;
12910     lex_pbeg = RSTRING_PTR(line);
12911     lex_pend = lex_pbeg + RSTRING_LEN(line);
12912     lex_p = lex_pbeg + here->nd_nth;
12913     heredoc_end = ruby_sourceline;
12914     ruby_sourceline = nd_line(here);
12915     dispose_string(here->nd_lit);
12916     rb_gc_force_recycle((VALUE)here);
12917     ripper_flush(parser);
12918 }
12919 
12920 static int
12921 parser_whole_match_p(struct parser_params *parser,
12922     const char *eos, long len, int indent)
12923 {
12924     const char *p = lex_pbeg;
12925     long n;
12926 
12927     if (indent) {
12928         while (*p && ISSPACE(*p)) p++;
12929     }
12930     n = lex_pend - (p + len);
12931     if (n < 0) return FALSE;
12932     if (n > 0 && p[len] != '\n') {
12933         if (p[len] != '\r') return FALSE;
12934         if (n <= 1 || p[len+1] != '\n') return FALSE;
12935     }
12936     return strncmp(eos, p, len) == 0;
12937 }
12938 
12939 #define NUM_SUFFIX_R   (1<<0)
12940 #define NUM_SUFFIX_I   (1<<1)
12941 #define NUM_SUFFIX_ALL 3
12942 
12943 static int
12944 parser_number_literal_suffix(struct parser_params *parser, int mask)
12945 {
12946     int c, result = 0;
12947     const char *lastp = lex_p;
12948 
12949     while ((c = nextc()) != -1) {
12950         if ((mask & NUM_SUFFIX_I) && c == 'i') {
12951             result |= (mask & NUM_SUFFIX_I);
12952             mask &= ~NUM_SUFFIX_I;
12953             /* r after i, rational of complex is disallowed */
12954             mask &= ~NUM_SUFFIX_R;
12955             continue;
12956         }
12957         if ((mask & NUM_SUFFIX_R) && c == 'r') {
12958             result |= (mask & NUM_SUFFIX_R);
12959             mask &= ~NUM_SUFFIX_R;
12960             continue;
12961         }
12962         if (!ISASCII(c) || ISALPHA(c) || c == '_') {
12963             lex_p = lastp;
12964             return 0;
12965         }
12966         pushback(c);
12967         break;
12968     }
12969     return result;
12970 }
12971 
12972 static int
12973 parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
12974 {
12975     if (suffix & NUM_SUFFIX_I) {
12976         v = rb_complex_raw(INT2FIX(0), v);
12977         type = tIMAGINARY;
12978     }
12979     set_yylval_literal(v);
12980     return type;
12981 }
12982 
12983 static int
12984 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
12985 {
12986     int type = tINTEGER;
12987     if (suffix & NUM_SUFFIX_R) {
12988         v = rb_rational_raw1(v);
12989         type = tRATIONAL;
12990     }
12991     return set_number_literal(v, type, suffix);
12992 }
12993 
12994 #ifdef RIPPER
12995 static void
12996 ripper_dispatch_heredoc_end(struct parser_params *parser)
12997 {
12998     if (!NIL_P(parser->delayed))
12999         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13000     lex_goto_eol(parser);
13001     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
13002 }
13003 
13004 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
13005 #else
13006 #define dispatch_heredoc_end() ((void)0)
13007 #endif
13008 
13009 static int
13010 parser_here_document(struct parser_params *parser, NODE *here)
13011 {
13012     int c, func, indent = 0;
13013     const char *eos, *p, *pend;
13014     long len;
13015     VALUE str = 0;
13016     rb_encoding *enc = current_enc;
13017 
13018     eos = RSTRING_PTR(here->nd_lit);
13019     len = RSTRING_LEN(here->nd_lit) - 1;
13020     indent = (func = *eos++) & STR_FUNC_INDENT;
13021 
13022     if ((c = nextc()) == -1) {
13023       error:
13024         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
13025 #ifdef RIPPER
13026         if (NIL_P(parser->delayed)) {
13027             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
13028         }
13029         else {
13030             if (str ||
13031                 ((len = lex_p - parser->tokp) > 0 &&
13032                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
13033                 rb_str_append(parser->delayed, str);
13034             }
13035             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13036         }
13037         lex_goto_eol(parser);
13038 #endif
13039       restore:
13040         heredoc_restore(lex_strterm);
13041         return 0;
13042     }
13043     if (was_bol() && whole_match_p(eos, len, indent)) {
13044         dispatch_heredoc_end();
13045         heredoc_restore(lex_strterm);
13046         return tSTRING_END;
13047     }
13048 
13049     if (!(func & STR_FUNC_EXPAND)) {
13050         do {
13051             p = RSTRING_PTR(lex_lastline);
13052             pend = lex_pend;
13053             if (pend > p) {
13054                 switch (pend[-1]) {
13055                   case '\n':
13056                     if (--pend == p || pend[-1] != '\r') {
13057                         pend++;
13058                         break;
13059                     }
13060                   case '\r':
13061                     --pend;
13062                 }
13063             }
13064             if (str)
13065                 rb_str_cat(str, p, pend - p);
13066             else
13067                 str = STR_NEW(p, pend - p);
13068             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13069             lex_goto_eol(parser);
13070             if (nextc() == -1) {
13071                 if (str) {
13072                     dispose_string(str);
13073                     str = 0;
13074                 }
13075                 goto error;
13076             }
13077         } while (!whole_match_p(eos, len, indent));
13078     }
13079     else {
13080         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13081         newtok();
13082         if (c == '#') {
13083             int t = parser_peek_variable_name(parser);
13084             if (t) return t;
13085             tokadd('#');
13086             c = nextc();
13087         }
13088         do {
13089             pushback(c);
13090             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13091                 if (parser->eofp) goto error;
13092                 goto restore;
13093             }
13094             if (c != '\n') {
13095                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13096                 flush_string_content(enc);
13097                 return tSTRING_CONTENT;
13098             }
13099             tokadd(nextc());
13100             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13101             if ((c = nextc()) == -1) goto error;
13102         } while (!whole_match_p(eos, len, indent));
13103         str = STR_NEW3(tok(), toklen(), enc, func);
13104     }
13105     dispatch_heredoc_end();
13106     heredoc_restore(lex_strterm);
13107     lex_strterm = NEW_STRTERM(-1, 0, 0);
13108     set_yylval_str(str);
13109     return tSTRING_CONTENT;
13110 }
13111 
13112 #include "lex.c"
13113 
13114 static void
13115 arg_ambiguous_gen(struct parser_params *parser)
13116 {
13117 #ifndef RIPPER
13118     rb_warning0("ambiguous first argument; put parentheses or even spaces");
13119 #else
13120     dispatch0(arg_ambiguous);
13121 #endif
13122 }
13123 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13124 
13125 static ID
13126 formal_argument_gen(struct parser_params *parser, ID lhs)
13127 {
13128 #ifndef RIPPER
13129     if (!is_local_id(lhs))
13130         yyerror("formal argument must be local variable");
13131 #endif
13132     shadowing_lvar(lhs);
13133     return lhs;
13134 }
13135 
13136 static int
13137 lvar_defined_gen(struct parser_params *parser, ID id)
13138 {
13139     return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13140 }
13141 
13142 /* emacsen -*- hack */
13143 static long
13144 parser_encode_length(struct parser_params *parser, const char *name, long len)
13145 {
13146     long nlen;
13147 
13148     if (len > 5 && name[nlen = len - 5] == '-') {
13149         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13150             return nlen;
13151     }
13152     if (len > 4 && name[nlen = len - 4] == '-') {
13153         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13154             return nlen;
13155         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13156             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13157             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13158             return nlen;
13159     }
13160     return len;
13161 }
13162 
13163 static void
13164 parser_set_encode(struct parser_params *parser, const char *name)
13165 {
13166     int idx = rb_enc_find_index(name);
13167     rb_encoding *enc;
13168     VALUE excargs[3];
13169 
13170     if (idx < 0) {
13171         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13172       error:
13173         excargs[0] = rb_eArgError;
13174         excargs[2] = rb_make_backtrace();
13175         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13176         rb_exc_raise(rb_make_exception(3, excargs));
13177     }
13178     enc = rb_enc_from_index(idx);
13179     if (!rb_enc_asciicompat(enc)) {
13180         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13181         goto error;
13182     }
13183     parser->enc = enc;
13184 #ifndef RIPPER
13185     if (ruby_debug_lines) {
13186         VALUE lines = ruby_debug_lines;
13187         long i, n = RARRAY_LEN(lines);
13188         for (i = 0; i < n; ++i) {
13189             rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13190         }
13191     }
13192 #endif
13193 }
13194 
13195 static int
13196 comment_at_top(struct parser_params *parser)
13197 {
13198     const char *p = lex_pbeg, *pend = lex_p - 1;
13199     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13200     while (p < pend) {
13201         if (!ISSPACE(*p)) return 0;
13202         p++;
13203     }
13204     return 1;
13205 }
13206 
13207 #ifndef RIPPER
13208 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13209 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13210 
13211 static void
13212 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13213 {
13214     if (!comment_at_top(parser)) {
13215         return;
13216     }
13217     parser_set_encode(parser, val);
13218 }
13219 
13220 static void
13221 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13222 {
13223     int *p = &parser->parser_token_info_enabled;
13224 
13225     switch (*val) {
13226       case 't': case 'T':
13227         if (strcasecmp(val, "true") == 0) {
13228             *p = TRUE;
13229             return;
13230         }
13231         break;
13232       case 'f': case 'F':
13233         if (strcasecmp(val, "false") == 0) {
13234             *p = FALSE;
13235             return;
13236         }
13237         break;
13238     }
13239     rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13240 }
13241 
13242 struct magic_comment {
13243     const char *name;
13244     rb_magic_comment_setter_t func;
13245     rb_magic_comment_length_t length;
13246 };
13247 
13248 static const struct magic_comment magic_comments[] = {
13249     {"coding", magic_comment_encoding, parser_encode_length},
13250     {"encoding", magic_comment_encoding, parser_encode_length},
13251     {"warn_indent", parser_set_token_info},
13252 };
13253 #endif
13254 
13255 static const char *
13256 magic_comment_marker(const char *str, long len)
13257 {
13258     long i = 2;
13259 
13260     while (i < len) {
13261         switch (str[i]) {
13262           case '-':
13263             if (str[i-1] == '*' && str[i-2] == '-') {
13264                 return str + i + 1;
13265             }
13266             i += 2;
13267             break;
13268           case '*':
13269             if (i + 1 >= len) return 0;
13270             if (str[i+1] != '-') {
13271                 i += 4;
13272             }
13273             else if (str[i-1] != '-') {
13274                 i += 2;
13275             }
13276             else {
13277                 return str + i + 2;
13278             }
13279             break;
13280           default:
13281             i += 3;
13282             break;
13283         }
13284     }
13285     return 0;
13286 }
13287 
13288 static int
13289 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13290 {
13291     VALUE name = 0, val = 0;
13292     const char *beg, *end, *vbeg, *vend;
13293 #define str_copy(_s, _p, _n) ((_s) \
13294         ? (void)(rb_str_resize((_s), (_n)), \
13295            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13296         : (void)((_s) = STR_NEW((_p), (_n))))
13297 
13298     if (len <= 7) return FALSE;
13299     if (!(beg = magic_comment_marker(str, len))) return FALSE;
13300     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13301     str = beg;
13302     len = end - beg - 3;
13303 
13304     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13305     while (len > 0) {
13306 #ifndef RIPPER
13307         const struct magic_comment *p = magic_comments;
13308 #endif
13309         char *s;
13310         int i;
13311         long n = 0;
13312 
13313         for (; len > 0 && *str; str++, --len) {
13314             switch (*str) {
13315               case '\'': case '"': case ':': case ';':
13316                 continue;
13317             }
13318             if (!ISSPACE(*str)) break;
13319         }
13320         for (beg = str; len > 0; str++, --len) {
13321             switch (*str) {
13322               case '\'': case '"': case ':': case ';':
13323                 break;
13324               default:
13325                 if (ISSPACE(*str)) break;
13326                 continue;
13327             }
13328             break;
13329         }
13330         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13331         if (!len) break;
13332         if (*str != ':') continue;
13333 
13334         do str++; while (--len > 0 && ISSPACE(*str));
13335         if (!len) break;
13336         if (*str == '"') {
13337             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13338                 if (*str == '\\') {
13339                     --len;
13340                     ++str;
13341                 }
13342             }
13343             vend = str;
13344             if (len) {
13345                 --len;
13346                 ++str;
13347             }
13348         }
13349         else {
13350             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13351             vend = str;
13352         }
13353         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13354 
13355         n = end - beg;
13356         str_copy(name, beg, n);
13357         s = RSTRING_PTR(name);
13358         for (i = 0; i < n; ++i) {
13359             if (s[i] == '-') s[i] = '_';
13360         }
13361 #ifndef RIPPER
13362         do {
13363             if (STRNCASECMP(p->name, s, n) == 0) {
13364                 n = vend - vbeg;
13365                 if (p->length) {
13366                     n = (*p->length)(parser, vbeg, n);
13367                 }
13368                 str_copy(val, vbeg, n);
13369                 (*p->func)(parser, s, RSTRING_PTR(val));
13370                 break;
13371             }
13372         } while (++p < magic_comments + numberof(magic_comments));
13373 #else
13374         str_copy(val, vbeg, vend - vbeg);
13375         dispatch2(magic_comment, name, val);
13376 #endif
13377     }
13378 
13379     return TRUE;
13380 }
13381 
13382 static void
13383 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13384 {
13385     int sep = 0;
13386     const char *beg = str;
13387     VALUE s;
13388 
13389     for (;;) {
13390         if (send - str <= 6) return;
13391         switch (str[6]) {
13392           case 'C': case 'c': str += 6; continue;
13393           case 'O': case 'o': str += 5; continue;
13394           case 'D': case 'd': str += 4; continue;
13395           case 'I': case 'i': str += 3; continue;
13396           case 'N': case 'n': str += 2; continue;
13397           case 'G': case 'g': str += 1; continue;
13398           case '=': case ':':
13399             sep = 1;
13400             str += 6;
13401             break;
13402           default:
13403             str += 6;
13404             if (ISSPACE(*str)) break;
13405             continue;
13406         }
13407         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13408     }
13409     for (;;) {
13410         do {
13411             if (++str >= send) return;
13412         } while (ISSPACE(*str));
13413         if (sep) break;
13414         if (*str != '=' && *str != ':') return;
13415         sep = 1;
13416         str++;
13417     }
13418     beg = str;
13419     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13420     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13421     parser_set_encode(parser, RSTRING_PTR(s));
13422     rb_str_resize(s, 0);
13423 }
13424 
13425 static void
13426 parser_prepare(struct parser_params *parser)
13427 {
13428     int c = nextc();
13429     switch (c) {
13430       case '#':
13431         if (peek('!')) parser->has_shebang = 1;
13432         break;
13433       case 0xef:                /* UTF-8 BOM marker */
13434         if (lex_pend - lex_p >= 2 &&
13435             (unsigned char)lex_p[0] == 0xbb &&
13436             (unsigned char)lex_p[1] == 0xbf) {
13437             parser->enc = rb_utf8_encoding();
13438             lex_p += 2;
13439             lex_pbeg = lex_p;
13440             return;
13441         }
13442         break;
13443       case EOF:
13444         return;
13445     }
13446     pushback(c);
13447     parser->enc = rb_enc_get(lex_lastline);
13448 }
13449 
13450 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13451 #define IS_END() IS_lex_state(EXPR_END_ANY)
13452 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13453 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13454 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13455 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13456 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13457 
13458 #ifndef RIPPER
13459 #define ambiguous_operator(op, syn) ( \
13460     rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13461     rb_warning0("even though it seems like "syn""))
13462 #else
13463 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13464 #endif
13465 #define warn_balanced(op, syn) ((void) \
13466     (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13467      space_seen && !ISSPACE(c) && \
13468      (ambiguous_operator(op, syn), 0)))
13469 
13470 static int
13471 parse_numvar(struct parser_params *parser)
13472 {
13473     size_t len;
13474     int overflow;
13475     unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow);
13476     const unsigned long nth_ref_max =
13477         ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
13478     /* NTH_REF is left-shifted to be ORed with back-ref flag and
13479      * turned into a Fixnum, in compile.c */
13480 
13481     if (overflow || n > nth_ref_max) {
13482         /* compile_error()? */
13483         rb_warnS("`%s' is too big for a number variable, always nil", tok());
13484         return 0;               /* $0 is $PROGRAM_NAME, not NTH_REF */
13485     }
13486     else {
13487         return (int)n;
13488     }
13489 }
13490 
13491 static int
13492 parser_yylex(struct parser_params *parser)
13493 {
13494     register int c;
13495     int space_seen = 0;
13496     int cmd_state;
13497     enum lex_state_e last_state;
13498     rb_encoding *enc;
13499     int mb;
13500 #ifdef RIPPER
13501     int fallthru = FALSE;
13502 #endif
13503 
13504     if (lex_strterm) {
13505         int token;
13506         if (nd_type(lex_strterm) == NODE_HEREDOC) {
13507             token = here_document(lex_strterm);
13508             if (token == tSTRING_END) {
13509                 lex_strterm = 0;
13510                 lex_state = EXPR_END;
13511             }
13512         }
13513         else {
13514             token = parse_string(lex_strterm);
13515             if (token == tSTRING_END || token == tREGEXP_END) {
13516                 rb_gc_force_recycle((VALUE)lex_strterm);
13517                 lex_strterm = 0;
13518                 lex_state = EXPR_END;
13519             }
13520         }
13521         return token;
13522     }
13523     cmd_state = command_start;
13524     command_start = FALSE;
13525   retry:
13526     last_state = lex_state;
13527     switch (c = nextc()) {
13528       case '\0':                /* NUL */
13529       case '\004':              /* ^D */
13530       case '\032':              /* ^Z */
13531       case -1:                  /* end of script. */
13532         return 0;
13533 
13534         /* white spaces */
13535       case ' ': case '\t': case '\f': case '\r':
13536       case '\13': /* '\v' */
13537         space_seen = 1;
13538 #ifdef RIPPER
13539         while ((c = nextc())) {
13540             switch (c) {
13541               case ' ': case '\t': case '\f': case '\r':
13542               case '\13': /* '\v' */
13543                 break;
13544               default:
13545                 goto outofloop;
13546             }
13547         }
13548       outofloop:
13549         pushback(c);
13550         ripper_dispatch_scan_event(parser, tSP);
13551 #endif
13552         goto retry;
13553 
13554       case '#':         /* it's a comment */
13555         /* no magic_comment in shebang line */
13556         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13557             if (comment_at_top(parser)) {
13558                 set_file_encoding(parser, lex_p, lex_pend);
13559             }
13560         }
13561         lex_p = lex_pend;
13562 #ifdef RIPPER
13563         ripper_dispatch_scan_event(parser, tCOMMENT);
13564         fallthru = TRUE;
13565 #endif
13566         /* fall through */
13567       case '\n':
13568         if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
13569 #ifdef RIPPER
13570             if (!fallthru) {
13571                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
13572             }
13573             fallthru = FALSE;
13574 #endif
13575             if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
13576                 goto normal_newline;
13577             }
13578             goto retry;
13579         }
13580         while ((c = nextc())) {
13581             switch (c) {
13582               case ' ': case '\t': case '\f': case '\r':
13583               case '\13': /* '\v' */
13584                 space_seen = 1;
13585                 break;
13586               case '.': {
13587                   if ((c = nextc()) != '.') {
13588                       pushback(c);
13589                       pushback('.');
13590                       goto retry;
13591                   }
13592               }
13593               default:
13594                 --ruby_sourceline;
13595                 lex_nextline = lex_lastline;
13596               case -1:          /* EOF no decrement*/
13597                 lex_goto_eol(parser);
13598 #ifdef RIPPER
13599                 if (c != -1) {
13600                     parser->tokp = lex_p;
13601                 }
13602 #endif
13603                 goto normal_newline;
13604             }
13605         }
13606       normal_newline:
13607         command_start = TRUE;
13608         lex_state = EXPR_BEG;
13609         return '\n';
13610 
13611       case '*':
13612         if ((c = nextc()) == '*') {
13613             if ((c = nextc()) == '=') {
13614                 set_yylval_id(tPOW);
13615                 lex_state = EXPR_BEG;
13616                 return tOP_ASGN;
13617             }
13618             pushback(c);
13619             if (IS_SPCARG(c)) {
13620                 rb_warning0("`**' interpreted as argument prefix");
13621                 c = tDSTAR;
13622             }
13623             else if (IS_BEG()) {
13624                 c = tDSTAR;
13625             }
13626             else {
13627                 warn_balanced("**", "argument prefix");
13628                 c = tPOW;
13629             }
13630         }
13631         else {
13632             if (c == '=') {
13633                 set_yylval_id('*');
13634                 lex_state = EXPR_BEG;
13635                 return tOP_ASGN;
13636             }
13637             pushback(c);
13638             if (IS_SPCARG(c)) {
13639                 rb_warning0("`*' interpreted as argument prefix");
13640                 c = tSTAR;
13641             }
13642             else if (IS_BEG()) {
13643                 c = tSTAR;
13644             }
13645             else {
13646                 warn_balanced("*", "argument prefix");
13647                 c = '*';
13648             }
13649         }
13650         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13651         return c;
13652 
13653       case '!':
13654         c = nextc();
13655         if (IS_AFTER_OPERATOR()) {
13656             lex_state = EXPR_ARG;
13657             if (c == '@') {
13658                 return '!';
13659             }
13660         }
13661         else {
13662             lex_state = EXPR_BEG;
13663         }
13664         if (c == '=') {
13665             return tNEQ;
13666         }
13667         if (c == '~') {
13668             return tNMATCH;
13669         }
13670         pushback(c);
13671         return '!';
13672 
13673       case '=':
13674         if (was_bol()) {
13675             /* skip embedded rd document */
13676             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13677 #ifdef RIPPER
13678                 int first_p = TRUE;
13679 
13680                 lex_goto_eol(parser);
13681                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13682 #endif
13683                 for (;;) {
13684                     lex_goto_eol(parser);
13685 #ifdef RIPPER
13686                     if (!first_p) {
13687                         ripper_dispatch_scan_event(parser, tEMBDOC);
13688                     }
13689                     first_p = FALSE;
13690 #endif
13691                     c = nextc();
13692                     if (c == -1) {
13693                         compile_error(PARSER_ARG "embedded document meets end of file");
13694                         return 0;
13695                     }
13696                     if (c != '=') continue;
13697                     if (strncmp(lex_p, "end", 3) == 0 &&
13698                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13699                         break;
13700                     }
13701                 }
13702                 lex_goto_eol(parser);
13703 #ifdef RIPPER
13704                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
13705 #endif
13706                 goto retry;
13707             }
13708         }
13709 
13710         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13711         if ((c = nextc()) == '=') {
13712             if ((c = nextc()) == '=') {
13713                 return tEQQ;
13714             }
13715             pushback(c);
13716             return tEQ;
13717         }
13718         if (c == '~') {
13719             return tMATCH;
13720         }
13721         else if (c == '>') {
13722             return tASSOC;
13723         }
13724         pushback(c);
13725         return '=';
13726 
13727       case '<':
13728         last_state = lex_state;
13729         c = nextc();
13730         if (c == '<' &&
13731             !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13732             !IS_END() &&
13733             (!IS_ARG() || space_seen)) {
13734             int token = heredoc_identifier();
13735             if (token) return token;
13736         }
13737         if (IS_AFTER_OPERATOR()) {
13738             lex_state = EXPR_ARG;
13739         }
13740         else {
13741             if (IS_lex_state(EXPR_CLASS))
13742                 command_start = TRUE;
13743             lex_state = EXPR_BEG;
13744         }
13745         if (c == '=') {
13746             if ((c = nextc()) == '>') {
13747                 return tCMP;
13748             }
13749             pushback(c);
13750             return tLEQ;
13751         }
13752         if (c == '<') {
13753             if ((c = nextc()) == '=') {
13754                 set_yylval_id(tLSHFT);
13755                 lex_state = EXPR_BEG;
13756                 return tOP_ASGN;
13757             }
13758             pushback(c);
13759             warn_balanced("<<", "here document");
13760             return tLSHFT;
13761         }
13762         pushback(c);
13763         return '<';
13764 
13765       case '>':
13766         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13767         if ((c = nextc()) == '=') {
13768             return tGEQ;
13769         }
13770         if (c == '>') {
13771             if ((c = nextc()) == '=') {
13772                 set_yylval_id(tRSHFT);
13773                 lex_state = EXPR_BEG;
13774                 return tOP_ASGN;
13775             }
13776             pushback(c);
13777             return tRSHFT;
13778         }
13779         pushback(c);
13780         return '>';
13781 
13782       case '"':
13783         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13784         return tSTRING_BEG;
13785 
13786       case '`':
13787         if (IS_lex_state(EXPR_FNAME)) {
13788             lex_state = EXPR_ENDFN;
13789             return c;
13790         }
13791         if (IS_lex_state(EXPR_DOT)) {
13792             if (cmd_state)
13793                 lex_state = EXPR_CMDARG;
13794             else
13795                 lex_state = EXPR_ARG;
13796             return c;
13797         }
13798         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13799         return tXSTRING_BEG;
13800 
13801       case '\'':
13802         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13803         return tSTRING_BEG;
13804 
13805       case '?':
13806         if (IS_END()) {
13807             lex_state = EXPR_VALUE;
13808             return '?';
13809         }
13810         c = nextc();
13811         if (c == -1) {
13812             compile_error(PARSER_ARG "incomplete character syntax");
13813             return 0;
13814         }
13815         if (rb_enc_isspace(c, current_enc)) {
13816             if (!IS_ARG()) {
13817                 int c2 = 0;
13818                 switch (c) {
13819                   case ' ':
13820                     c2 = 's';
13821                     break;
13822                   case '\n':
13823                     c2 = 'n';
13824                     break;
13825                   case '\t':
13826                     c2 = 't';
13827                     break;
13828                   case '\v':
13829                     c2 = 'v';
13830                     break;
13831                   case '\r':
13832                     c2 = 'r';
13833                     break;
13834                   case '\f':
13835                     c2 = 'f';
13836                     break;
13837                 }
13838                 if (c2) {
13839                     rb_warnI("invalid character syntax; use ?\\%c", c2);
13840                 }
13841             }
13842           ternary:
13843             pushback(c);
13844             lex_state = EXPR_VALUE;
13845             return '?';
13846         }
13847         newtok();
13848         enc = current_enc;
13849         if (!parser_isascii()) {
13850             if (tokadd_mbchar(c) == -1) return 0;
13851         }
13852         else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13853                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13854             goto ternary;
13855         }
13856         else if (c == '\\') {
13857             if (peek('u')) {
13858                 nextc();
13859                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13860                 if (0x80 <= c) {
13861                     tokaddmbc(c, enc);
13862                 }
13863                 else {
13864                     tokadd(c);
13865                 }
13866             }
13867             else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13868                 nextc();
13869                 if (tokadd_mbchar(c) == -1) return 0;
13870             }
13871             else {
13872                 c = read_escape(0, &enc);
13873                 tokadd(c);
13874             }
13875         }
13876         else {
13877             tokadd(c);
13878         }
13879         tokfix();
13880         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13881         lex_state = EXPR_END;
13882         return tCHAR;
13883 
13884       case '&':
13885         if ((c = nextc()) == '&') {
13886             lex_state = EXPR_BEG;
13887             if ((c = nextc()) == '=') {
13888                 set_yylval_id(tANDOP);
13889                 lex_state = EXPR_BEG;
13890                 return tOP_ASGN;
13891             }
13892             pushback(c);
13893             return tANDOP;
13894         }
13895         else if (c == '=') {
13896             set_yylval_id('&');
13897             lex_state = EXPR_BEG;
13898             return tOP_ASGN;
13899         }
13900         pushback(c);
13901         if (IS_SPCARG(c)) {
13902             rb_warning0("`&' interpreted as argument prefix");
13903             c = tAMPER;
13904         }
13905         else if (IS_BEG()) {
13906             c = tAMPER;
13907         }
13908         else {
13909             warn_balanced("&", "argument prefix");
13910             c = '&';
13911         }
13912         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13913         return c;
13914 
13915       case '|':
13916         if ((c = nextc()) == '|') {
13917             lex_state = EXPR_BEG;
13918             if ((c = nextc()) == '=') {
13919                 set_yylval_id(tOROP);
13920                 lex_state = EXPR_BEG;
13921                 return tOP_ASGN;
13922             }
13923             pushback(c);
13924             return tOROP;
13925         }
13926         if (c == '=') {
13927             set_yylval_id('|');
13928             lex_state = EXPR_BEG;
13929             return tOP_ASGN;
13930         }
13931         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13932         pushback(c);
13933         return '|';
13934 
13935       case '+':
13936         c = nextc();
13937         if (IS_AFTER_OPERATOR()) {
13938             lex_state = EXPR_ARG;
13939             if (c == '@') {
13940                 return tUPLUS;
13941             }
13942             pushback(c);
13943             return '+';
13944         }
13945         if (c == '=') {
13946             set_yylval_id('+');
13947             lex_state = EXPR_BEG;
13948             return tOP_ASGN;
13949         }
13950         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13951             lex_state = EXPR_BEG;
13952             pushback(c);
13953             if (c != -1 && ISDIGIT(c)) {
13954                 c = '+';
13955                 goto start_num;
13956             }
13957             return tUPLUS;
13958         }
13959         lex_state = EXPR_BEG;
13960         pushback(c);
13961         warn_balanced("+", "unary operator");
13962         return '+';
13963 
13964       case '-':
13965         c = nextc();
13966         if (IS_AFTER_OPERATOR()) {
13967             lex_state = EXPR_ARG;
13968             if (c == '@') {
13969                 return tUMINUS;
13970             }
13971             pushback(c);
13972             return '-';
13973         }
13974         if (c == '=') {
13975             set_yylval_id('-');
13976             lex_state = EXPR_BEG;
13977             return tOP_ASGN;
13978         }
13979         if (c == '>') {
13980             lex_state = EXPR_ENDFN;
13981             return tLAMBDA;
13982         }
13983         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13984             lex_state = EXPR_BEG;
13985             pushback(c);
13986             if (c != -1 && ISDIGIT(c)) {
13987                 return tUMINUS_NUM;
13988             }
13989             return tUMINUS;
13990         }
13991         lex_state = EXPR_BEG;
13992         pushback(c);
13993         warn_balanced("-", "unary operator");
13994         return '-';
13995 
13996       case '.':
13997         lex_state = EXPR_BEG;
13998         if ((c = nextc()) == '.') {
13999             if ((c = nextc()) == '.') {
14000                 return tDOT3;
14001             }
14002             pushback(c);
14003             return tDOT2;
14004         }
14005         pushback(c);
14006         if (c != -1 && ISDIGIT(c)) {
14007             yyerror("no .<digit> floating literal anymore; put 0 before dot");
14008         }
14009         lex_state = EXPR_DOT;
14010         return '.';
14011 
14012       start_num:
14013       case '0': case '1': case '2': case '3': case '4':
14014       case '5': case '6': case '7': case '8': case '9':
14015         {
14016             int is_float, seen_point, seen_e, nondigit;
14017             int suffix;
14018 
14019             is_float = seen_point = seen_e = nondigit = 0;
14020             lex_state = EXPR_END;
14021             newtok();
14022             if (c == '-' || c == '+') {
14023                 tokadd(c);
14024                 c = nextc();
14025             }
14026             if (c == '0') {
14027 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
14028                 int start = toklen();
14029                 c = nextc();
14030                 if (c == 'x' || c == 'X') {
14031                     /* hexadecimal */
14032                     c = nextc();
14033                     if (c != -1 && ISXDIGIT(c)) {
14034                         do {
14035                             if (c == '_') {
14036                                 if (nondigit) break;
14037                                 nondigit = c;
14038                                 continue;
14039                             }
14040                             if (!ISXDIGIT(c)) break;
14041                             nondigit = 0;
14042                             tokadd(c);
14043                         } while ((c = nextc()) != -1);
14044                     }
14045                     pushback(c);
14046                     tokfix();
14047                     if (toklen() == start) {
14048                         no_digits();
14049                     }
14050                     else if (nondigit) goto trailing_uc;
14051                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14052                     return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
14053                 }
14054                 if (c == 'b' || c == 'B') {
14055                     /* binary */
14056                     c = nextc();
14057                     if (c == '0' || c == '1') {
14058                         do {
14059                             if (c == '_') {
14060                                 if (nondigit) break;
14061                                 nondigit = c;
14062                                 continue;
14063                             }
14064                             if (c != '0' && c != '1') break;
14065                             nondigit = 0;
14066                             tokadd(c);
14067                         } while ((c = nextc()) != -1);
14068                     }
14069                     pushback(c);
14070                     tokfix();
14071                     if (toklen() == start) {
14072                         no_digits();
14073                     }
14074                     else if (nondigit) goto trailing_uc;
14075                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14076                     return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
14077                 }
14078                 if (c == 'd' || c == 'D') {
14079                     /* decimal */
14080                     c = nextc();
14081                     if (c != -1 && ISDIGIT(c)) {
14082                         do {
14083                             if (c == '_') {
14084                                 if (nondigit) break;
14085                                 nondigit = c;
14086                                 continue;
14087                             }
14088                             if (!ISDIGIT(c)) break;
14089                             nondigit = 0;
14090                             tokadd(c);
14091                         } while ((c = nextc()) != -1);
14092                     }
14093                     pushback(c);
14094                     tokfix();
14095                     if (toklen() == start) {
14096                         no_digits();
14097                     }
14098                     else if (nondigit) goto trailing_uc;
14099                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14100                     return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14101                 }
14102                 if (c == '_') {
14103                     /* 0_0 */
14104                     goto octal_number;
14105                 }
14106                 if (c == 'o' || c == 'O') {
14107                     /* prefixed octal */
14108                     c = nextc();
14109                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
14110                         no_digits();
14111                     }
14112                 }
14113                 if (c >= '0' && c <= '7') {
14114                     /* octal */
14115                   octal_number:
14116                     do {
14117                         if (c == '_') {
14118                             if (nondigit) break;
14119                             nondigit = c;
14120                             continue;
14121                         }
14122                         if (c < '0' || c > '9') break;
14123                         if (c > '7') goto invalid_octal;
14124                         nondigit = 0;
14125                         tokadd(c);
14126                     } while ((c = nextc()) != -1);
14127                     if (toklen() > start) {
14128                         pushback(c);
14129                         tokfix();
14130                         if (nondigit) goto trailing_uc;
14131                         suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14132                         return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
14133                     }
14134                     if (nondigit) {
14135                         pushback(c);
14136                         goto trailing_uc;
14137                     }
14138                 }
14139                 if (c > '7' && c <= '9') {
14140                   invalid_octal:
14141                     yyerror("Invalid octal digit");
14142                 }
14143                 else if (c == '.' || c == 'e' || c == 'E') {
14144                     tokadd('0');
14145                 }
14146                 else {
14147                     pushback(c);
14148                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14149                     return set_integer_literal(INT2FIX(0), suffix);
14150                 }
14151             }
14152 
14153             for (;;) {
14154                 switch (c) {
14155                   case '0': case '1': case '2': case '3': case '4':
14156                   case '5': case '6': case '7': case '8': case '9':
14157                     nondigit = 0;
14158                     tokadd(c);
14159                     break;
14160 
14161                   case '.':
14162                     if (nondigit) goto trailing_uc;
14163                     if (seen_point || seen_e) {
14164                         goto decode_num;
14165                     }
14166                     else {
14167                         int c0 = nextc();
14168                         if (c0 == -1 || !ISDIGIT(c0)) {
14169                             pushback(c0);
14170                             goto decode_num;
14171                         }
14172                         c = c0;
14173                     }
14174                     seen_point = toklen();
14175                     tokadd('.');
14176                     tokadd(c);
14177                     is_float++;
14178                     nondigit = 0;
14179                     break;
14180 
14181                   case 'e':
14182                   case 'E':
14183                     if (nondigit) {
14184                         pushback(c);
14185                         c = nondigit;
14186                         goto decode_num;
14187                     }
14188                     if (seen_e) {
14189                         goto decode_num;
14190                     }
14191                     nondigit = c;
14192                     c = nextc();
14193                     if (c != '-' && c != '+' && !ISDIGIT(c)) {
14194                         pushback(c);
14195                         nondigit = 0;
14196                         goto decode_num;
14197                     }
14198                     tokadd(nondigit);
14199                     seen_e++;
14200                     is_float++;
14201                     tokadd(c);
14202                     nondigit = (c == '-' || c == '+') ? c : 0;
14203                     break;
14204 
14205                   case '_':     /* `_' in number just ignored */
14206                     if (nondigit) goto decode_num;
14207                     nondigit = c;
14208                     break;
14209 
14210                   default:
14211                     goto decode_num;
14212                 }
14213                 c = nextc();
14214             }
14215 
14216           decode_num:
14217             pushback(c);
14218             if (nondigit) {
14219                 char tmp[30];
14220               trailing_uc:
14221                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14222                 yyerror(tmp);
14223             }
14224             tokfix();
14225             if (is_float) {
14226                 int type = tFLOAT;
14227                 VALUE v;
14228 
14229                 suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
14230                 if (suffix & NUM_SUFFIX_R) {
14231                     char *point = &tok()[seen_point];
14232                     size_t fraclen = toklen()-seen_point-1;
14233                     type = tRATIONAL;
14234                     memmove(point, point+1, fraclen+1);
14235                     v = rb_cstr_to_inum(tok(), 10, FALSE);
14236                     v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14237                 }
14238                 else {
14239                     double d = strtod(tok(), 0);
14240                     if (errno == ERANGE) {
14241                         rb_warningS("Float %s out of range", tok());
14242                         errno = 0;
14243                     }
14244                     v = DBL2NUM(d);
14245                 }
14246                 return set_number_literal(v, type, suffix);
14247             }
14248             suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14249             return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14250         }
14251 
14252       case ')':
14253       case ']':
14254         paren_nest--;
14255       case '}':
14256         COND_LEXPOP();
14257         CMDARG_LEXPOP();
14258         if (c == ')')
14259             lex_state = EXPR_ENDFN;
14260         else
14261             lex_state = EXPR_ENDARG;
14262         if (c == '}') {
14263             if (!brace_nest--) c = tSTRING_DEND;
14264         }
14265         return c;
14266 
14267       case ':':
14268         c = nextc();
14269         if (c == ':') {
14270             if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14271                 lex_state = EXPR_BEG;
14272                 return tCOLON3;
14273             }
14274             lex_state = EXPR_DOT;
14275             return tCOLON2;
14276         }
14277         if (IS_END() || ISSPACE(c)) {
14278             pushback(c);
14279             warn_balanced(":", "symbol literal");
14280             lex_state = EXPR_BEG;
14281             return ':';
14282         }
14283         switch (c) {
14284           case '\'':
14285             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14286             break;
14287           case '"':
14288             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14289             break;
14290           default:
14291             pushback(c);
14292             break;
14293         }
14294         lex_state = EXPR_FNAME;
14295         return tSYMBEG;
14296 
14297       case '/':
14298         if (IS_lex_state(EXPR_BEG_ANY)) {
14299             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14300             return tREGEXP_BEG;
14301         }
14302         if ((c = nextc()) == '=') {
14303             set_yylval_id('/');
14304             lex_state = EXPR_BEG;
14305             return tOP_ASGN;
14306         }
14307         pushback(c);
14308         if (IS_SPCARG(c)) {
14309             (void)arg_ambiguous();
14310             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14311             return tREGEXP_BEG;
14312         }
14313         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14314         warn_balanced("/", "regexp literal");
14315         return '/';
14316 
14317       case '^':
14318         if ((c = nextc()) == '=') {
14319             set_yylval_id('^');
14320             lex_state = EXPR_BEG;
14321             return tOP_ASGN;
14322         }
14323         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14324         pushback(c);
14325         return '^';
14326 
14327       case ';':
14328         lex_state = EXPR_BEG;
14329         command_start = TRUE;
14330         return ';';
14331 
14332       case ',':
14333         lex_state = EXPR_BEG;
14334         return ',';
14335 
14336       case '~':
14337         if (IS_AFTER_OPERATOR()) {
14338             if ((c = nextc()) != '@') {
14339                 pushback(c);
14340             }
14341             lex_state = EXPR_ARG;
14342         }
14343         else {
14344             lex_state = EXPR_BEG;
14345         }
14346         return '~';
14347 
14348       case '(':
14349         if (IS_BEG()) {
14350             c = tLPAREN;
14351         }
14352         else if (IS_SPCARG(-1)) {
14353             c = tLPAREN_ARG;
14354         }
14355         paren_nest++;
14356         COND_PUSH(0);
14357         CMDARG_PUSH(0);
14358         lex_state = EXPR_BEG;
14359         return c;
14360 
14361       case '[':
14362         paren_nest++;
14363         if (IS_AFTER_OPERATOR()) {
14364             lex_state = EXPR_ARG;
14365             if ((c = nextc()) == ']') {
14366                 if ((c = nextc()) == '=') {
14367                     return tASET;
14368                 }
14369                 pushback(c);
14370                 return tAREF;
14371             }
14372             pushback(c);
14373             return '[';
14374         }
14375         else if (IS_BEG()) {
14376             c = tLBRACK;
14377         }
14378         else if (IS_ARG() && space_seen) {
14379             c = tLBRACK;
14380         }
14381         lex_state = EXPR_BEG;
14382         COND_PUSH(0);
14383         CMDARG_PUSH(0);
14384         return c;
14385 
14386       case '{':
14387         ++brace_nest;
14388         if (lpar_beg && lpar_beg == paren_nest) {
14389             lex_state = EXPR_BEG;
14390             lpar_beg = 0;
14391             --paren_nest;
14392             COND_PUSH(0);
14393             CMDARG_PUSH(0);
14394             return tLAMBEG;
14395         }
14396         if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14397             c = '{';          /* block (primary) */
14398         else if (IS_lex_state(EXPR_ENDARG))
14399             c = tLBRACE_ARG;  /* block (expr) */
14400         else
14401             c = tLBRACE;      /* hash */
14402         COND_PUSH(0);
14403         CMDARG_PUSH(0);
14404         lex_state = EXPR_BEG;
14405         if (c != tLBRACE) command_start = TRUE;
14406         return c;
14407 
14408       case '\\':
14409         c = nextc();
14410         if (c == '\n') {
14411             space_seen = 1;
14412 #ifdef RIPPER
14413             ripper_dispatch_scan_event(parser, tSP);
14414 #endif
14415             goto retry; /* skip \\n */
14416         }
14417         pushback(c);
14418         return '\\';
14419 
14420       case '%':
14421         if (IS_lex_state(EXPR_BEG_ANY)) {
14422             int term;
14423             int paren;
14424 
14425             c = nextc();
14426           quotation:
14427             if (c == -1 || !ISALNUM(c)) {
14428                 term = c;
14429                 c = 'Q';
14430             }
14431             else {
14432                 term = nextc();
14433                 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14434                     yyerror("unknown type of %string");
14435                     return 0;
14436                 }
14437             }
14438             if (c == -1 || term == -1) {
14439                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14440                 return 0;
14441             }
14442             paren = term;
14443             if (term == '(') term = ')';
14444             else if (term == '[') term = ']';
14445             else if (term == '{') term = '}';
14446             else if (term == '<') term = '>';
14447             else paren = 0;
14448 
14449             switch (c) {
14450               case 'Q':
14451                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14452                 return tSTRING_BEG;
14453 
14454               case 'q':
14455                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
14456                 return tSTRING_BEG;
14457 
14458               case 'W':
14459                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14460                 do {c = nextc();} while (ISSPACE(c));
14461                 pushback(c);
14462                 return tWORDS_BEG;
14463 
14464               case 'w':
14465                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14466                 do {c = nextc();} while (ISSPACE(c));
14467                 pushback(c);
14468                 return tQWORDS_BEG;
14469 
14470               case 'I':
14471                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14472                 do {c = nextc();} while (ISSPACE(c));
14473                 pushback(c);
14474                 return tSYMBOLS_BEG;
14475 
14476               case 'i':
14477                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14478                 do {c = nextc();} while (ISSPACE(c));
14479                 pushback(c);
14480                 return tQSYMBOLS_BEG;
14481 
14482               case 'x':
14483                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14484                 return tXSTRING_BEG;
14485 
14486               case 'r':
14487                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14488                 return tREGEXP_BEG;
14489 
14490               case 's':
14491                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14492                 lex_state = EXPR_FNAME;
14493                 return tSYMBEG;
14494 
14495               default:
14496                 yyerror("unknown type of %string");
14497                 return 0;
14498             }
14499         }
14500         if ((c = nextc()) == '=') {
14501             set_yylval_id('%');
14502             lex_state = EXPR_BEG;
14503             return tOP_ASGN;
14504         }
14505         if (IS_SPCARG(c)) {
14506             goto quotation;
14507         }
14508         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14509         pushback(c);
14510         warn_balanced("%%", "string literal");
14511         return '%';
14512 
14513       case '$':
14514         lex_state = EXPR_END;
14515         newtok();
14516         c = nextc();
14517         switch (c) {
14518           case '_':             /* $_: last read line string */
14519             c = nextc();
14520             if (parser_is_identchar()) {
14521                 tokadd('$');
14522                 tokadd('_');
14523                 break;
14524             }
14525             pushback(c);
14526             c = '_';
14527             /* fall through */
14528           case '~':             /* $~: match-data */
14529           case '*':             /* $*: argv */
14530           case '$':             /* $$: pid */
14531           case '?':             /* $?: last status */
14532           case '!':             /* $!: error string */
14533           case '@':             /* $@: error position */
14534           case '/':             /* $/: input record separator */
14535           case '\\':            /* $\: output record separator */
14536           case ';':             /* $;: field separator */
14537           case ',':             /* $,: output field separator */
14538           case '.':             /* $.: last read line number */
14539           case '=':             /* $=: ignorecase */
14540           case ':':             /* $:: load path */
14541           case '<':             /* $<: reading filename */
14542           case '>':             /* $>: default output handle */
14543           case '\"':            /* $": already loaded files */
14544             tokadd('$');
14545             tokadd(c);
14546             goto gvar;
14547 
14548           case '-':
14549             tokadd('$');
14550             tokadd(c);
14551             c = nextc();
14552             if (parser_is_identchar()) {
14553                 if (tokadd_mbchar(c) == -1) return 0;
14554             }
14555             else {
14556                 pushback(c);
14557                 pushback('-');
14558                 return '$';
14559             }
14560           gvar:
14561             set_yylval_name(rb_intern3(tok(), tokidx, current_enc));
14562             return tGVAR;
14563 
14564           case '&':             /* $&: last match */
14565           case '`':             /* $`: string before last match */
14566           case '\'':            /* $': string after last match */
14567           case '+':             /* $+: string matches last paren. */
14568             if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14569                 tokadd('$');
14570                 tokadd(c);
14571                 goto gvar;
14572             }
14573             set_yylval_node(NEW_BACK_REF(c));
14574             return tBACK_REF;
14575 
14576           case '1': case '2': case '3':
14577           case '4': case '5': case '6':
14578           case '7': case '8': case '9':
14579             tokadd('$');
14580             do {
14581                 tokadd(c);
14582                 c = nextc();
14583             } while (c != -1 && ISDIGIT(c));
14584             pushback(c);
14585             if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14586             tokfix();
14587             set_yylval_node(NEW_NTH_REF(parse_numvar(parser)));
14588             return tNTH_REF;
14589 
14590           default:
14591             if (!parser_is_identchar()) {
14592                 pushback(c);
14593                 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14594                 return 0;
14595             }
14596           case '0':
14597             tokadd('$');
14598         }
14599         break;
14600 
14601       case '@':
14602         c = nextc();
14603         newtok();
14604         tokadd('@');
14605         if (c == '@') {
14606             tokadd('@');
14607             c = nextc();
14608         }
14609         if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14610             pushback(c);
14611             if (tokidx == 1) {
14612                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14613             }
14614             else {
14615                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14616             }
14617             return 0;
14618         }
14619         break;
14620 
14621       case '_':
14622         if (was_bol() && whole_match_p("__END__", 7, 0)) {
14623             ruby__end__seen = 1;
14624             parser->eofp = Qtrue;
14625 #ifndef RIPPER
14626             return -1;
14627 #else
14628             lex_goto_eol(parser);
14629             ripper_dispatch_scan_event(parser, k__END__);
14630             return 0;
14631 #endif
14632         }
14633         newtok();
14634         break;
14635 
14636       default:
14637         if (!parser_is_identchar()) {
14638             compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
14639             goto retry;
14640         }
14641 
14642         newtok();
14643         break;
14644     }
14645 
14646     mb = ENC_CODERANGE_7BIT;
14647     do {
14648         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14649         if (tokadd_mbchar(c) == -1) return 0;
14650         c = nextc();
14651     } while (parser_is_identchar());
14652     switch (tok()[0]) {
14653       case '@': case '$':
14654         pushback(c);
14655         break;
14656       default:
14657         if ((c == '!' || c == '?') && !peek('=')) {
14658             tokadd(c);
14659         }
14660         else {
14661             pushback(c);
14662         }
14663     }
14664     tokfix();
14665 
14666     {
14667         int result = 0;
14668 
14669         last_state = lex_state;
14670         switch (tok()[0]) {
14671           case '$':
14672             lex_state = EXPR_END;
14673             result = tGVAR;
14674             break;
14675           case '@':
14676             lex_state = EXPR_END;
14677             if (tok()[1] == '@')
14678                 result = tCVAR;
14679             else
14680                 result = tIVAR;
14681             break;
14682 
14683           default:
14684             if (toklast() == '!' || toklast() == '?') {
14685                 result = tFID;
14686             }
14687             else {
14688                 if (IS_lex_state(EXPR_FNAME)) {
14689                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14690                         (!peek('=') || (peek_n('>', 1)))) {
14691                         result = tIDENTIFIER;
14692                         tokadd(c);
14693                         tokfix();
14694                     }
14695                     else {
14696                         pushback(c);
14697                     }
14698                 }
14699                 if (result == 0 && ISUPPER(tok()[0])) {
14700                     result = tCONSTANT;
14701                 }
14702                 else {
14703                     result = tIDENTIFIER;
14704                 }
14705             }
14706 
14707             if (IS_LABEL_POSSIBLE()) {
14708                 if (IS_LABEL_SUFFIX(0)) {
14709                     lex_state = EXPR_LABELARG;
14710                     nextc();
14711                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
14712                     return tLABEL;
14713                 }
14714             }
14715             if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14716                 const struct kwtable *kw;
14717 
14718                 /* See if it is a reserved word.  */
14719                 kw = rb_reserved_word(tok(), toklen());
14720                 if (kw) {
14721                     enum lex_state_e state = lex_state;
14722                     lex_state = kw->state;
14723                     if (IS_lex_state_for(state, EXPR_FNAME)) {
14724                         set_yylval_name(rb_intern(kw->name));
14725                         return kw->id[0];
14726                     }
14727                     if (IS_lex_state(EXPR_BEG)) {
14728                         command_start = TRUE;
14729                     }
14730                     if (kw->id[0] == keyword_do) {
14731                         if (lpar_beg && lpar_beg == paren_nest) {
14732                             lpar_beg = 0;
14733                             --paren_nest;
14734                             return keyword_do_LAMBDA;
14735                         }
14736                         if (COND_P()) return keyword_do_cond;
14737                         if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14738                             return keyword_do_block;
14739                         if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14740                             return keyword_do_block;
14741                         return keyword_do;
14742                     }
14743                     if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG)))
14744                         return kw->id[0];
14745                     else {
14746                         if (kw->id[0] != kw->id[1])
14747                             lex_state = EXPR_BEG;
14748                         return kw->id[1];
14749                     }
14750                 }
14751             }
14752 
14753             if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14754                 if (cmd_state) {
14755                     lex_state = EXPR_CMDARG;
14756                 }
14757                 else {
14758                     lex_state = EXPR_ARG;
14759                 }
14760             }
14761             else if (lex_state == EXPR_FNAME) {
14762                 lex_state = EXPR_ENDFN;
14763             }
14764             else {
14765                 lex_state = EXPR_END;
14766             }
14767         }
14768         {
14769             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14770 
14771             set_yylval_name(ident);
14772             if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14773                 is_local_id(ident) && lvar_defined(ident)) {
14774                 lex_state = EXPR_END;
14775             }
14776         }
14777         return result;
14778     }
14779 }
14780 
14781 #if YYPURE
14782 static int
14783 yylex(void *lval, void *p)
14784 #else
14785 yylex(void *p)
14786 #endif
14787 {
14788     struct parser_params *parser = (struct parser_params*)p;
14789     int t;
14790 
14791 #if YYPURE
14792     parser->parser_yylval = lval;
14793     parser->parser_yylval->val = Qundef;
14794 #endif
14795     t = parser_yylex(parser);
14796 #ifdef RIPPER
14797     if (!NIL_P(parser->delayed)) {
14798         ripper_dispatch_delayed_token(parser, t);
14799         return t;
14800     }
14801     if (t != 0)
14802         ripper_dispatch_scan_event(parser, t);
14803 #endif
14804 
14805     return t;
14806 }
14807 
14808 #ifndef RIPPER
14809 static NODE*
14810 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14811 {
14812     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14813     nd_set_line(n, ruby_sourceline);
14814     return n;
14815 }
14816 
14817 static enum node_type
14818 nodetype(NODE *node)                    /* for debug */
14819 {
14820     return (enum node_type)nd_type(node);
14821 }
14822 
14823 static int
14824 nodeline(NODE *node)
14825 {
14826     return nd_line(node);
14827 }
14828 
14829 static NODE*
14830 newline_node(NODE *node)
14831 {
14832     if (node) {
14833         node = remove_begin(node);
14834         node->flags |= NODE_FL_NEWLINE;
14835     }
14836     return node;
14837 }
14838 
14839 static void
14840 fixpos(NODE *node, NODE *orig)
14841 {
14842     if (!node) return;
14843     if (!orig) return;
14844     if (orig == (NODE*)1) return;
14845     nd_set_line(node, nd_line(orig));
14846 }
14847 
14848 static void
14849 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14850 {
14851     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14852 }
14853 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14854 
14855 static void
14856 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14857 {
14858     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14859 }
14860 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14861 
14862 static NODE*
14863 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14864 {
14865     NODE *end, *h = head, *nd;
14866 
14867     if (tail == 0) return head;
14868 
14869     if (h == 0) return tail;
14870     switch (nd_type(h)) {
14871       case NODE_LIT:
14872       case NODE_STR:
14873       case NODE_SELF:
14874       case NODE_TRUE:
14875       case NODE_FALSE:
14876       case NODE_NIL:
14877         parser_warning(h, "unused literal ignored");
14878         return tail;
14879       default:
14880         h = end = NEW_BLOCK(head);
14881         end->nd_end = end;
14882         fixpos(end, head);
14883         head = end;
14884         break;
14885       case NODE_BLOCK:
14886         end = h->nd_end;
14887         break;
14888     }
14889 
14890     nd = end->nd_head;
14891     switch (nd_type(nd)) {
14892       case NODE_RETURN:
14893       case NODE_BREAK:
14894       case NODE_NEXT:
14895       case NODE_REDO:
14896       case NODE_RETRY:
14897         if (RTEST(ruby_verbose)) {
14898             parser_warning(tail, "statement not reached");
14899         }
14900         break;
14901 
14902       default:
14903         break;
14904     }
14905 
14906     if (nd_type(tail) != NODE_BLOCK) {
14907         tail = NEW_BLOCK(tail);
14908         tail->nd_end = tail;
14909     }
14910     end->nd_next = tail;
14911     h->nd_end = tail->nd_end;
14912     return head;
14913 }
14914 
14915 /* append item to the list */
14916 static NODE*
14917 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14918 {
14919     NODE *last;
14920 
14921     if (list == 0) return NEW_LIST(item);
14922     if (list->nd_next) {
14923         last = list->nd_next->nd_end;
14924     }
14925     else {
14926         last = list;
14927     }
14928 
14929     list->nd_alen += 1;
14930     last->nd_next = NEW_LIST(item);
14931     list->nd_next->nd_end = last->nd_next;
14932     return list;
14933 }
14934 
14935 /* concat two lists */
14936 static NODE*
14937 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14938 {
14939     NODE *last;
14940 
14941     if (head->nd_next) {
14942         last = head->nd_next->nd_end;
14943     }
14944     else {
14945         last = head;
14946     }
14947 
14948     head->nd_alen += tail->nd_alen;
14949     last->nd_next = tail;
14950     if (tail->nd_next) {
14951         head->nd_next->nd_end = tail->nd_next->nd_end;
14952     }
14953     else {
14954         head->nd_next->nd_end = tail;
14955     }
14956 
14957     return head;
14958 }
14959 
14960 static int
14961 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14962 {
14963     if (NIL_P(tail)) return 1;
14964     if (!rb_enc_compatible(head, tail)) {
14965         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14966                       rb_enc_name(rb_enc_get(head)),
14967                       rb_enc_name(rb_enc_get(tail)));
14968         rb_str_resize(head, 0);
14969         rb_str_resize(tail, 0);
14970         return 0;
14971     }
14972     rb_str_buf_append(head, tail);
14973     return 1;
14974 }
14975 
14976 /* concat two string literals */
14977 static NODE *
14978 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14979 {
14980     enum node_type htype;
14981     NODE *headlast;
14982     VALUE lit;
14983 
14984     if (!head) return tail;
14985     if (!tail) return head;
14986 
14987     htype = nd_type(head);
14988     if (htype == NODE_EVSTR) {
14989         NODE *node = NEW_DSTR(STR_NEW0());
14990         head = list_append(node, head);
14991         htype = NODE_DSTR;
14992     }
14993     switch (nd_type(tail)) {
14994       case NODE_STR:
14995         if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14996             nd_type(headlast) == NODE_STR) {
14997             htype = NODE_STR;
14998             lit = headlast->nd_lit;
14999         }
15000         else {
15001             lit = head->nd_lit;
15002         }
15003         if (htype == NODE_STR) {
15004             if (!literal_concat0(parser, lit, tail->nd_lit)) {
15005               error:
15006                 rb_gc_force_recycle((VALUE)head);
15007                 rb_gc_force_recycle((VALUE)tail);
15008                 return 0;
15009             }
15010             rb_gc_force_recycle((VALUE)tail);
15011         }
15012         else {
15013             list_append(head, tail);
15014         }
15015         break;
15016 
15017       case NODE_DSTR:
15018         if (htype == NODE_STR) {
15019             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
15020                 goto error;
15021             tail->nd_lit = head->nd_lit;
15022             rb_gc_force_recycle((VALUE)head);
15023             head = tail;
15024         }
15025         else if (NIL_P(tail->nd_lit)) {
15026           append:
15027             head->nd_alen += tail->nd_alen - 1;
15028             head->nd_next->nd_end->nd_next = tail->nd_next;
15029             head->nd_next->nd_end = tail->nd_next->nd_end;
15030             rb_gc_force_recycle((VALUE)tail);
15031         }
15032         else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15033                  nd_type(headlast) == NODE_STR) {
15034             lit = headlast->nd_lit;
15035             if (!literal_concat0(parser, lit, tail->nd_lit))
15036                 goto error;
15037             tail->nd_lit = Qnil;
15038             goto append;
15039         }
15040         else {
15041             nd_set_type(tail, NODE_ARRAY);
15042             tail->nd_head = NEW_STR(tail->nd_lit);
15043             list_concat(head, tail);
15044         }
15045         break;
15046 
15047       case NODE_EVSTR:
15048         if (htype == NODE_STR) {
15049             nd_set_type(head, NODE_DSTR);
15050             head->nd_alen = 1;
15051         }
15052         list_append(head, tail);
15053         break;
15054     }
15055     return head;
15056 }
15057 
15058 static NODE *
15059 evstr2dstr_gen(struct parser_params *parser, NODE *node)
15060 {
15061     if (nd_type(node) == NODE_EVSTR) {
15062         node = list_append(NEW_DSTR(STR_NEW0()), node);
15063     }
15064     return node;
15065 }
15066 
15067 static NODE *
15068 new_evstr_gen(struct parser_params *parser, NODE *node)
15069 {
15070     NODE *head = node;
15071 
15072     if (node) {
15073         switch (nd_type(node)) {
15074           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15075             return node;
15076         }
15077     }
15078     return NEW_EVSTR(head);
15079 }
15080 
15081 static NODE *
15082 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
15083 {
15084     value_expr(recv);
15085     value_expr(arg1);
15086     return NEW_CALL(recv, id, NEW_LIST(arg1));
15087 }
15088 
15089 static NODE *
15090 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15091 {
15092     value_expr(recv);
15093     return NEW_CALL(recv, id, 0);
15094 }
15095 
15096 static NODE*
15097 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15098 {
15099     value_expr(node1);
15100     value_expr(node2);
15101     if (node1) {
15102         switch (nd_type(node1)) {
15103           case NODE_DREGX:
15104           case NODE_DREGX_ONCE:
15105             return NEW_MATCH2(node1, node2);
15106 
15107           case NODE_LIT:
15108             if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15109                 return NEW_MATCH2(node1, node2);
15110             }
15111         }
15112     }
15113 
15114     if (node2) {
15115         switch (nd_type(node2)) {
15116           case NODE_DREGX:
15117           case NODE_DREGX_ONCE:
15118             return NEW_MATCH3(node2, node1);
15119 
15120           case NODE_LIT:
15121             if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15122                 return NEW_MATCH3(node2, node1);
15123             }
15124         }
15125     }
15126 
15127     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15128 }
15129 
15130 static NODE*
15131 gettable_gen(struct parser_params *parser, ID id)
15132 {
15133     switch (id) {
15134       case keyword_self:
15135         return NEW_SELF();
15136       case keyword_nil:
15137         return NEW_NIL();
15138       case keyword_true:
15139         return NEW_TRUE();
15140       case keyword_false:
15141         return NEW_FALSE();
15142       case keyword__FILE__:
15143         return NEW_STR(rb_str_dup(ruby_sourcefile_string));
15144       case keyword__LINE__:
15145         return NEW_LIT(INT2FIX(tokline));
15146       case keyword__ENCODING__:
15147         return NEW_LIT(rb_enc_from_encoding(current_enc));
15148     }
15149     switch (id_type(id)) {
15150       case ID_LOCAL:
15151         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15152         if (local_id(id)) return NEW_LVAR(id);
15153         /* method call without arguments */
15154         return NEW_VCALL(id);
15155       case ID_GLOBAL:
15156         return NEW_GVAR(id);
15157       case ID_INSTANCE:
15158         return NEW_IVAR(id);
15159       case ID_CONST:
15160         return NEW_CONST(id);
15161       case ID_CLASS:
15162         return NEW_CVAR(id);
15163     }
15164     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15165     return 0;
15166 }
15167 #else  /* !RIPPER */
15168 static int
15169 id_is_var_gen(struct parser_params *parser, ID id)
15170 {
15171     if (is_notop_id(id)) {
15172         switch (id & ID_SCOPE_MASK) {
15173           case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15174             return 1;
15175           case ID_LOCAL:
15176             if (dyna_in_block() && dvar_defined(id)) return 1;
15177             if (local_id(id)) return 1;
15178             /* method call without arguments */
15179             return 0;
15180         }
15181     }
15182     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15183     return 0;
15184 }
15185 #endif /* !RIPPER */
15186 
15187 #if PARSER_DEBUG
15188 static const char *
15189 lex_state_name(enum lex_state_e state)
15190 {
15191     static const char names[][12] = {
15192         "EXPR_BEG",    "EXPR_END",    "EXPR_ENDARG", "EXPR_ENDFN",  "EXPR_ARG",
15193         "EXPR_CMDARG", "EXPR_MID",    "EXPR_FNAME",  "EXPR_DOT",    "EXPR_CLASS",
15194         "EXPR_VALUE",
15195     };
15196 
15197     if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15198         return names[ffs(state)];
15199     return NULL;
15200 }
15201 #endif
15202 
15203 #ifdef RIPPER
15204 static VALUE
15205 assignable_gen(struct parser_params *parser, VALUE lhs)
15206 #else
15207 static NODE*
15208 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15209 #endif
15210 {
15211 #ifdef RIPPER
15212     ID id = get_id(lhs);
15213 # define assignable_result(x) get_value(lhs)
15214 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15215 #else
15216 # define assignable_result(x) (x)
15217 #endif
15218     if (!id) return assignable_result(0);
15219     switch (id) {
15220       case keyword_self:
15221         yyerror("Can't change the value of self");
15222         goto error;
15223       case keyword_nil:
15224         yyerror("Can't assign to nil");
15225         goto error;
15226       case keyword_true:
15227         yyerror("Can't assign to true");
15228         goto error;
15229       case keyword_false:
15230         yyerror("Can't assign to false");
15231         goto error;
15232       case keyword__FILE__:
15233         yyerror("Can't assign to __FILE__");
15234         goto error;
15235       case keyword__LINE__:
15236         yyerror("Can't assign to __LINE__");
15237         goto error;
15238       case keyword__ENCODING__:
15239         yyerror("Can't assign to __ENCODING__");
15240         goto error;
15241     }
15242     switch (id_type(id)) {
15243       case ID_LOCAL:
15244         if (dyna_in_block()) {
15245             if (dvar_curr(id)) {
15246                 return assignable_result(NEW_DASGN_CURR(id, val));
15247             }
15248             else if (dvar_defined(id)) {
15249                 return assignable_result(NEW_DASGN(id, val));
15250             }
15251             else if (local_id(id)) {
15252                 return assignable_result(NEW_LASGN(id, val));
15253             }
15254             else {
15255                 dyna_var(id);
15256                 return assignable_result(NEW_DASGN_CURR(id, val));
15257             }
15258         }
15259         else {
15260             if (!local_id(id)) {
15261                 local_var(id);
15262             }
15263             return assignable_result(NEW_LASGN(id, val));
15264         }
15265         break;
15266       case ID_GLOBAL:
15267         return assignable_result(NEW_GASGN(id, val));
15268       case ID_INSTANCE:
15269         return assignable_result(NEW_IASGN(id, val));
15270       case ID_CONST:
15271         if (!in_def && !in_single)
15272             return assignable_result(NEW_CDECL(id, val, 0));
15273         yyerror("dynamic constant assignment");
15274         break;
15275       case ID_CLASS:
15276         return assignable_result(NEW_CVASGN(id, val));
15277       default:
15278         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15279     }
15280   error:
15281     return assignable_result(0);
15282 #undef assignable_result
15283 #undef parser_yyerror
15284 }
15285 
15286 static int
15287 is_private_local_id(ID name)
15288 {
15289     VALUE s;
15290     if (name == idUScore) return 1;
15291     if (!is_local_id(name)) return 0;
15292     s = rb_id2str(name);
15293     if (!s) return 0;
15294     return RSTRING_PTR(s)[0] == '_';
15295 }
15296 
15297 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15298 
15299 static int
15300 shadowing_lvar_0(struct parser_params *parser, ID name)
15301 {
15302     if (is_private_local_id(name)) return 1;
15303     if (dyna_in_block()) {
15304         if (dvar_curr(name)) {
15305             yyerror("duplicated argument name");
15306         }
15307         else if (dvar_defined_get(name) || local_id(name)) {
15308             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15309             vtable_add(lvtbl->vars, name);
15310             if (lvtbl->used) {
15311                 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15312             }
15313             return 0;
15314         }
15315     }
15316     else {
15317         if (local_id(name)) {
15318             yyerror("duplicated argument name");
15319         }
15320     }
15321     return 1;
15322 }
15323 
15324 static ID
15325 shadowing_lvar_gen(struct parser_params *parser, ID name)
15326 {
15327     shadowing_lvar_0(parser, name);
15328     return name;
15329 }
15330 
15331 static void
15332 new_bv_gen(struct parser_params *parser, ID name)
15333 {
15334     if (!name) return;
15335     if (!is_local_id(name)) {
15336         compile_error(PARSER_ARG "invalid local variable - %s",
15337                       rb_id2name(name));
15338         return;
15339     }
15340     if (!shadowing_lvar_0(parser, name)) return;
15341     dyna_var(name);
15342 }
15343 
15344 #ifndef RIPPER
15345 static NODE *
15346 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15347 {
15348     if (recv && nd_type(recv) == NODE_SELF)
15349         recv = (NODE *)1;
15350     return NEW_ATTRASGN(recv, tASET, idx);
15351 }
15352 
15353 static void
15354 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15355 {
15356     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15357         compile_error(PARSER_ARG "both block arg and actual block given");
15358     }
15359 }
15360 
15361 static const char id_type_names[][9] = {
15362     "LOCAL",
15363     "INSTANCE",
15364     "",                         /* INSTANCE2 */
15365     "GLOBAL",
15366     "ATTRSET",
15367     "CONST",
15368     "CLASS",
15369     "JUNK",
15370 };
15371 
15372 ID
15373 rb_id_attrset(ID id)
15374 {
15375     if (!is_notop_id(id)) {
15376         switch (id) {
15377           case tAREF: case tASET:
15378             return tASET;       /* only exception */
15379         }
15380         rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15381     }
15382     else {
15383         int scope = (int)(id & ID_SCOPE_MASK);
15384         switch (scope) {
15385           case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15386           case ID_CONST: case ID_CLASS: case ID_JUNK:
15387             break;
15388           case ID_ATTRSET:
15389             return id;
15390           default:
15391             rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15392                           id_type_names[scope], ID2SYM(id));
15393 
15394         }
15395     }
15396     id &= ~ID_SCOPE_MASK;
15397     id |= ID_ATTRSET;
15398     return id;
15399 }
15400 
15401 static NODE *
15402 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15403 {
15404     if (recv && nd_type(recv) == NODE_SELF)
15405         recv = (NODE *)1;
15406     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15407 }
15408 
15409 static void
15410 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15411 {
15412     switch (nd_type(node)) {
15413       case NODE_NTH_REF:
15414         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15415         break;
15416       case NODE_BACK_REF:
15417         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15418         break;
15419     }
15420 }
15421 
15422 static NODE *
15423 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15424 {
15425     if (!node2) return node1;
15426     switch (nd_type(node1)) {
15427       case NODE_BLOCK_PASS:
15428         if (node1->nd_head)
15429             node1->nd_head = arg_concat(node1->nd_head, node2);
15430         else
15431             node1->nd_head = NEW_LIST(node2);
15432         return node1;
15433       case NODE_ARGSPUSH:
15434         if (nd_type(node2) != NODE_ARRAY) break;
15435         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15436         nd_set_type(node1, NODE_ARGSCAT);
15437         return node1;
15438       case NODE_ARGSCAT:
15439         if (nd_type(node2) != NODE_ARRAY ||
15440             nd_type(node1->nd_body) != NODE_ARRAY) break;
15441         node1->nd_body = list_concat(node1->nd_body, node2);
15442         return node1;
15443     }
15444     return NEW_ARGSCAT(node1, node2);
15445 }
15446 
15447 static NODE *
15448 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15449 {
15450     if (!node1) return NEW_LIST(node2);
15451     switch (nd_type(node1))  {
15452       case NODE_ARRAY:
15453         return list_append(node1, node2);
15454       case NODE_BLOCK_PASS:
15455         node1->nd_head = arg_append(node1->nd_head, node2);
15456         return node1;
15457       case NODE_ARGSPUSH:
15458         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15459         nd_set_type(node1, NODE_ARGSCAT);
15460         return node1;
15461     }
15462     return NEW_ARGSPUSH(node1, node2);
15463 }
15464 
15465 static NODE *
15466 splat_array(NODE* node)
15467 {
15468     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15469     if (nd_type(node) == NODE_ARRAY) return node;
15470     return 0;
15471 }
15472 
15473 static NODE *
15474 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15475 {
15476     if (!lhs) return 0;
15477 
15478     switch (nd_type(lhs)) {
15479       case NODE_GASGN:
15480       case NODE_IASGN:
15481       case NODE_IASGN2:
15482       case NODE_LASGN:
15483       case NODE_DASGN:
15484       case NODE_DASGN_CURR:
15485       case NODE_MASGN:
15486       case NODE_CDECL:
15487       case NODE_CVASGN:
15488         lhs->nd_value = rhs;
15489         break;
15490 
15491       case NODE_ATTRASGN:
15492       case NODE_CALL:
15493         lhs->nd_args = arg_append(lhs->nd_args, rhs);
15494         break;
15495 
15496       default:
15497         /* should not happen */
15498         break;
15499     }
15500 
15501     return lhs;
15502 }
15503 
15504 static int
15505 value_expr_gen(struct parser_params *parser, NODE *node)
15506 {
15507     int cond = 0;
15508 
15509     if (!node) {
15510         rb_warning0("empty expression");
15511     }
15512     while (node) {
15513         switch (nd_type(node)) {
15514           case NODE_RETURN:
15515           case NODE_BREAK:
15516           case NODE_NEXT:
15517           case NODE_REDO:
15518           case NODE_RETRY:
15519             if (!cond) yyerror("void value expression");
15520             /* or "control never reach"? */
15521             return FALSE;
15522 
15523           case NODE_BLOCK:
15524             while (node->nd_next) {
15525                 node = node->nd_next;
15526             }
15527             node = node->nd_head;
15528             break;
15529 
15530           case NODE_BEGIN:
15531             node = node->nd_body;
15532             break;
15533 
15534           case NODE_IF:
15535             if (!node->nd_body) {
15536                 node = node->nd_else;
15537                 break;
15538             }
15539             else if (!node->nd_else) {
15540                 node = node->nd_body;
15541                 break;
15542             }
15543             if (!value_expr(node->nd_body)) return FALSE;
15544             node = node->nd_else;
15545             break;
15546 
15547           case NODE_AND:
15548           case NODE_OR:
15549             cond = 1;
15550             node = node->nd_2nd;
15551             break;
15552 
15553           default:
15554             return TRUE;
15555         }
15556     }
15557 
15558     return TRUE;
15559 }
15560 
15561 static void
15562 void_expr_gen(struct parser_params *parser, NODE *node)
15563 {
15564     const char *useless = 0;
15565 
15566     if (!RTEST(ruby_verbose)) return;
15567 
15568     if (!node) return;
15569     switch (nd_type(node)) {
15570       case NODE_CALL:
15571         switch (node->nd_mid) {
15572           case '+':
15573           case '-':
15574           case '*':
15575           case '/':
15576           case '%':
15577           case tPOW:
15578           case tUPLUS:
15579           case tUMINUS:
15580           case '|':
15581           case '^':
15582           case '&':
15583           case tCMP:
15584           case '>':
15585           case tGEQ:
15586           case '<':
15587           case tLEQ:
15588           case tEQ:
15589           case tNEQ:
15590             useless = rb_id2name(node->nd_mid);
15591             break;
15592         }
15593         break;
15594 
15595       case NODE_LVAR:
15596       case NODE_DVAR:
15597       case NODE_GVAR:
15598       case NODE_IVAR:
15599       case NODE_CVAR:
15600       case NODE_NTH_REF:
15601       case NODE_BACK_REF:
15602         useless = "a variable";
15603         break;
15604       case NODE_CONST:
15605         useless = "a constant";
15606         break;
15607       case NODE_LIT:
15608       case NODE_STR:
15609       case NODE_DSTR:
15610       case NODE_DREGX:
15611       case NODE_DREGX_ONCE:
15612         useless = "a literal";
15613         break;
15614       case NODE_COLON2:
15615       case NODE_COLON3:
15616         useless = "::";
15617         break;
15618       case NODE_DOT2:
15619         useless = "..";
15620         break;
15621       case NODE_DOT3:
15622         useless = "...";
15623         break;
15624       case NODE_SELF:
15625         useless = "self";
15626         break;
15627       case NODE_NIL:
15628         useless = "nil";
15629         break;
15630       case NODE_TRUE:
15631         useless = "true";
15632         break;
15633       case NODE_FALSE:
15634         useless = "false";
15635         break;
15636       case NODE_DEFINED:
15637         useless = "defined?";
15638         break;
15639     }
15640 
15641     if (useless) {
15642         int line = ruby_sourceline;
15643 
15644         ruby_sourceline = nd_line(node);
15645         rb_warnS("possibly useless use of %s in void context", useless);
15646         ruby_sourceline = line;
15647     }
15648 }
15649 
15650 static void
15651 void_stmts_gen(struct parser_params *parser, NODE *node)
15652 {
15653     if (!RTEST(ruby_verbose)) return;
15654     if (!node) return;
15655     if (nd_type(node) != NODE_BLOCK) return;
15656 
15657     for (;;) {
15658         if (!node->nd_next) return;
15659         void_expr0(node->nd_head);
15660         node = node->nd_next;
15661     }
15662 }
15663 
15664 static NODE *
15665 remove_begin(NODE *node)
15666 {
15667     NODE **n = &node, *n1 = node;
15668     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15669         *n = n1 = n1->nd_body;
15670     }
15671     return node;
15672 }
15673 
15674 static NODE *
15675 remove_begin_all(NODE *node)
15676 {
15677     NODE **n = &node, *n1 = node;
15678     while (n1 && nd_type(n1) == NODE_BEGIN) {
15679         *n = n1 = n1->nd_body;
15680     }
15681     return node;
15682 }
15683 
15684 static void
15685 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15686 {
15687     NODE *node = *body;
15688 
15689     if (!node) {
15690         *body = NEW_NIL();
15691         return;
15692     }
15693 #define subnodes(n1, n2) \
15694     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15695      (!node->n2) ? (body = &node->n1, 1) : \
15696      (reduce_nodes(&node->n1), body = &node->n2, 1))
15697 
15698     while (node) {
15699         int newline = (int)(node->flags & NODE_FL_NEWLINE);
15700         switch (nd_type(node)) {
15701           end:
15702           case NODE_NIL:
15703             *body = 0;
15704             return;
15705           case NODE_RETURN:
15706             *body = node = node->nd_stts;
15707             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15708             continue;
15709           case NODE_BEGIN:
15710             *body = node = node->nd_body;
15711             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15712             continue;
15713           case NODE_BLOCK:
15714             body = &node->nd_end->nd_head;
15715             break;
15716           case NODE_IF:
15717             if (subnodes(nd_body, nd_else)) break;
15718             return;
15719           case NODE_CASE:
15720             body = &node->nd_body;
15721             break;
15722           case NODE_WHEN:
15723             if (!subnodes(nd_body, nd_next)) goto end;
15724             break;
15725           case NODE_ENSURE:
15726             if (!subnodes(nd_head, nd_resq)) goto end;
15727             break;
15728           case NODE_RESCUE:
15729             if (node->nd_else) {
15730                 body = &node->nd_resq;
15731                 break;
15732             }
15733             if (!subnodes(nd_head, nd_resq)) goto end;
15734             break;
15735           default:
15736             return;
15737         }
15738         node = *body;
15739         if (newline && node) node->flags |= NODE_FL_NEWLINE;
15740     }
15741 
15742 #undef subnodes
15743 }
15744 
15745 static int
15746 is_static_content(NODE *node)
15747 {
15748     if (!node) return 1;
15749     switch (nd_type(node)) {
15750       case NODE_HASH:
15751         if (!(node = node->nd_head)) break;
15752       case NODE_ARRAY:
15753         do {
15754             if (!is_static_content(node->nd_head)) return 0;
15755         } while ((node = node->nd_next) != 0);
15756       case NODE_LIT:
15757       case NODE_STR:
15758       case NODE_NIL:
15759       case NODE_TRUE:
15760       case NODE_FALSE:
15761       case NODE_ZARRAY:
15762         break;
15763       default:
15764         return 0;
15765     }
15766     return 1;
15767 }
15768 
15769 static int
15770 assign_in_cond(struct parser_params *parser, NODE *node)
15771 {
15772     switch (nd_type(node)) {
15773       case NODE_MASGN:
15774         yyerror("multiple assignment in conditional");
15775         return 1;
15776 
15777       case NODE_LASGN:
15778       case NODE_DASGN:
15779       case NODE_DASGN_CURR:
15780       case NODE_GASGN:
15781       case NODE_IASGN:
15782         break;
15783 
15784       default:
15785         return 0;
15786     }
15787 
15788     if (!node->nd_value) return 1;
15789     if (is_static_content(node->nd_value)) {
15790         /* reports always */
15791         parser_warn(node->nd_value, "found = in conditional, should be ==");
15792     }
15793     return 1;
15794 }
15795 
15796 static void
15797 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15798 {
15799     if (!e_option_supplied(parser)) parser_warn(node, str);
15800 }
15801 
15802 static void
15803 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15804 {
15805     if (!e_option_supplied(parser)) parser_warning(node, str);
15806 }
15807 
15808 static void
15809 fixup_nodes(NODE **rootnode)
15810 {
15811     NODE *node, *next, *head;
15812 
15813     for (node = *rootnode; node; node = next) {
15814         enum node_type type;
15815         VALUE val;
15816 
15817         next = node->nd_next;
15818         head = node->nd_head;
15819         rb_gc_force_recycle((VALUE)node);
15820         *rootnode = next;
15821         switch (type = nd_type(head)) {
15822           case NODE_DOT2:
15823           case NODE_DOT3:
15824             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15825                                type == NODE_DOT3);
15826             rb_gc_force_recycle((VALUE)head->nd_beg);
15827             rb_gc_force_recycle((VALUE)head->nd_end);
15828             nd_set_type(head, NODE_LIT);
15829             head->nd_lit = val;
15830             break;
15831           default:
15832             break;
15833         }
15834     }
15835 }
15836 
15837 static NODE *cond0(struct parser_params*,NODE*);
15838 
15839 static NODE*
15840 range_op(struct parser_params *parser, NODE *node)
15841 {
15842     enum node_type type;
15843 
15844     if (node == 0) return 0;
15845 
15846     type = nd_type(node);
15847     value_expr(node);
15848     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15849         warn_unless_e_option(parser, node, "integer literal in conditional range");
15850         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15851     }
15852     return cond0(parser, node);
15853 }
15854 
15855 static int
15856 literal_node(NODE *node)
15857 {
15858     if (!node) return 1;        /* same as NODE_NIL */
15859     switch (nd_type(node)) {
15860       case NODE_LIT:
15861       case NODE_STR:
15862       case NODE_DSTR:
15863       case NODE_EVSTR:
15864       case NODE_DREGX:
15865       case NODE_DREGX_ONCE:
15866       case NODE_DSYM:
15867         return 2;
15868       case NODE_TRUE:
15869       case NODE_FALSE:
15870       case NODE_NIL:
15871         return 1;
15872     }
15873     return 0;
15874 }
15875 
15876 static NODE*
15877 cond0(struct parser_params *parser, NODE *node)
15878 {
15879     if (node == 0) return 0;
15880     assign_in_cond(parser, node);
15881 
15882     switch (nd_type(node)) {
15883       case NODE_DSTR:
15884       case NODE_EVSTR:
15885       case NODE_STR:
15886         rb_warn0("string literal in condition");
15887         break;
15888 
15889       case NODE_DREGX:
15890       case NODE_DREGX_ONCE:
15891         warning_unless_e_option(parser, node, "regex literal in condition");
15892         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15893 
15894       case NODE_AND:
15895       case NODE_OR:
15896         node->nd_1st = cond0(parser, node->nd_1st);
15897         node->nd_2nd = cond0(parser, node->nd_2nd);
15898         break;
15899 
15900       case NODE_DOT2:
15901       case NODE_DOT3:
15902         node->nd_beg = range_op(parser, node->nd_beg);
15903         node->nd_end = range_op(parser, node->nd_end);
15904         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15905         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15906         if (!e_option_supplied(parser)) {
15907             int b = literal_node(node->nd_beg);
15908             int e = literal_node(node->nd_end);
15909             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15910                 parser_warn(node, "range literal in condition");
15911             }
15912         }
15913         break;
15914 
15915       case NODE_DSYM:
15916         parser_warning(node, "literal in condition");
15917         break;
15918 
15919       case NODE_LIT:
15920         if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15921             warn_unless_e_option(parser, node, "regex literal in condition");
15922             nd_set_type(node, NODE_MATCH);
15923         }
15924         else {
15925             parser_warning(node, "literal in condition");
15926         }
15927       default:
15928         break;
15929     }
15930     return node;
15931 }
15932 
15933 static NODE*
15934 cond_gen(struct parser_params *parser, NODE *node)
15935 {
15936     if (node == 0) return 0;
15937     return cond0(parser, node);
15938 }
15939 
15940 static NODE*
15941 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15942 {
15943     value_expr(left);
15944     if (left && (enum node_type)nd_type(left) == type) {
15945         NODE *node = left, *second;
15946         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15947             node = second;
15948         }
15949         node->nd_2nd = NEW_NODE(type, second, right, 0);
15950         return left;
15951     }
15952     return NEW_NODE(type, left, right, 0);
15953 }
15954 
15955 static void
15956 no_blockarg(struct parser_params *parser, NODE *node)
15957 {
15958     if (node && nd_type(node) == NODE_BLOCK_PASS) {
15959         compile_error(PARSER_ARG "block argument should not be given");
15960     }
15961 }
15962 
15963 static NODE *
15964 ret_args_gen(struct parser_params *parser, NODE *node)
15965 {
15966     if (node) {
15967         no_blockarg(parser, node);
15968         if (nd_type(node) == NODE_ARRAY) {
15969             if (node->nd_next == 0) {
15970                 node = node->nd_head;
15971             }
15972             else {
15973                 nd_set_type(node, NODE_VALUES);
15974             }
15975         }
15976     }
15977     return node;
15978 }
15979 
15980 static NODE *
15981 new_yield_gen(struct parser_params *parser, NODE *node)
15982 {
15983     if (node) no_blockarg(parser, node);
15984 
15985     return NEW_YIELD(node);
15986 }
15987 
15988 static NODE*
15989 negate_lit(NODE *node)
15990 {
15991     switch (TYPE(node->nd_lit)) {
15992       case T_FIXNUM:
15993         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15994         break;
15995       case T_BIGNUM:
15996       case T_RATIONAL:
15997       case T_COMPLEX:
15998         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15999         break;
16000       case T_FLOAT:
16001 #if USE_FLONUM
16002         if (FLONUM_P(node->nd_lit)) {
16003             node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
16004         }
16005         else {
16006             RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16007         }
16008 #else
16009         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16010 #endif
16011         break;
16012       default:
16013         rb_bug("unknown literal type passed to negate_lit");
16014         break;
16015     }
16016     return node;
16017 }
16018 
16019 static NODE *
16020 arg_blk_pass(NODE *node1, NODE *node2)
16021 {
16022     if (node2) {
16023         node2->nd_head = node1;
16024         return node2;
16025     }
16026     return node1;
16027 }
16028 
16029 
16030 static NODE*
16031 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16032 {
16033     int saved_line = ruby_sourceline;
16034     struct rb_args_info *args = tail->nd_ainfo;
16035 
16036     args->pre_args_num   = m ? rb_long2int(m->nd_plen) : 0;
16037     args->pre_init       = m ? m->nd_next : 0;
16038 
16039     args->post_args_num  = p ? rb_long2int(p->nd_plen) : 0;
16040     args->post_init      = p ? p->nd_next : 0;
16041     args->first_post_arg = p ? p->nd_pid : 0;
16042 
16043     args->rest_arg       = r;
16044 
16045     args->opt_args       = o;
16046 
16047     ruby_sourceline = saved_line;
16048 
16049     return tail;
16050 }
16051 
16052 static NODE*
16053 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
16054 {
16055     int saved_line = ruby_sourceline;
16056     struct rb_args_info *args;
16057     NODE *kw_rest_arg = 0;
16058     NODE *node;
16059     int check = 0;
16060 
16061     args = ALLOC(struct rb_args_info);
16062     MEMZERO(args, struct rb_args_info, 1);
16063     node = NEW_NODE(NODE_ARGS, 0, 0, args);
16064 
16065     args->block_arg      = b;
16066     args->kw_args        = k;
16067     if (k && !kr) {
16068         check = 1;
16069         kr = internal_id();
16070     }
16071     if (kr) {
16072         arg_var(kr);
16073         kw_rest_arg  = NEW_DVAR(kr);
16074         kw_rest_arg->nd_cflag = check;
16075     }
16076     args->kw_rest_arg    = kw_rest_arg;
16077 
16078     ruby_sourceline = saved_line;
16079     return node;
16080 }
16081 
16082 static NODE*
16083 dsym_node_gen(struct parser_params *parser, NODE *node)
16084 {
16085     VALUE lit;
16086 
16087     if (!node) {
16088         return NEW_LIT(ID2SYM(idNULL));
16089     }
16090 
16091     switch (nd_type(node)) {
16092       case NODE_DSTR:
16093         nd_set_type(node, NODE_DSYM);
16094         break;
16095       case NODE_STR:
16096         lit = node->nd_lit;
16097         node->nd_lit = ID2SYM(rb_intern_str(lit));
16098         nd_set_type(node, NODE_LIT);
16099         break;
16100       default:
16101         node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
16102         break;
16103     }
16104     return node;
16105 }
16106 #endif /* !RIPPER */
16107 
16108 #ifndef RIPPER
16109 static NODE *
16110 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16111 {
16112     NODE *asgn;
16113 
16114     if (lhs) {
16115         ID vid = lhs->nd_vid;
16116         if (op == tOROP) {
16117             lhs->nd_value = rhs;
16118             asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16119             if (is_asgn_or_id(vid)) {
16120                 asgn->nd_aid = vid;
16121             }
16122         }
16123         else if (op == tANDOP) {
16124             lhs->nd_value = rhs;
16125             asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16126         }
16127         else {
16128             asgn = lhs;
16129             asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16130         }
16131     }
16132     else {
16133         asgn = NEW_BEGIN(0);
16134     }
16135     return asgn;
16136 }
16137 
16138 static NODE *
16139 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16140 {
16141     NODE *asgn;
16142 
16143     if (op == tOROP) {
16144         op = 0;
16145     }
16146     else if (op == tANDOP) {
16147         op = 1;
16148     }
16149     asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16150     fixpos(asgn, lhs);
16151     return asgn;
16152 }
16153 
16154 static NODE *
16155 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16156 {
16157     NODE *asgn;
16158 
16159     if (op == tOROP) {
16160         op = 0;
16161     }
16162     else if (op == tANDOP) {
16163         op = 1;
16164     }
16165     if (lhs) {
16166         asgn = NEW_OP_CDECL(lhs, op, rhs);
16167     }
16168     else {
16169         asgn = NEW_BEGIN(0);
16170     }
16171     fixpos(asgn, lhs);
16172     return asgn;
16173 }
16174 #else
16175 static VALUE
16176 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16177 {
16178     return dispatch3(opassign, lhs, op, rhs);
16179 }
16180 
16181 static VALUE
16182 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16183 {
16184     VALUE recv = dispatch3(field, lhs, type, attr);
16185     return dispatch3(opassign, recv, op, rhs);
16186 }
16187 #endif
16188 
16189 static void
16190 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16191 {
16192     int i, cnt;
16193     ID *v, *u;
16194 
16195     if (!local->used) return;
16196     v = local->vars->tbl;
16197     u = local->used->tbl;
16198     cnt = local->used->pos;
16199     if (cnt != local->vars->pos) {
16200         rb_bug("local->used->pos != local->vars->pos");
16201     }
16202     for (i = 0; i < cnt; ++i) {
16203         if (!v[i] || (u[i] & LVAR_USED)) continue;
16204         if (is_private_local_id(v[i])) continue;
16205         rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16206     }
16207 }
16208 
16209 static void
16210 local_push_gen(struct parser_params *parser, int inherit_dvars)
16211 {
16212     struct local_vars *local;
16213 
16214     local = ALLOC(struct local_vars);
16215     local->prev = lvtbl;
16216     local->args = vtable_alloc(0);
16217     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16218     local->used = !(inherit_dvars &&
16219                     (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
16220         RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16221     local->cmdargs = cmdarg_stack;
16222     cmdarg_stack = 0;
16223     lvtbl = local;
16224 }
16225 
16226 static void
16227 local_pop_gen(struct parser_params *parser)
16228 {
16229     struct local_vars *local = lvtbl->prev;
16230     if (lvtbl->used) {
16231         warn_unused_var(parser, lvtbl);
16232         vtable_free(lvtbl->used);
16233     }
16234     vtable_free(lvtbl->args);
16235     vtable_free(lvtbl->vars);
16236     cmdarg_stack = lvtbl->cmdargs;
16237     xfree(lvtbl);
16238     lvtbl = local;
16239 }
16240 
16241 #ifndef RIPPER
16242 static ID*
16243 local_tbl_gen(struct parser_params *parser)
16244 {
16245     int cnt_args = vtable_size(lvtbl->args);
16246     int cnt_vars = vtable_size(lvtbl->vars);
16247     int cnt = cnt_args + cnt_vars;
16248     int i, j;
16249     ID *buf;
16250 
16251     if (cnt <= 0) return 0;
16252     buf = ALLOC_N(ID, cnt + 1);
16253     MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16254     /* remove IDs duplicated to warn shadowing */
16255     for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16256         ID id = lvtbl->vars->tbl[i];
16257         if (!vtable_included(lvtbl->args, id)) {
16258             buf[j++] = id;
16259         }
16260     }
16261     if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16262     buf[0] = cnt;
16263     return buf;
16264 }
16265 #endif
16266 
16267 static int
16268 arg_var_gen(struct parser_params *parser, ID id)
16269 {
16270     vtable_add(lvtbl->args, id);
16271     return vtable_size(lvtbl->args) - 1;
16272 }
16273 
16274 static int
16275 local_var_gen(struct parser_params *parser, ID id)
16276 {
16277     vtable_add(lvtbl->vars, id);
16278     if (lvtbl->used) {
16279         vtable_add(lvtbl->used, (ID)ruby_sourceline);
16280     }
16281     return vtable_size(lvtbl->vars) - 1;
16282 }
16283 
16284 static int
16285 local_id_gen(struct parser_params *parser, ID id)
16286 {
16287     struct vtable *vars, *args, *used;
16288 
16289     vars = lvtbl->vars;
16290     args = lvtbl->args;
16291     used = lvtbl->used;
16292 
16293     while (vars && POINTER_P(vars->prev)) {
16294         vars = vars->prev;
16295         args = args->prev;
16296         if (used) used = used->prev;
16297     }
16298 
16299     if (vars && vars->prev == DVARS_INHERIT) {
16300         return rb_local_defined(id);
16301     }
16302     else if (vtable_included(args, id)) {
16303         return 1;
16304     }
16305     else {
16306         int i = vtable_included(vars, id);
16307         if (i && used) used->tbl[i-1] |= LVAR_USED;
16308         return i != 0;
16309     }
16310 }
16311 
16312 static const struct vtable *
16313 dyna_push_gen(struct parser_params *parser)
16314 {
16315     lvtbl->args = vtable_alloc(lvtbl->args);
16316     lvtbl->vars = vtable_alloc(lvtbl->vars);
16317     if (lvtbl->used) {
16318         lvtbl->used = vtable_alloc(lvtbl->used);
16319     }
16320     return lvtbl->args;
16321 }
16322 
16323 static void
16324 dyna_pop_1(struct parser_params *parser)
16325 {
16326     struct vtable *tmp;
16327 
16328     if ((tmp = lvtbl->used) != 0) {
16329         warn_unused_var(parser, lvtbl);
16330         lvtbl->used = lvtbl->used->prev;
16331         vtable_free(tmp);
16332     }
16333     tmp = lvtbl->args;
16334     lvtbl->args = lvtbl->args->prev;
16335     vtable_free(tmp);
16336     tmp = lvtbl->vars;
16337     lvtbl->vars = lvtbl->vars->prev;
16338     vtable_free(tmp);
16339 }
16340 
16341 static void
16342 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16343 {
16344     while (lvtbl->args != lvargs) {
16345         dyna_pop_1(parser);
16346         if (!lvtbl->args) {
16347             struct local_vars *local = lvtbl->prev;
16348             xfree(lvtbl);
16349             lvtbl = local;
16350         }
16351     }
16352     dyna_pop_1(parser);
16353 }
16354 
16355 static int
16356 dyna_in_block_gen(struct parser_params *parser)
16357 {
16358     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16359 }
16360 
16361 static int
16362 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16363 {
16364     struct vtable *vars, *args, *used;
16365     int i;
16366 
16367     args = lvtbl->args;
16368     vars = lvtbl->vars;
16369     used = lvtbl->used;
16370 
16371     while (POINTER_P(vars)) {
16372         if (vtable_included(args, id)) {
16373             return 1;
16374         }
16375         if ((i = vtable_included(vars, id)) != 0) {
16376             if (used) used->tbl[i-1] |= LVAR_USED;
16377             return 1;
16378         }
16379         args = args->prev;
16380         vars = vars->prev;
16381         if (get) used = 0;
16382         if (used) used = used->prev;
16383     }
16384 
16385     if (vars == DVARS_INHERIT) {
16386         return rb_dvar_defined(id);
16387     }
16388 
16389     return 0;
16390 }
16391 
16392 static int
16393 dvar_curr_gen(struct parser_params *parser, ID id)
16394 {
16395     return (vtable_included(lvtbl->args, id) ||
16396             vtable_included(lvtbl->vars, id));
16397 }
16398 
16399 #ifndef RIPPER
16400 static void
16401 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
16402 {
16403     int c = RE_OPTION_ENCODING_IDX(options);
16404 
16405     if (c) {
16406         int opt, idx;
16407         rb_char_to_option_kcode(c, &opt, &idx);
16408         if (idx != ENCODING_GET(str) &&
16409             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16410             goto error;
16411         }
16412         ENCODING_SET(str, idx);
16413     }
16414     else if (RE_OPTION_ENCODING_NONE(options)) {
16415         if (!ENCODING_IS_ASCII8BIT(str) &&
16416             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16417             c = 'n';
16418             goto error;
16419         }
16420         rb_enc_associate(str, rb_ascii8bit_encoding());
16421     }
16422     else if (current_enc == rb_usascii_encoding()) {
16423         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16424             /* raise in re.c */
16425             rb_enc_associate(str, rb_usascii_encoding());
16426         }
16427         else {
16428             rb_enc_associate(str, rb_ascii8bit_encoding());
16429         }
16430     }
16431     return;
16432 
16433   error:
16434     compile_error(PARSER_ARG
16435         "regexp encoding option '%c' differs from source encoding '%s'",
16436         c, rb_enc_name(rb_enc_get(str)));
16437 }
16438 
16439 static int
16440 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
16441 {
16442     VALUE err;
16443     reg_fragment_setenc(str, options);
16444     err = rb_reg_check_preprocess(str);
16445     if (err != Qnil) {
16446         err = rb_obj_as_string(err);
16447         compile_error(PARSER_ARG "%"PRIsVALUE, err);
16448         return 0;
16449     }
16450     return 1;
16451 }
16452 
16453 typedef struct {
16454     struct parser_params* parser;
16455     rb_encoding *enc;
16456     NODE *succ_block;
16457     NODE *fail_block;
16458     int num;
16459 } reg_named_capture_assign_t;
16460 
16461 static int
16462 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
16463           int back_num, int *back_refs, OnigRegex regex, void *arg0)
16464 {
16465     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
16466     struct parser_params* parser = arg->parser;
16467     rb_encoding *enc = arg->enc;
16468     long len = name_end - name;
16469     const char *s = (const char *)name;
16470     ID var;
16471 
16472     arg->num++;
16473 
16474     if (arg->succ_block == 0) {
16475         arg->succ_block = NEW_BEGIN(0);
16476         arg->fail_block = NEW_BEGIN(0);
16477     }
16478 
16479     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16480         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16481         !rb_enc_symname2_p(s, len, enc)) {
16482         return ST_CONTINUE;
16483     }
16484     var = rb_intern3(s, len, enc);
16485     if (dvar_defined(var) || local_id(var)) {
16486         rb_warningS("named capture conflicts a local variable - %s",
16487                     rb_id2name(var));
16488     }
16489     arg->succ_block = block_append(arg->succ_block,
16490         newline_node(node_assign(assignable(var,0),
16491             NEW_CALL(
16492               gettable(rb_intern("$~")),
16493               idAREF,
16494               NEW_LIST(NEW_LIT(ID2SYM(var))))
16495             )));
16496     arg->fail_block = block_append(arg->fail_block,
16497         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
16498     return ST_CONTINUE;
16499 }
16500 
16501 static NODE *
16502 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
16503 {
16504     reg_named_capture_assign_t arg;
16505 
16506     arg.parser = parser;
16507     arg.enc = rb_enc_get(regexp);
16508     arg.succ_block = 0;
16509     arg.fail_block = 0;
16510     arg.num = 0;
16511     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16512 
16513     if (arg.num == 0)
16514         return match;
16515 
16516     return
16517         block_append(
16518             newline_node(match),
16519             NEW_IF(gettable(rb_intern("$~")),
16520                 block_append(
16521                     newline_node(arg.succ_block),
16522                     newline_node(
16523                         NEW_CALL(
16524                           gettable(rb_intern("$~")),
16525                           rb_intern("begin"),
16526                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16527                 block_append(
16528                     newline_node(arg.fail_block),
16529                     newline_node(
16530                         NEW_LIT(Qnil)))));
16531 }
16532 
16533 static VALUE
16534 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16535 {
16536     VALUE re;
16537     VALUE err;
16538 
16539     reg_fragment_setenc(str, options);
16540     err = rb_errinfo();
16541     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
16542     if (NIL_P(re)) {
16543         ID mesg = rb_intern("mesg");
16544         VALUE m = rb_attr_get(rb_errinfo(), mesg);
16545         rb_set_errinfo(err);
16546         if (!NIL_P(err)) {
16547             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16548         }
16549         else {
16550             compile_error(PARSER_ARG "%"PRIsVALUE, m);
16551         }
16552         return Qnil;
16553     }
16554     return re;
16555 }
16556 
16557 void
16558 rb_gc_mark_parser(void)
16559 {
16560 }
16561 
16562 NODE*
16563 rb_parser_append_print(VALUE vparser, NODE *node)
16564 {
16565     NODE *prelude = 0;
16566     NODE *scope = node;
16567     struct parser_params *parser;
16568 
16569     if (!node) return node;
16570 
16571     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16572 
16573     node = node->nd_body;
16574 
16575     if (nd_type(node) == NODE_PRELUDE) {
16576         prelude = node;
16577         node = node->nd_body;
16578     }
16579 
16580     node = block_append(node,
16581                         NEW_FCALL(rb_intern("print"),
16582                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16583     if (prelude) {
16584         prelude->nd_body = node;
16585         scope->nd_body = prelude;
16586     }
16587     else {
16588         scope->nd_body = node;
16589     }
16590 
16591     return scope;
16592 }
16593 
16594 NODE *
16595 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16596 {
16597     NODE *prelude = 0;
16598     NODE *scope = node;
16599     struct parser_params *parser;
16600 
16601     if (!node) return node;
16602 
16603     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16604 
16605     node = node->nd_body;
16606 
16607     if (nd_type(node) == NODE_PRELUDE) {
16608         prelude = node;
16609         node = node->nd_body;
16610     }
16611     if (split) {
16612         node = block_append(NEW_GASGN(rb_intern("$F"),
16613                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
16614                                                rb_intern("split"), 0)),
16615                             node);
16616     }
16617     if (chop) {
16618         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16619                                      rb_intern("chop!"), 0), node);
16620     }
16621 
16622     node = NEW_OPT_N(node);
16623 
16624     if (prelude) {
16625         prelude->nd_body = node;
16626         scope->nd_body = prelude;
16627     }
16628     else {
16629         scope->nd_body = node;
16630     }
16631 
16632     return scope;
16633 }
16634 
16635 static const struct {
16636     ID token;
16637     const char *name;
16638 } op_tbl[] = {
16639     {tDOT2,     ".."},
16640     {tDOT3,     "..."},
16641     {tPOW,      "**"},
16642     {tDSTAR,    "**"},
16643     {tUPLUS,    "+@"},
16644     {tUMINUS,   "-@"},
16645     {tCMP,      "<=>"},
16646     {tGEQ,      ">="},
16647     {tLEQ,      "<="},
16648     {tEQ,       "=="},
16649     {tEQQ,      "==="},
16650     {tNEQ,      "!="},
16651     {tMATCH,    "=~"},
16652     {tNMATCH,   "!~"},
16653     {tAREF,     "[]"},
16654     {tASET,     "[]="},
16655     {tLSHFT,    "<<"},
16656     {tRSHFT,    ">>"},
16657     {tCOLON2,   "::"},
16658 };
16659 
16660 #define op_tbl_count numberof(op_tbl)
16661 
16662 #ifndef ENABLE_SELECTOR_NAMESPACE
16663 #define ENABLE_SELECTOR_NAMESPACE 0
16664 #endif
16665 
16666 static struct symbols {
16667     ID last_id;
16668     st_table *sym_id;
16669     st_table *id_str;
16670 #if ENABLE_SELECTOR_NAMESPACE
16671     st_table *ivar2_id;
16672     st_table *id_ivar2;
16673 #endif
16674     VALUE op_sym[tLAST_OP_ID];
16675     int minor_marked;
16676 } global_symbols = {tLAST_TOKEN};
16677 
16678 static const struct st_hash_type symhash = {
16679     rb_str_hash_cmp,
16680     rb_str_hash,
16681 };
16682 
16683 #if ENABLE_SELECTOR_NAMESPACE
16684 struct ivar2_key {
16685     ID id;
16686     VALUE klass;
16687 };
16688 
16689 static int
16690 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16691 {
16692     if (key1->id == key2->id && key1->klass == key2->klass) {
16693         return 0;
16694     }
16695     return 1;
16696 }
16697 
16698 static int
16699 ivar2_hash(struct ivar2_key *key)
16700 {
16701     return (key->id << 8) ^ (key->klass >> 2);
16702 }
16703 
16704 static const struct st_hash_type ivar2_hash_type = {
16705     ivar2_cmp,
16706     ivar2_hash,
16707 };
16708 #endif
16709 
16710 void
16711 Init_sym(void)
16712 {
16713     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16714     global_symbols.id_str = st_init_numtable_with_size(1000);
16715 #if ENABLE_SELECTOR_NAMESPACE
16716     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16717     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16718 #endif
16719 
16720     (void)nodetype;
16721     (void)nodeline;
16722 #if PARSER_DEBUG
16723     (void)lex_state_name(-1);
16724 #endif
16725 
16726     Init_id();
16727 }
16728 
16729 void
16730 rb_gc_mark_symbols(int full_mark)
16731 {
16732     if (full_mark || global_symbols.minor_marked == 0) {
16733         rb_mark_tbl(global_symbols.id_str);
16734         rb_gc_mark_locations(global_symbols.op_sym,
16735                              global_symbols.op_sym + numberof(global_symbols.op_sym));
16736 
16737         if (!full_mark) global_symbols.minor_marked = 1;
16738     }
16739 }
16740 #endif /* !RIPPER */
16741 
16742 static ID
16743 internal_id_gen(struct parser_params *parser)
16744 {
16745     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16746     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16747     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16748 }
16749 
16750 #ifndef RIPPER
16751 static int
16752 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16753 {
16754     int mb = 0;
16755 
16756     if (m >= e) return 0;
16757     if (is_global_name_punct(*m)) {
16758         ++m;
16759     }
16760     else if (*m == '-') {
16761         if (++m >= e) return 0;
16762         if (is_identchar(m, e, enc)) {
16763             if (!ISASCII(*m)) mb = 1;
16764             m += rb_enc_mbclen(m, e, enc);
16765         }
16766     }
16767     else {
16768         if (!rb_enc_isdigit(*m, enc)) return 0;
16769         do {
16770             if (!ISASCII(*m)) mb = 1;
16771             ++m;
16772         } while (m < e && rb_enc_isdigit(*m, enc));
16773     }
16774     return m == e ? mb + 1 : 0;
16775 }
16776 
16777 int
16778 rb_symname_p(const char *name)
16779 {
16780     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16781 }
16782 
16783 int
16784 rb_enc_symname_p(const char *name, rb_encoding *enc)
16785 {
16786     return rb_enc_symname2_p(name, strlen(name), enc);
16787 }
16788 
16789 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16790 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
16791 
16792 static int
16793 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
16794 {
16795     const char *m = name;
16796     const char *e = m + len;
16797     int type = ID_JUNK;
16798 
16799     if (!m || len <= 0) return -1;
16800     switch (*m) {
16801       case '\0':
16802         return -1;
16803 
16804       case '$':
16805         type = ID_GLOBAL;
16806         if (is_special_global_name(++m, e, enc)) return type;
16807         goto id;
16808 
16809       case '@':
16810         type = ID_INSTANCE;
16811         if (*++m == '@') {
16812             ++m;
16813             type = ID_CLASS;
16814         }
16815         goto id;
16816 
16817       case '<':
16818         switch (*++m) {
16819           case '<': ++m; break;
16820           case '=': if (*++m == '>') ++m; break;
16821           default: break;
16822         }
16823         break;
16824 
16825       case '>':
16826         switch (*++m) {
16827           case '>': case '=': ++m; break;
16828         }
16829         break;
16830 
16831       case '=':
16832         switch (*++m) {
16833           case '~': ++m; break;
16834           case '=': if (*++m == '=') ++m; break;
16835           default: return -1;
16836         }
16837         break;
16838 
16839       case '*':
16840         if (*++m == '*') ++m;
16841         break;
16842 
16843       case '+': case '-':
16844         if (*++m == '@') ++m;
16845         break;
16846 
16847       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16848         ++m;
16849         break;
16850 
16851       case '[':
16852         if (*++m != ']') return -1;
16853         if (*++m == '=') ++m;
16854         break;
16855 
16856       case '!':
16857         if (len == 1) return ID_JUNK;
16858         switch (*++m) {
16859           case '=': case '~': ++m; break;
16860           default: return -1;
16861         }
16862         break;
16863 
16864       default:
16865         type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16866       id:
16867         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16868             return -1;
16869         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16870         if (m >= e) break;
16871         switch (*m) {
16872           case '!': case '?':
16873             if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16874             type = ID_JUNK;
16875             ++m;
16876             break;
16877           case '=':
16878             if (!(allowed_attrset & (1U << type))) return -1;
16879             type = ID_ATTRSET;
16880             ++m;
16881             break;
16882         }
16883         break;
16884     }
16885     return m == e ? type : -1;
16886 }
16887 
16888 int
16889 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16890 {
16891     return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16892 }
16893 
16894 static int
16895 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
16896 {
16897     const char *ptr = StringValuePtr(name);
16898     long len = RSTRING_LEN(name);
16899     int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
16900     RB_GC_GUARD(name);
16901     return type;
16902 }
16903 
16904 static ID
16905 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16906 {
16907     VALUE str = rb_enc_str_new(name, len, enc);
16908     return register_symid_str(id, str);
16909 }
16910 
16911 static ID
16912 register_symid_str(ID id, VALUE str)
16913 {
16914     OBJ_FREEZE(str);
16915     str = rb_fstring(str);
16916 
16917     if (RUBY_DTRACE_SYMBOL_CREATE_ENABLED()) {
16918         RUBY_DTRACE_SYMBOL_CREATE(RSTRING_PTR(str), rb_sourcefile(), rb_sourceline());
16919     }
16920 
16921     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
16922     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
16923     global_symbols.minor_marked = 0;
16924     return id;
16925 }
16926 
16927 static int
16928 sym_check_asciionly(VALUE str)
16929 {
16930     if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16931     switch (rb_enc_str_coderange(str)) {
16932       case ENC_CODERANGE_BROKEN:
16933         rb_raise(rb_eEncodingError, "invalid encoding symbol");
16934       case ENC_CODERANGE_7BIT:
16935         return TRUE;
16936     }
16937     return FALSE;
16938 }
16939 
16940 /*
16941  * _str_ itself will be registered at the global symbol table.  _str_
16942  * can be modified before the registration, since the encoding will be
16943  * set to ASCII-8BIT if it is a special global name.
16944  */
16945 static ID intern_str(VALUE str);
16946 
16947 static VALUE
16948 setup_fake_str(struct RString *fake_str, const char *name, long len)
16949 {
16950     fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
16951     RBASIC_SET_CLASS_RAW((VALUE)fake_str, rb_cString);
16952     fake_str->as.heap.len = len;
16953     fake_str->as.heap.ptr = (char *)name;
16954     fake_str->as.heap.aux.capa = len;
16955     return (VALUE)fake_str;
16956 }
16957 
16958 ID
16959 rb_intern3(const char *name, long len, rb_encoding *enc)
16960 {
16961     st_data_t data;
16962     struct RString fake_str;
16963     VALUE str = setup_fake_str(&fake_str, name, len);
16964     rb_enc_associate(str, enc);
16965     OBJ_FREEZE(str);
16966 
16967     if (st_lookup(global_symbols.sym_id, str, &data))
16968         return (ID)data;
16969 
16970     str = rb_enc_str_new(name, len, enc); /* make true string */
16971     return intern_str(str);
16972 }
16973 
16974 static ID
16975 intern_str(VALUE str)
16976 {
16977     const char *name, *m, *e;
16978     long len, last;
16979     rb_encoding *enc, *symenc;
16980     unsigned char c;
16981     ID id;
16982     int mb;
16983 
16984     RSTRING_GETMEM(str, name, len);
16985     m = name;
16986     e = m + len;
16987     enc = rb_enc_get(str);
16988     symenc = enc;
16989 
16990     if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16991       junk:
16992         id = ID_JUNK;
16993         goto new_id;
16994     }
16995     last = len-1;
16996     id = 0;
16997     switch (*m) {
16998       case '$':
16999         if (len < 2) goto junk;
17000         id |= ID_GLOBAL;
17001         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
17002             if (!--mb) symenc = rb_usascii_encoding();
17003             goto new_id;
17004         }
17005         break;
17006       case '@':
17007         if (m[1] == '@') {
17008             if (len < 3) goto junk;
17009             m++;
17010             id |= ID_CLASS;
17011         }
17012         else {
17013             if (len < 2) goto junk;
17014             id |= ID_INSTANCE;
17015         }
17016         m++;
17017         break;
17018       default:
17019         c = m[0];
17020         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
17021             /* operators */
17022             int i;
17023 
17024             if (len == 1) {
17025                 id = c;
17026                 goto id_register;
17027             }
17028             for (i = 0; i < op_tbl_count; i++) {
17029                 if (*op_tbl[i].name == *m &&
17030                     strcmp(op_tbl[i].name, m) == 0) {
17031                     id = op_tbl[i].token;
17032                     goto id_register;
17033                 }
17034             }
17035         }
17036         break;
17037     }
17038     if (name[last] == '=') {
17039         /* attribute assignment */
17040         if (last > 1 && name[last-1] == '=')
17041             goto junk;
17042         id = rb_intern3(name, last, enc);
17043         if (id > tLAST_OP_ID && !is_attrset_id(id)) {
17044             enc = rb_enc_get(rb_id2str(id));
17045             id = rb_id_attrset(id);
17046             goto id_register;
17047         }
17048         id = ID_ATTRSET;
17049     }
17050     else if (id == 0) {
17051         if (rb_enc_isupper(m[0], enc)) {
17052             id = ID_CONST;
17053         }
17054         else {
17055             id = ID_LOCAL;
17056         }
17057     }
17058     if (!rb_enc_isdigit(*m, enc)) {
17059         while (m <= name + last && is_identchar(m, e, enc)) {
17060             if (ISASCII(*m)) {
17061                 m++;
17062             }
17063             else {
17064                 m += rb_enc_mbclen(m, e, enc);
17065             }
17066         }
17067     }
17068     if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
17069     if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
17070   new_id:
17071     if (symenc != enc) rb_enc_associate(str, symenc);
17072     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
17073         if (len > 20) {
17074             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
17075                      name);
17076         }
17077         else {
17078             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
17079                      (int)len, name);
17080         }
17081     }
17082     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
17083   id_register:
17084     return register_symid_str(id, str);
17085 }
17086 
17087 ID
17088 rb_intern2(const char *name, long len)
17089 {
17090     return rb_intern3(name, len, rb_usascii_encoding());
17091 }
17092 
17093 #undef rb_intern
17094 ID
17095 rb_intern(const char *name)
17096 {
17097     return rb_intern2(name, strlen(name));
17098 }
17099 
17100 ID
17101 rb_intern_str(VALUE str)
17102 {
17103     st_data_t id;
17104 
17105     if (st_lookup(global_symbols.sym_id, str, &id))
17106         return (ID)id;
17107     return intern_str(rb_str_dup(str));
17108 }
17109 
17110 VALUE
17111 rb_id2str(ID id)
17112 {
17113     st_data_t data;
17114 
17115     if (id < tLAST_TOKEN) {
17116         int i = 0;
17117 
17118         if (id < INT_MAX && rb_ispunct((int)id)) {
17119             VALUE str = global_symbols.op_sym[i = (int)id];
17120             if (!str) {
17121                 char name[2];
17122                 name[0] = (char)id;
17123                 name[1] = 0;
17124                 str = rb_usascii_str_new(name, 1);
17125                 OBJ_FREEZE(str);
17126                 str = rb_fstring(str);
17127                 global_symbols.op_sym[i] = str;
17128                 global_symbols.minor_marked = 0;
17129             }
17130             return str;
17131         }
17132         for (i = 0; i < op_tbl_count; i++) {
17133             if (op_tbl[i].token == id) {
17134                 VALUE str = global_symbols.op_sym[i];
17135                 if (!str) {
17136                     str = rb_usascii_str_new2(op_tbl[i].name);
17137                     OBJ_FREEZE(str);
17138                     str = rb_fstring(str);
17139                     global_symbols.op_sym[i] = str;
17140                     global_symbols.minor_marked = 0;
17141                 }
17142                 return str;
17143             }
17144         }
17145     }
17146 
17147     if (st_lookup(global_symbols.id_str, id, &data)) {
17148         VALUE str = (VALUE)data;
17149         if (RBASIC(str)->klass == 0)
17150             RBASIC_SET_CLASS_RAW(str, rb_cString);
17151         return str;
17152     }
17153 
17154     if (is_attrset_id(id)) {
17155         ID id_stem = (id & ~ID_SCOPE_MASK);
17156         VALUE str;
17157 
17158         do {
17159             if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17160             if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17161             if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17162             if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17163             if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17164             if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17165             return 0;
17166         } while (0);
17167         str = rb_str_dup(str);
17168         rb_str_cat(str, "=", 1);
17169         register_symid_str(id, str);
17170         if (st_lookup(global_symbols.id_str, id, &data)) {
17171             VALUE str = (VALUE)data;
17172             if (RBASIC(str)->klass == 0)
17173                 RBASIC_SET_CLASS_RAW(str, rb_cString);
17174             return str;
17175         }
17176     }
17177     return 0;
17178 }
17179 
17180 const char *
17181 rb_id2name(ID id)
17182 {
17183     VALUE str = rb_id2str(id);
17184 
17185     if (!str) return 0;
17186     return RSTRING_PTR(str);
17187 }
17188 
17189 static int
17190 symbols_i(VALUE sym, ID value, VALUE ary)
17191 {
17192     rb_ary_push(ary, ID2SYM(value));
17193     return ST_CONTINUE;
17194 }
17195 
17196 /*
17197  *  call-seq:
17198  *     Symbol.all_symbols    => array
17199  *
17200  *  Returns an array of all the symbols currently in Ruby's symbol
17201  *  table.
17202  *
17203  *     Symbol.all_symbols.size    #=> 903
17204  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
17205  *                                     :chown, :EOFError, :$;, :String,
17206  *                                     :LOCK_SH, :"setuid?", :$<,
17207  *                                     :default_proc, :compact, :extend,
17208  *                                     :Tms, :getwd, :$=, :ThreadGroup,
17209  *                                     :wait2, :$>]
17210  */
17211 
17212 VALUE
17213 rb_sym_all_symbols(void)
17214 {
17215     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
17216 
17217     st_foreach(global_symbols.sym_id, symbols_i, ary);
17218     return ary;
17219 }
17220 
17221 int
17222 rb_is_const_id(ID id)
17223 {
17224     return is_const_id(id);
17225 }
17226 
17227 int
17228 rb_is_class_id(ID id)
17229 {
17230     return is_class_id(id);
17231 }
17232 
17233 int
17234 rb_is_global_id(ID id)
17235 {
17236     return is_global_id(id);
17237 }
17238 
17239 int
17240 rb_is_instance_id(ID id)
17241 {
17242     return is_instance_id(id);
17243 }
17244 
17245 int
17246 rb_is_attrset_id(ID id)
17247 {
17248     return is_attrset_id(id);
17249 }
17250 
17251 int
17252 rb_is_local_id(ID id)
17253 {
17254     return is_local_id(id);
17255 }
17256 
17257 int
17258 rb_is_junk_id(ID id)
17259 {
17260     return is_junk_id(id);
17261 }
17262 
17274 ID
17275 rb_check_id(volatile VALUE *namep)
17276 {
17277     st_data_t id;
17278     VALUE tmp;
17279     VALUE name = *namep;
17280 
17281     if (SYMBOL_P(name)) {
17282         return SYM2ID(name);
17283     }
17284     else if (!RB_TYPE_P(name, T_STRING)) {
17285         tmp = rb_check_string_type(name);
17286         if (NIL_P(tmp)) {
17287             tmp = rb_inspect(name);
17288             rb_raise(rb_eTypeError, "%s is not a symbol",
17289                      RSTRING_PTR(tmp));
17290         }
17291         name = tmp;
17292         *namep = name;
17293     }
17294 
17295     sym_check_asciionly(name);
17296 
17297     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17298         return (ID)id;
17299 
17300     if (rb_is_attrset_name(name)) {
17301         struct RString fake_str;
17302         /* make local name by chopping '=' */
17303         const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
17304         rb_enc_copy(localname, name);
17305         OBJ_FREEZE(localname);
17306 
17307         if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17308             return rb_id_attrset((ID)id);
17309         }
17310         RB_GC_GUARD(name);
17311     }
17312 
17313     return (ID)0;
17314 }
17315 
17316 ID
17317 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17318 {
17319     st_data_t id;
17320     struct RString fake_str;
17321     const VALUE name = setup_fake_str(&fake_str, ptr, len);
17322     rb_enc_associate(name, enc);
17323 
17324     sym_check_asciionly(name);
17325 
17326     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17327         return (ID)id;
17328 
17329     if (rb_is_attrset_name(name)) {
17330         fake_str.as.heap.len = len - 1;
17331         if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17332             return rb_id_attrset((ID)id);
17333         }
17334     }
17335 
17336     return (ID)0;
17337 }
17338 
17339 int
17340 rb_is_const_name(VALUE name)
17341 {
17342     return rb_str_symname_type(name, 0) == ID_CONST;
17343 }
17344 
17345 int
17346 rb_is_class_name(VALUE name)
17347 {
17348     return rb_str_symname_type(name, 0) == ID_CLASS;
17349 }
17350 
17351 int
17352 rb_is_global_name(VALUE name)
17353 {
17354     return rb_str_symname_type(name, 0) == ID_GLOBAL;
17355 }
17356 
17357 int
17358 rb_is_instance_name(VALUE name)
17359 {
17360     return rb_str_symname_type(name, 0) == ID_INSTANCE;
17361 }
17362 
17363 int
17364 rb_is_attrset_name(VALUE name)
17365 {
17366     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
17367 }
17368 
17369 int
17370 rb_is_local_name(VALUE name)
17371 {
17372     return rb_str_symname_type(name, 0) == ID_LOCAL;
17373 }
17374 
17375 int
17376 rb_is_method_name(VALUE name)
17377 {
17378     switch (rb_str_symname_type(name, 0)) {
17379       case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17380         return TRUE;
17381     }
17382     return FALSE;
17383 }
17384 
17385 int
17386 rb_is_junk_name(VALUE name)
17387 {
17388     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17389 }
17390 
17391 #endif /* !RIPPER */
17392 
17393 static void
17394 parser_initialize(struct parser_params *parser)
17395 {
17396     parser->eofp = Qfalse;
17397 
17398     parser->parser_lex_strterm = 0;
17399     parser->parser_cond_stack = 0;
17400     parser->parser_cmdarg_stack = 0;
17401     parser->parser_class_nest = 0;
17402     parser->parser_paren_nest = 0;
17403     parser->parser_lpar_beg = 0;
17404     parser->parser_brace_nest = 0;
17405     parser->parser_in_single = 0;
17406     parser->parser_in_def = 0;
17407     parser->parser_in_defined = 0;
17408     parser->parser_in_kwarg = 0;
17409     parser->parser_compile_for_eval = 0;
17410     parser->parser_cur_mid = 0;
17411     parser->parser_tokenbuf = NULL;
17412     parser->parser_tokidx = 0;
17413     parser->parser_toksiz = 0;
17414     parser->parser_heredoc_end = 0;
17415     parser->parser_command_start = TRUE;
17416     parser->parser_deferred_nodes = 0;
17417     parser->parser_lex_pbeg = 0;
17418     parser->parser_lex_p = 0;
17419     parser->parser_lex_pend = 0;
17420     parser->parser_lvtbl = 0;
17421     parser->parser_ruby__end__seen = 0;
17422     parser->parser_ruby_sourcefile = 0;
17423     parser->parser_ruby_sourcefile_string = Qnil;
17424 #ifndef RIPPER
17425     parser->is_ripper = 0;
17426     parser->parser_eval_tree_begin = 0;
17427     parser->parser_eval_tree = 0;
17428 #else
17429     parser->is_ripper = 1;
17430     parser->delayed = Qnil;
17431 
17432     parser->result = Qnil;
17433     parser->parsing_thread = Qnil;
17434     parser->toplevel_p = TRUE;
17435 #endif
17436 #ifdef YYMALLOC
17437     parser->heap = NULL;
17438 #endif
17439     parser->enc = rb_utf8_encoding();
17440 }
17441 
17442 #ifdef RIPPER
17443 #define parser_mark ripper_parser_mark
17444 #define parser_free ripper_parser_free
17445 #endif
17446 
17447 static void
17448 parser_mark(void *ptr)
17449 {
17450     struct parser_params *p = (struct parser_params*)ptr;
17451 
17452     rb_gc_mark((VALUE)p->parser_lex_strterm);
17453     rb_gc_mark((VALUE)p->parser_deferred_nodes);
17454     rb_gc_mark(p->parser_lex_input);
17455     rb_gc_mark(p->parser_lex_lastline);
17456     rb_gc_mark(p->parser_lex_nextline);
17457     rb_gc_mark(p->parser_ruby_sourcefile_string);
17458 #ifndef RIPPER
17459     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
17460     rb_gc_mark((VALUE)p->parser_eval_tree) ;
17461     rb_gc_mark(p->debug_lines);
17462 #else
17463     rb_gc_mark(p->delayed);
17464     rb_gc_mark(p->value);
17465     rb_gc_mark(p->result);
17466     rb_gc_mark(p->parsing_thread);
17467 #endif
17468 #ifdef YYMALLOC
17469     rb_gc_mark((VALUE)p->heap);
17470 #endif
17471 }
17472 
17473 static void
17474 parser_free(void *ptr)
17475 {
17476     struct parser_params *p = (struct parser_params*)ptr;
17477     struct local_vars *local, *prev;
17478 
17479     if (p->parser_tokenbuf) {
17480         xfree(p->parser_tokenbuf);
17481     }
17482     for (local = p->parser_lvtbl; local; local = prev) {
17483         if (local->vars) xfree(local->vars);
17484         prev = local->prev;
17485         xfree(local);
17486     }
17487     xfree(p);
17488 }
17489 
17490 static size_t
17491 parser_memsize(const void *ptr)
17492 {
17493     struct parser_params *p = (struct parser_params*)ptr;
17494     struct local_vars *local;
17495     size_t size = sizeof(*p);
17496 
17497     if (!ptr) return 0;
17498     size += p->parser_toksiz;
17499     for (local = p->parser_lvtbl; local; local = local->prev) {
17500         size += sizeof(*local);
17501         if (local->vars) size += local->vars->capa * sizeof(ID);
17502     }
17503     return size;
17504 }
17505 
17506 static
17507 #ifndef RIPPER
17508 const
17509 #endif
17510 rb_data_type_t parser_data_type = {
17511     "parser",
17512     {
17513         parser_mark,
17514         parser_free,
17515         parser_memsize,
17516     },
17517     NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
17518 };
17519 
17520 #ifndef RIPPER
17521 #undef rb_reserved_word
17522 
17523 const struct kwtable *
17524 rb_reserved_word(const char *str, unsigned int len)
17525 {
17526     return reserved_word(str, len);
17527 }
17528 
17529 static struct parser_params *
17530 parser_new(void)
17531 {
17532     struct parser_params *p;
17533 
17534     p = ALLOC_N(struct parser_params, 1);
17535     MEMZERO(p, struct parser_params, 1);
17536     parser_initialize(p);
17537     return p;
17538 }
17539 
17540 VALUE
17541 rb_parser_new(void)
17542 {
17543     struct parser_params *p = parser_new();
17544 
17545     return TypedData_Wrap_Struct(0, &parser_data_type, p);
17546 }
17547 
17548 /*
17549  *  call-seq:
17550  *    ripper#end_seen?   -> Boolean
17551  *
17552  *  Return true if parsed source ended by +\_\_END\_\_+.
17553  */
17554 VALUE
17555 rb_parser_end_seen_p(VALUE vparser)
17556 {
17557     struct parser_params *parser;
17558 
17559     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17560     return ruby__end__seen ? Qtrue : Qfalse;
17561 }
17562 
17563 /*
17564  *  call-seq:
17565  *    ripper#encoding   -> encoding
17566  *
17567  *  Return encoding of the source.
17568  */
17569 VALUE
17570 rb_parser_encoding(VALUE vparser)
17571 {
17572     struct parser_params *parser;
17573 
17574     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17575     return rb_enc_from_encoding(current_enc);
17576 }
17577 
17578 /*
17579  *  call-seq:
17580  *    ripper.yydebug   -> true or false
17581  *
17582  *  Get yydebug.
17583  */
17584 VALUE
17585 rb_parser_get_yydebug(VALUE self)
17586 {
17587     struct parser_params *parser;
17588 
17589     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17590     return yydebug ? Qtrue : Qfalse;
17591 }
17592 
17593 /*
17594  *  call-seq:
17595  *    ripper.yydebug = flag
17596  *
17597  *  Set yydebug.
17598  */
17599 VALUE
17600 rb_parser_set_yydebug(VALUE self, VALUE flag)
17601 {
17602     struct parser_params *parser;
17603 
17604     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17605     yydebug = RTEST(flag);
17606     return flag;
17607 }
17608 
17609 #ifdef YYMALLOC
17610 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17611 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17612 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17613                            (n)->u3.cnt = (c), (p))
17614 
17615 void *
17616 rb_parser_malloc(struct parser_params *parser, size_t size)
17617 {
17618     size_t cnt = HEAPCNT(1, size);
17619     NODE *n = NEWHEAP();
17620     void *ptr = xmalloc(size);
17621 
17622     return ADD2HEAP(n, cnt, ptr);
17623 }
17624 
17625 void *
17626 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17627 {
17628     size_t cnt = HEAPCNT(nelem, size);
17629     NODE *n = NEWHEAP();
17630     void *ptr = xcalloc(nelem, size);
17631 
17632     return ADD2HEAP(n, cnt, ptr);
17633 }
17634 
17635 void *
17636 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17637 {
17638     NODE *n;
17639     size_t cnt = HEAPCNT(1, size);
17640 
17641     if (ptr && (n = parser->heap) != NULL) {
17642         do {
17643             if (n->u1.node == ptr) {
17644                 n->u1.node = ptr = xrealloc(ptr, size);
17645                 if (n->u3.cnt) n->u3.cnt = cnt;
17646                 return ptr;
17647             }
17648         } while ((n = n->u2.node) != NULL);
17649     }
17650     n = NEWHEAP();
17651     ptr = xrealloc(ptr, size);
17652     return ADD2HEAP(n, cnt, ptr);
17653 }
17654 
17655 void
17656 rb_parser_free(struct parser_params *parser, void *ptr)
17657 {
17658     NODE **prev = &parser->heap, *n;
17659 
17660     while ((n = *prev) != NULL) {
17661         if (n->u1.node == ptr) {
17662             *prev = n->u2.node;
17663             rb_gc_force_recycle((VALUE)n);
17664             break;
17665         }
17666         prev = &n->u2.node;
17667     }
17668     xfree(ptr);
17669 }
17670 #endif
17671 #endif
17672 
17673 #ifdef RIPPER
17674 #ifdef RIPPER_DEBUG
17675 extern int rb_is_pointer_to_heap(VALUE);
17676 
17677 /* :nodoc: */
17678 static VALUE
17679 ripper_validate_object(VALUE self, VALUE x)
17680 {
17681     if (x == Qfalse) return x;
17682     if (x == Qtrue) return x;
17683     if (x == Qnil) return x;
17684     if (x == Qundef)
17685         rb_raise(rb_eArgError, "Qundef given");
17686     if (FIXNUM_P(x)) return x;
17687     if (SYMBOL_P(x)) return x;
17688     if (!rb_is_pointer_to_heap(x))
17689         rb_raise(rb_eArgError, "invalid pointer: %p", x);
17690     switch (BUILTIN_TYPE(x)) {
17691       case T_STRING:
17692       case T_OBJECT:
17693       case T_ARRAY:
17694       case T_BIGNUM:
17695       case T_FLOAT:
17696       case T_COMPLEX:
17697       case T_RATIONAL:
17698         return x;
17699       case T_NODE:
17700         if (nd_type(x) != NODE_LASGN) {
17701             rb_raise(rb_eArgError, "NODE given: %p", x);
17702         }
17703         return ((NODE *)x)->nd_rval;
17704       default:
17705         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17706                  x, rb_obj_classname(x));
17707     }
17708     return x;
17709 }
17710 #endif
17711 
17712 #define validate(x) ((x) = get_value(x))
17713 
17714 static VALUE
17715 ripper_dispatch0(struct parser_params *parser, ID mid)
17716 {
17717     return rb_funcall(parser->value, mid, 0);
17718 }
17719 
17720 static VALUE
17721 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17722 {
17723     validate(a);
17724     return rb_funcall(parser->value, mid, 1, a);
17725 }
17726 
17727 static VALUE
17728 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17729 {
17730     validate(a);
17731     validate(b);
17732     return rb_funcall(parser->value, mid, 2, a, b);
17733 }
17734 
17735 static VALUE
17736 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17737 {
17738     validate(a);
17739     validate(b);
17740     validate(c);
17741     return rb_funcall(parser->value, mid, 3, a, b, c);
17742 }
17743 
17744 static VALUE
17745 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17746 {
17747     validate(a);
17748     validate(b);
17749     validate(c);
17750     validate(d);
17751     return rb_funcall(parser->value, mid, 4, a, b, c, d);
17752 }
17753 
17754 static VALUE
17755 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17756 {
17757     validate(a);
17758     validate(b);
17759     validate(c);
17760     validate(d);
17761     validate(e);
17762     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17763 }
17764 
17765 static VALUE
17766 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17767 {
17768     validate(a);
17769     validate(b);
17770     validate(c);
17771     validate(d);
17772     validate(e);
17773     validate(f);
17774     validate(g);
17775     return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17776 }
17777 
17778 static const struct kw_assoc {
17779     ID id;
17780     const char *name;
17781 } keyword_to_name[] = {
17782     {keyword_class,     "class"},
17783     {keyword_module,    "module"},
17784     {keyword_def,       "def"},
17785     {keyword_undef,     "undef"},
17786     {keyword_begin,     "begin"},
17787     {keyword_rescue,    "rescue"},
17788     {keyword_ensure,    "ensure"},
17789     {keyword_end,       "end"},
17790     {keyword_if,        "if"},
17791     {keyword_unless,    "unless"},
17792     {keyword_then,      "then"},
17793     {keyword_elsif,     "elsif"},
17794     {keyword_else,      "else"},
17795     {keyword_case,      "case"},
17796     {keyword_when,      "when"},
17797     {keyword_while,     "while"},
17798     {keyword_until,     "until"},
17799     {keyword_for,       "for"},
17800     {keyword_break,     "break"},
17801     {keyword_next,      "next"},
17802     {keyword_redo,      "redo"},
17803     {keyword_retry,     "retry"},
17804     {keyword_in,        "in"},
17805     {keyword_do,        "do"},
17806     {keyword_do_cond,   "do"},
17807     {keyword_do_block,  "do"},
17808     {keyword_return,    "return"},
17809     {keyword_yield,     "yield"},
17810     {keyword_super,     "super"},
17811     {keyword_self,      "self"},
17812     {keyword_nil,       "nil"},
17813     {keyword_true,      "true"},
17814     {keyword_false,     "false"},
17815     {keyword_and,       "and"},
17816     {keyword_or,        "or"},
17817     {keyword_not,       "not"},
17818     {modifier_if,       "if"},
17819     {modifier_unless,   "unless"},
17820     {modifier_while,    "while"},
17821     {modifier_until,    "until"},
17822     {modifier_rescue,   "rescue"},
17823     {keyword_alias,     "alias"},
17824     {keyword_defined,   "defined?"},
17825     {keyword_BEGIN,     "BEGIN"},
17826     {keyword_END,       "END"},
17827     {keyword__LINE__,   "__LINE__"},
17828     {keyword__FILE__,   "__FILE__"},
17829     {keyword__ENCODING__, "__ENCODING__"},
17830     {0, NULL}
17831 };
17832 
17833 static const char*
17834 keyword_id_to_str(ID id)
17835 {
17836     const struct kw_assoc *a;
17837 
17838     for (a = keyword_to_name; a->id; a++) {
17839         if (a->id == id)
17840             return a->name;
17841     }
17842     return NULL;
17843 }
17844 
17845 #undef ripper_id2sym
17846 static VALUE
17847 ripper_id2sym(ID id)
17848 {
17849     const char *name;
17850     char buf[8];
17851 
17852     if (id <= 256) {
17853         buf[0] = (char)id;
17854         buf[1] = '\0';
17855         return ID2SYM(rb_intern2(buf, 1));
17856     }
17857     if ((name = keyword_id_to_str(id))) {
17858         return ID2SYM(rb_intern(name));
17859     }
17860     switch (id) {
17861       case tOROP:
17862         name = "||";
17863         break;
17864       case tANDOP:
17865         name = "&&";
17866         break;
17867       default:
17868         name = rb_id2name(id);
17869         if (!name) {
17870             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17871         }
17872         return ID2SYM(id);
17873     }
17874     return ID2SYM(rb_intern(name));
17875 }
17876 
17877 static ID
17878 ripper_get_id(VALUE v)
17879 {
17880     NODE *nd;
17881     if (!RB_TYPE_P(v, T_NODE)) return 0;
17882     nd = (NODE *)v;
17883     if (nd_type(nd) != NODE_LASGN) return 0;
17884     return nd->nd_vid;
17885 }
17886 
17887 static VALUE
17888 ripper_get_value(VALUE v)
17889 {
17890     NODE *nd;
17891     if (v == Qundef) return Qnil;
17892     if (!RB_TYPE_P(v, T_NODE)) return v;
17893     nd = (NODE *)v;
17894     if (nd_type(nd) != NODE_LASGN) return Qnil;
17895     return nd->nd_rval;
17896 }
17897 
17898 static void
17899 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17900 {
17901     VALUE str;
17902     va_list args;
17903 
17904     va_start(args, fmt);
17905     str = rb_vsprintf(fmt, args);
17906     va_end(args);
17907     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17908 }
17909 
17910 static void
17911 ripper_warn0(struct parser_params *parser, const char *fmt)
17912 {
17913     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17914 }
17915 
17916 static void
17917 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17918 {
17919     rb_funcall(parser->value, rb_intern("warn"), 2,
17920                STR_NEW2(fmt), INT2NUM(a));
17921 }
17922 
17923 static void
17924 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17925 {
17926     rb_funcall(parser->value, rb_intern("warn"), 2,
17927                STR_NEW2(fmt), STR_NEW2(str));
17928 }
17929 
17930 static void
17931 ripper_warning0(struct parser_params *parser, const char *fmt)
17932 {
17933     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17934 }
17935 
17936 static void
17937 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17938 {
17939     rb_funcall(parser->value, rb_intern("warning"), 2,
17940                STR_NEW2(fmt), STR_NEW2(str));
17941 }
17942 
17943 static VALUE
17944 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17945 {
17946     return rb_io_gets(src);
17947 }
17948 
17949 static VALUE
17950 ripper_s_allocate(VALUE klass)
17951 {
17952     struct parser_params *p;
17953     VALUE self;
17954 
17955     p = ALLOC_N(struct parser_params, 1);
17956     MEMZERO(p, struct parser_params, 1);
17957     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17958     p->value = self;
17959     return self;
17960 }
17961 
17962 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17963 
17964 /*
17965  *  call-seq:
17966  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17967  *
17968  *  Create a new Ripper object.
17969  *  _src_ must be a String, an IO, or an Object which has #gets method.
17970  *
17971  *  This method does not starts parsing.
17972  *  See also Ripper#parse and Ripper.parse.
17973  */
17974 static VALUE
17975 ripper_initialize(int argc, VALUE *argv, VALUE self)
17976 {
17977     struct parser_params *parser;
17978     VALUE src, fname, lineno;
17979 
17980     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17981     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17982     if (RB_TYPE_P(src, T_FILE)) {
17983         parser->parser_lex_gets = ripper_lex_get_generic;
17984     }
17985     else {
17986         StringValue(src);
17987         parser->parser_lex_gets = lex_get_str;
17988     }
17989     parser->parser_lex_input = src;
17990     parser->eofp = Qfalse;
17991     if (NIL_P(fname)) {
17992         fname = STR_NEW2("(ripper)");
17993     }
17994     else {
17995         StringValue(fname);
17996     }
17997     parser_initialize(parser);
17998 
17999     parser->parser_ruby_sourcefile_string = fname;
18000     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
18001     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
18002 
18003     return Qnil;
18004 }
18005 
18006 struct ripper_args {
18007     struct parser_params *parser;
18008     int argc;
18009     VALUE *argv;
18010 };
18011 
18012 static VALUE
18013 ripper_parse0(VALUE parser_v)
18014 {
18015     struct parser_params *parser;
18016 
18017     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18018     parser_prepare(parser);
18019     ripper_yyparse((void*)parser);
18020     return parser->result;
18021 }
18022 
18023 static VALUE
18024 ripper_ensure(VALUE parser_v)
18025 {
18026     struct parser_params *parser;
18027 
18028     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18029     parser->parsing_thread = Qnil;
18030     return Qnil;
18031 }
18032 
18033 /*
18034  *  call-seq:
18035  *    ripper#parse
18036  *
18037  *  Start parsing and returns the value of the root action.
18038  */
18039 static VALUE
18040 ripper_parse(VALUE self)
18041 {
18042     struct parser_params *parser;
18043 
18044     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18045     if (!ripper_initialized_p(parser)) {
18046         rb_raise(rb_eArgError, "method called for uninitialized object");
18047     }
18048     if (!NIL_P(parser->parsing_thread)) {
18049         if (parser->parsing_thread == rb_thread_current())
18050             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
18051         else
18052             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
18053     }
18054     parser->parsing_thread = rb_thread_current();
18055     rb_ensure(ripper_parse0, self, ripper_ensure, self);
18056 
18057     return parser->result;
18058 }
18059 
18060 /*
18061  *  call-seq:
18062  *    ripper#column   -> Integer
18063  *
18064  *  Return column number of current parsing line.
18065  *  This number starts from 0.
18066  */
18067 static VALUE
18068 ripper_column(VALUE self)
18069 {
18070     struct parser_params *parser;
18071     long col;
18072 
18073     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18074     if (!ripper_initialized_p(parser)) {
18075         rb_raise(rb_eArgError, "method called for uninitialized object");
18076     }
18077     if (NIL_P(parser->parsing_thread)) return Qnil;
18078     col = parser->tokp - parser->parser_lex_pbeg;
18079     return LONG2NUM(col);
18080 }
18081 
18082 /*
18083  *  call-seq:
18084  *    ripper#filename   -> String
18085  *
18086  *  Return current parsing filename.
18087  */
18088 static VALUE
18089 ripper_filename(VALUE self)
18090 {
18091     struct parser_params *parser;
18092 
18093     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18094     if (!ripper_initialized_p(parser)) {
18095         rb_raise(rb_eArgError, "method called for uninitialized object");
18096     }
18097     return parser->parser_ruby_sourcefile_string;
18098 }
18099 
18100 /*
18101  *  call-seq:
18102  *    ripper#lineno   -> Integer
18103  *
18104  *  Return line number of current parsing line.
18105  *  This number starts from 1.
18106  */
18107 static VALUE
18108 ripper_lineno(VALUE self)
18109 {
18110     struct parser_params *parser;
18111 
18112     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18113     if (!ripper_initialized_p(parser)) {
18114         rb_raise(rb_eArgError, "method called for uninitialized object");
18115     }
18116     if (NIL_P(parser->parsing_thread)) return Qnil;
18117     return INT2NUM(parser->parser_ruby_sourceline);
18118 }
18119 
18120 #ifdef RIPPER_DEBUG
18121 /* :nodoc: */
18122 static VALUE
18123 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18124 {
18125     StringValue(msg);
18126     if (obj == Qundef) {
18127         rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
18128     }
18129     return Qnil;
18130 }
18131 
18132 /* :nodoc: */
18133 static VALUE
18134 ripper_value(VALUE self, VALUE obj)
18135 {
18136     return ULONG2NUM(obj);
18137 }
18138 #endif
18139 
18140 
18141 void
18142 Init_ripper(void)
18143 {
18144     parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
18145 
18146     ripper_init_eventids1();
18147     ripper_init_eventids2();
18148     /* ensure existing in symbol table */
18149     (void)rb_intern("||");
18150     (void)rb_intern("&&");
18151 
18152     InitVM(ripper);
18153 }
18154 
18155 void
18156 InitVM_ripper(void)
18157 {
18158     VALUE Ripper;
18159 
18160     Ripper = rb_define_class("Ripper", rb_cObject);
18161     /* version of Ripper */
18162     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18163     rb_define_alloc_func(Ripper, ripper_s_allocate);
18164     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18165     rb_define_method(Ripper, "parse", ripper_parse, 0);
18166     rb_define_method(Ripper, "column", ripper_column, 0);
18167     rb_define_method(Ripper, "filename", ripper_filename, 0);
18168     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18169     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18170     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18171     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18172     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18173 #ifdef RIPPER_DEBUG
18174     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18175     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18176     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18177 #endif
18178 
18179     ripper_init_eventids1_table(Ripper);
18180     ripper_init_eventids2_table(Ripper);
18181 
18182 # if 0
18183     /* Hack to let RDoc document SCRIPT_LINES__ */
18184 
18185     /*
18186      * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18187      * after the assignment will be added as an Array of lines with the file
18188      * name as the key.
18189      */
18190     rb_define_global_const("SCRIPT_LINES__", Qnil);
18191 #endif
18192 
18193 }
18194 #endif /* RIPPER */
18195 
18196