Ruby: ext/ripper/ripper.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 "ripper.y"
00070 
00071 
00072 #ifndef PARSER_DEBUG
00073 #define PARSER_DEBUG 0
00074 #endif
00075 #define YYDEBUG 1
00076 #define YYERROR_VERBOSE 1
00077 #define YYSTACK_USE_ALLOCA 0
00078 
00079 #include "ruby/ruby.h"
00080 #include "ruby/st.h"
00081 #include "ruby/encoding.h"
00082 #include "internal.h"
00083 #include "node.h"
00084 #include "parse.h"
00085 #include "id.h"
00086 #include "regenc.h"
00087 #include <stdio.h>
00088 #include <errno.h>
00089 #include <ctype.h>
00090 #include "probes.h"
00091 
00092 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
00093 
00094 #define YYMALLOC(size)          rb_parser_malloc(parser, (size))
00095 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, (ptr), (size))
00096 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, (nelem), (size))
00097 #define YYFREE(ptr)             rb_parser_free(parser, (ptr))
00098 #define malloc  YYMALLOC
00099 #define realloc YYREALLOC
00100 #define calloc  YYCALLOC
00101 #define free    YYFREE
00102 
00103 #ifndef RIPPER
00104 static ID register_symid(ID, const char *, long, rb_encoding *);
00105 static ID register_symid_str(ID, VALUE);
00106 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
00107 #include "id.c"
00108 #endif
00109 
00110 #define is_notop_id(id) ((id)>tLAST_OP_ID)
00111 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00112 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00113 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00114 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00115 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00116 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00117 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00118 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
00119 
00120 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00121         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00122          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00123          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00124 
00125 enum lex_state_bits {
00126     EXPR_BEG_bit,               /* ignore newline, +/- is a sign. */
00127     EXPR_END_bit,               /* newline significant, +/- is an operator. */
00128     EXPR_ENDARG_bit,            /* ditto, and unbound braces. */
00129     EXPR_ENDFN_bit,             /* ditto, and unbound braces. */
00130     EXPR_ARG_bit,               /* newline significant, +/- is an operator. */
00131     EXPR_CMDARG_bit,            /* newline significant, +/- is an operator. */
00132     EXPR_MID_bit,               /* newline significant, +/- is an operator. */
00133     EXPR_FNAME_bit,             /* ignore newline, no reserved words. */
00134     EXPR_DOT_bit,               /* right after `.' or `::', no reserved words. */
00135     EXPR_CLASS_bit,             /* immediate after `class', no here document. */
00136     EXPR_VALUE_bit,             /* alike EXPR_BEG but label is disallowed. */
00137     EXPR_MAX_STATE
00138 };
00139 /* examine combinations */
00140 enum lex_state_e {
00141 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
00142     DEF_EXPR(BEG),
00143     DEF_EXPR(END),
00144     DEF_EXPR(ENDARG),
00145     DEF_EXPR(ENDFN),
00146     DEF_EXPR(ARG),
00147     DEF_EXPR(CMDARG),
00148     DEF_EXPR(MID),
00149     DEF_EXPR(FNAME),
00150     DEF_EXPR(DOT),
00151     DEF_EXPR(CLASS),
00152     DEF_EXPR(VALUE),
00153     EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS),
00154     EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG),
00155     EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
00156 };
00157 #define IS_lex_state_for(x, ls) ((x) & (ls))
00158 #define IS_lex_state(ls)        IS_lex_state_for(lex_state, (ls))
00159 
00160 #if PARSER_DEBUG
00161 static const char *lex_state_name(enum lex_state_e state);
00162 #endif
00163 
00164 typedef VALUE stack_type;
00165 
00166 # define BITSTACK_PUSH(stack, n)        ((stack) = ((stack)<<1)|((n)&1))
00167 # define BITSTACK_POP(stack)    ((stack) = (stack) >> 1)
00168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
00169 # define BITSTACK_SET_P(stack)  ((stack)&1)
00170 
00171 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, (n))
00172 #define COND_POP()      BITSTACK_POP(cond_stack)
00173 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00174 #define COND_P()        BITSTACK_SET_P(cond_stack)
00175 
00176 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, (n))
00177 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00179 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00180 
00181 struct vtable {
00182     ID *tbl;
00183     int pos;
00184     int capa;
00185     struct vtable *prev;
00186 };
00187 
00188 struct local_vars {
00189     struct vtable *args;
00190     struct vtable *vars;
00191     struct vtable *used;
00192     struct local_vars *prev;
00193     stack_type cmdargs;
00194 };
00195 
00196 #define DVARS_INHERIT ((void*)1)
00197 #define DVARS_TOPSCOPE NULL
00198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00200 
00201 static int
00202 vtable_size(const struct vtable *tbl)
00203 {
00204     if (POINTER_P(tbl)) {
00205         return tbl->pos;
00206     }
00207     else {
00208         return 0;
00209     }
00210 }
00211 
00212 #define VTBL_DEBUG 0
00213 
00214 static struct vtable *
00215 vtable_alloc(struct vtable *prev)
00216 {
00217     struct vtable *tbl = ALLOC(struct vtable);
00218     tbl->pos = 0;
00219     tbl->capa = 8;
00220     tbl->tbl = ALLOC_N(ID, tbl->capa);
00221     tbl->prev = prev;
00222     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00223     return tbl;
00224 }
00225 
00226 static void
00227 vtable_free(struct vtable *tbl)
00228 {
00229     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00230     if (POINTER_P(tbl)) {
00231         if (tbl->tbl) {
00232             xfree(tbl->tbl);
00233         }
00234         xfree(tbl);
00235     }
00236 }
00237 
00238 static void
00239 vtable_add(struct vtable *tbl, ID id)
00240 {
00241     if (!POINTER_P(tbl)) {
00242         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00243     }
00244     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00245 
00246     if (tbl->pos == tbl->capa) {
00247         tbl->capa = tbl->capa * 2;
00248         REALLOC_N(tbl->tbl, ID, tbl->capa);
00249     }
00250     tbl->tbl[tbl->pos++] = id;
00251 }
00252 
00253 static int
00254 vtable_included(const struct vtable * tbl, ID id)
00255 {
00256     int i;
00257 
00258     if (POINTER_P(tbl)) {
00259         for (i = 0; i < tbl->pos; i++) {
00260             if (tbl->tbl[i] == id) {
00261                 return i+1;
00262             }
00263         }
00264     }
00265     return 0;
00266 }
00267 
00268 
00269 #ifndef RIPPER
00270 typedef struct token_info {
00271     const char *token;
00272     int linenum;
00273     int column;
00274     int nonspc;
00275     struct token_info *next;
00276 } token_info;
00277 #endif
00278 
00279 /*
00280     Structure of Lexer Buffer:
00281 
00282  lex_pbeg      tokp         lex_p        lex_pend
00283     |           |              |            |
00284     |-----------+--------------+------------|
00285                 |<------------>|
00286                      token
00287 */
00288 struct parser_params {
00289     int is_ripper;
00290     NODE *heap;
00291 
00292     YYSTYPE *parser_yylval;
00293     VALUE eofp;
00294 
00295     NODE *parser_lex_strterm;
00296     enum lex_state_e parser_lex_state;
00297     stack_type parser_cond_stack;
00298     stack_type parser_cmdarg_stack;
00299     int parser_class_nest;
00300     int parser_paren_nest;
00301     int parser_lpar_beg;
00302     int parser_in_single;
00303     int parser_in_def;
00304     int parser_brace_nest;
00305     int parser_compile_for_eval;
00306     VALUE parser_cur_mid;
00307     int parser_in_defined;
00308     char *parser_tokenbuf;
00309     int parser_tokidx;
00310     int parser_toksiz;
00311     int parser_tokline;
00312     VALUE parser_lex_input;
00313     VALUE parser_lex_lastline;
00314     VALUE parser_lex_nextline;
00315     const char *parser_lex_pbeg;
00316     const char *parser_lex_p;
00317     const char *parser_lex_pend;
00318     int parser_heredoc_end;
00319     int parser_command_start;
00320     NODE *parser_deferred_nodes;
00321     long parser_lex_gets_ptr;
00322     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00323     struct local_vars *parser_lvtbl;
00324     int parser_ruby__end__seen;
00325     int line_count;
00326     int has_shebang;
00327     char *parser_ruby_sourcefile; /* current source file */
00328     int parser_ruby_sourceline; /* current line no. */
00329     VALUE parser_ruby_sourcefile_string;
00330     rb_encoding *enc;
00331 
00332     int parser_yydebug;
00333 
00334 #ifndef RIPPER
00335     /* Ruby core only */
00336     NODE *parser_eval_tree_begin;
00337     NODE *parser_eval_tree;
00338     VALUE debug_lines;
00339     VALUE coverage;
00340     int nerr;
00341 
00342     int parser_token_info_enabled;
00343     token_info *parser_token_info;
00344 #else
00345     /* Ripper only */
00346     const char *tokp;
00347     VALUE delayed;
00348     int delayed_line;
00349     int delayed_col;
00350 
00351     VALUE value;
00352     VALUE result;
00353     VALUE parsing_thread;
00354     int toplevel_p;
00355 #endif
00356 };
00357 
00358 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
00359 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
00360 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
00361 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
00362 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00363 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
00364 
00365 static int parser_yyerror(struct parser_params*, const char*);
00366 #define yyerror(msg) parser_yyerror(parser, (msg))
00367 
00368 #define lex_strterm             (parser->parser_lex_strterm)
00369 #define lex_state               (parser->parser_lex_state)
00370 #define cond_stack              (parser->parser_cond_stack)
00371 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00372 #define class_nest              (parser->parser_class_nest)
00373 #define paren_nest              (parser->parser_paren_nest)
00374 #define lpar_beg                (parser->parser_lpar_beg)
00375 #define brace_nest              (parser->parser_brace_nest)
00376 #define in_single               (parser->parser_in_single)
00377 #define in_def                  (parser->parser_in_def)
00378 #define compile_for_eval        (parser->parser_compile_for_eval)
00379 #define cur_mid                 (parser->parser_cur_mid)
00380 #define in_defined              (parser->parser_in_defined)
00381 #define tokenbuf                (parser->parser_tokenbuf)
00382 #define tokidx                  (parser->parser_tokidx)
00383 #define toksiz                  (parser->parser_toksiz)
00384 #define tokline                 (parser->parser_tokline)
00385 #define lex_input               (parser->parser_lex_input)
00386 #define lex_lastline            (parser->parser_lex_lastline)
00387 #define lex_nextline            (parser->parser_lex_nextline)
00388 #define lex_pbeg                (parser->parser_lex_pbeg)
00389 #define lex_p                   (parser->parser_lex_p)
00390 #define lex_pend                (parser->parser_lex_pend)
00391 #define heredoc_end             (parser->parser_heredoc_end)
00392 #define command_start           (parser->parser_command_start)
00393 #define deferred_nodes          (parser->parser_deferred_nodes)
00394 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00395 #define lex_gets                (parser->parser_lex_gets)
00396 #define lvtbl                   (parser->parser_lvtbl)
00397 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00398 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00399 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00400 #define ruby_sourcefile_string  (parser->parser_ruby_sourcefile_string)
00401 #define current_enc             (parser->enc)
00402 #define yydebug                 (parser->parser_yydebug)
00403 #ifdef RIPPER
00404 #else
00405 #define ruby_eval_tree          (parser->parser_eval_tree)
00406 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00407 #define ruby_debug_lines        (parser->debug_lines)
00408 #define ruby_coverage           (parser->coverage)
00409 #endif
00410 
00411 #if YYPURE
00412 static int yylex(void*, void*);
00413 #else
00414 static int yylex(void*);
00415 #endif
00416 
00417 #ifndef RIPPER
00418 #define yyparse ruby_yyparse
00419 
00420 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00421 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
00422 
00423 static NODE *cond_gen(struct parser_params*,NODE*);
00424 #define cond(node) cond_gen(parser, (node))
00425 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00426 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
00427 
00428 static NODE *newline_node(NODE*);
00429 static void fixpos(NODE*,NODE*);
00430 
00431 static int value_expr_gen(struct parser_params*,NODE*);
00432 static void void_expr_gen(struct parser_params*,NODE*);
00433 static NODE *remove_begin(NODE*);
00434 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00435 #define void_expr0(node) void_expr_gen(parser, (node))
00436 #define void_expr(node) void_expr0((node) = remove_begin(node))
00437 static void void_stmts_gen(struct parser_params*,NODE*);
00438 #define void_stmts(node) void_stmts_gen(parser, (node))
00439 static void reduce_nodes_gen(struct parser_params*,NODE**);
00440 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
00441 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00442 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
00443 
00444 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00445 #define block_append(h,t) block_append_gen(parser,(h),(t))
00446 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00447 #define list_append(l,i) list_append_gen(parser,(l),(i))
00448 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00449 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
00450 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00451 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
00452 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00453 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
00454 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00455 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
00456 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00457 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00458 #define new_evstr(n) new_evstr_gen(parser,(n))
00459 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00460 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
00461 static NODE *splat_array(NODE*);
00462 
00463 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00464 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
00465 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00466 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
00467 
00468 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
00469 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00470 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
00471 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00472 
00473 static NODE *negate_lit(NODE*);
00474 static NODE *ret_args_gen(struct parser_params*,NODE*);
00475 #define ret_args(node) ret_args_gen(parser, (node))
00476 static NODE *arg_blk_pass(NODE*,NODE*);
00477 static NODE *new_yield_gen(struct parser_params*,NODE*);
00478 #define new_yield(node) new_yield_gen(parser, (node))
00479 static NODE *dsym_node_gen(struct parser_params*,NODE*);
00480 #define dsym_node(node) dsym_node_gen(parser, (node))
00481 
00482 static NODE *gettable_gen(struct parser_params*,ID);
00483 #define gettable(id) gettable_gen(parser,(id))
00484 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00485 #define assignable(id,node) assignable_gen(parser, (id), (node))
00486 
00487 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00488 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
00489 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00490 #define attrset(node,id) attrset_gen(parser, (node), (id))
00491 
00492 static void rb_backref_error_gen(struct parser_params*,NODE*);
00493 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
00494 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00495 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
00496 
00497 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00498 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
00499 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
00500 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00501 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
00502 
00503 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00504 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
00505 
00506 static ID  *local_tbl_gen(struct parser_params*);
00507 #define local_tbl() local_tbl_gen(parser)
00508 
00509 static void fixup_nodes(NODE **);
00510 
00511 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00512 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
00513 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00514 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
00515 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00516 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
00517 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00518 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
00519 
00520 #define get_id(id) (id)
00521 #define get_value(val) (val)
00522 #else
00523 #define value_expr(node) ((void)(node))
00524 #define remove_begin(node) (node)
00525 #define rb_dvar_defined(id) 0
00526 #define rb_local_defined(id) 0
00527 static ID ripper_get_id(VALUE);
00528 #define get_id(id) ripper_get_id(id)
00529 static VALUE ripper_get_value(VALUE);
00530 #define get_value(val) ripper_get_value(val)
00531 static VALUE assignable_gen(struct parser_params*,VALUE);
00532 #define assignable(lhs,node) assignable_gen(parser, (lhs))
00533 static int id_is_var_gen(struct parser_params *parser, ID id);
00534 #define id_is_var(id) id_is_var_gen(parser, (id))
00535 
00536 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
00537 
00538 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
00539 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
00540 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
00541 
00542 #endif /* !RIPPER */
00543 
00544 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
00545 
00546 static ID formal_argument_gen(struct parser_params*, ID);
00547 #define formal_argument(id) formal_argument_gen(parser, (id))
00548 static ID shadowing_lvar_gen(struct parser_params*,ID);
00549 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
00550 static void new_bv_gen(struct parser_params*,ID);
00551 #define new_bv(id) new_bv_gen(parser, (id))
00552 
00553 static void local_push_gen(struct parser_params*,int);
00554 #define local_push(top) local_push_gen(parser,(top))
00555 static void local_pop_gen(struct parser_params*);
00556 #define local_pop() local_pop_gen(parser)
00557 static int local_var_gen(struct parser_params*, ID);
00558 #define local_var(id) local_var_gen(parser, (id))
00559 static int arg_var_gen(struct parser_params*, ID);
00560 #define arg_var(id) arg_var_gen(parser, (id))
00561 static int  local_id_gen(struct parser_params*, ID);
00562 #define local_id(id) local_id_gen(parser, (id))
00563 static ID   internal_id_gen(struct parser_params*);
00564 #define internal_id() internal_id_gen(parser)
00565 
00566 static const struct vtable *dyna_push_gen(struct parser_params *);
00567 #define dyna_push() dyna_push_gen(parser)
00568 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00569 #define dyna_pop(node) dyna_pop_gen(parser, (node))
00570 static int dyna_in_block_gen(struct parser_params*);
00571 #define dyna_in_block() dyna_in_block_gen(parser)
00572 #define dyna_var(id) local_var(id)
00573 static int dvar_defined_gen(struct parser_params*,ID,int);
00574 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
00575 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
00576 static int dvar_curr_gen(struct parser_params*,ID);
00577 #define dvar_curr(id) dvar_curr_gen(parser, (id))
00578 
00579 static int lvar_defined_gen(struct parser_params*, ID);
00580 #define lvar_defined(id) lvar_defined_gen(parser, (id))
00581 
00582 #define RE_OPTION_ONCE (1<<16)
00583 #define RE_OPTION_ENCODING_SHIFT 8
00584 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00585 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00586 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00587 #define RE_OPTION_MASK  0xff
00588 #define RE_OPTION_ARG_ENCODING_NONE 32
00589 
00590 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00591 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00592 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00593 #define nd_func u1.id
00594 #if SIZEOF_SHORT == 2
00595 #define nd_term(node) ((signed short)(node)->u2.id)
00596 #else
00597 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00598 #endif
00599 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00600 #define nd_nest u3.cnt
00601 
00602 /****** Ripper *******/
00603 
00604 #ifdef RIPPER
00605 #define RIPPER_VERSION "0.1.0"
00606 
00607 #include "eventids1.c"
00608 #include "eventids2.c"
00609 
00610 static VALUE ripper_dispatch0(struct parser_params*,ID);
00611 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00612 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00613 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00614 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00615 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00616 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
00617 
00618 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00619 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
00620 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
00621 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
00622 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
00623 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
00624 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
00625 
00626 #define yyparse ripper_yyparse
00627 
00628 #define ripper_intern(s) ID2SYM(rb_intern(s))
00629 static VALUE ripper_id2sym(ID);
00630 #ifdef __GNUC__
00631 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00632                            ID2SYM(id) : ripper_id2sym(id))
00633 #endif
00634 
00635 #define arg_new() dispatch0(args_new)
00636 #define arg_add(l,a) dispatch2(args_add, (l), (a))
00637 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
00638 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
00639 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
00640 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
00641 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
00642 
00643 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
00644 #define mrhs_new() dispatch0(mrhs_new)
00645 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
00646 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
00647 
00648 #define mlhs_new() dispatch0(mlhs_new)
00649 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
00650 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
00651 
00652 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
00653         dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
00654 
00655 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
00656 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
00657 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
00658 
00659 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
00660 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
00661 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
00662 
00663 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00664 
00665 static inline VALUE
00666 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
00667 {
00668     NODE *t = (NODE *)tail;
00669     VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
00670     return params_new(f, o, r, p, k, kr, escape_Qundef(b));
00671 }
00672 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00673 
00674 static inline VALUE
00675 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
00676 {
00677     return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
00678 }
00679 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00680 
00681 #define FIXME 0
00682 
00683 #endif /* RIPPER */
00684 
00685 #ifndef RIPPER
00686 # define Qnone 0
00687 # define ifndef_ripper(x) (x)
00688 #else
00689 # define Qnone Qnil
00690 # define ifndef_ripper(x)
00691 #endif
00692 
00693 #ifndef RIPPER
00694 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
00695 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00696 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00697 # define rb_warn4S(file,line,fmt,a)  rb_compile_warn((file), (line), (fmt), (a))
00698 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
00699 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00700 #else
00701 # define rb_warn0(fmt)    ripper_warn0(parser, (fmt))
00702 # define rb_warnI(fmt,a)  ripper_warnI(parser, (fmt), (a))
00703 # define rb_warnS(fmt,a)  ripper_warnS(parser, (fmt), (a))
00704 # define rb_warn4S(file,line,fmt,a)  ripper_warnS(parser, (fmt), (a))
00705 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
00706 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
00707 static void ripper_warn0(struct parser_params*, const char*);
00708 static void ripper_warnI(struct parser_params*, const char*, int);
00709 static void ripper_warnS(struct parser_params*, const char*, const char*);
00710 static void ripper_warning0(struct parser_params*, const char*);
00711 static void ripper_warningS(struct parser_params*, const char*, const char*);
00712 #endif
00713 
00714 #ifdef RIPPER
00715 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00716 # define rb_compile_error ripper_compile_error
00717 # define compile_error ripper_compile_error
00718 # define PARSER_ARG parser,
00719 #else
00720 # define rb_compile_error rb_compile_error_with_enc
00721 # define compile_error parser->nerr++,rb_compile_error_with_enc
00722 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
00723 #endif
00724 
00725 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00726    for instance).  This is too low for Ruby to parse some files, such as
00727    date/format.rb, therefore bump the value up to at least Bison's default. */
00728 #ifdef OLD_YACC
00729 #ifndef YYMAXDEPTH
00730 #define YYMAXDEPTH 10000
00731 #endif
00732 #endif
00733 
00734 #ifndef RIPPER
00735 static void token_info_push(struct parser_params*, const char *token);
00736 static void token_info_pop(struct parser_params*, const char *token);
00737 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
00738 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
00739 #else
00740 #define token_info_push(token) /* nothing */
00741 #define token_info_pop(token) /* nothing */
00742 #endif
00743 
00744 
00745 /* Line 268 of yacc.c  */
00746 #line 747 "parse.c"
00747 
00748 /* Enabling traces.  */
00749 #ifndef YYDEBUG
00750 # define YYDEBUG 1
00751 #endif
00752 
00753 /* Enabling verbose error messages.  */
00754 #ifdef YYERROR_VERBOSE
00755 # undef YYERROR_VERBOSE
00756 # define YYERROR_VERBOSE 1
00757 #else
00758 # define YYERROR_VERBOSE 0
00759 #endif
00760 
00761 /* Enabling the token table.  */
00762 #ifndef YYTOKEN_TABLE
00763 # define YYTOKEN_TABLE 0
00764 #endif
00765 
00766 
00767 /* Tokens.  */
00768 #ifndef YYTOKENTYPE
00769 # define YYTOKENTYPE
00770    /* Put the tokens into the symbol table, so that GDB and other debuggers
00771       know about them.  */
00772    enum yytokentype {
00773      END_OF_INPUT = 0,
00774      keyword_class = 258,
00775      keyword_module = 259,
00776      keyword_def = 260,
00777      keyword_undef = 261,
00778      keyword_begin = 262,
00779      keyword_rescue = 263,
00780      keyword_ensure = 264,
00781      keyword_end = 265,
00782      keyword_if = 266,
00783      keyword_unless = 267,
00784      keyword_then = 268,
00785      keyword_elsif = 269,
00786      keyword_else = 270,
00787      keyword_case = 271,
00788      keyword_when = 272,
00789      keyword_while = 273,
00790      keyword_until = 274,
00791      keyword_for = 275,
00792      keyword_break = 276,
00793      keyword_next = 277,
00794      keyword_redo = 278,
00795      keyword_retry = 279,
00796      keyword_in = 280,
00797      keyword_do = 281,
00798      keyword_do_cond = 282,
00799      keyword_do_block = 283,
00800      keyword_do_LAMBDA = 284,
00801      keyword_return = 285,
00802      keyword_yield = 286,
00803      keyword_super = 287,
00804      keyword_self = 288,
00805      keyword_nil = 289,
00806      keyword_true = 290,
00807      keyword_false = 291,
00808      keyword_and = 292,
00809      keyword_or = 293,
00810      keyword_not = 294,
00811      modifier_if = 295,
00812      modifier_unless = 296,
00813      modifier_while = 297,
00814      modifier_until = 298,
00815      modifier_rescue = 299,
00816      keyword_alias = 300,
00817      keyword_defined = 301,
00818      keyword_BEGIN = 302,
00819      keyword_END = 303,
00820      keyword__LINE__ = 304,
00821      keyword__FILE__ = 305,
00822      keyword__ENCODING__ = 306,
00823      tIDENTIFIER = 307,
00824      tFID = 308,
00825      tGVAR = 309,
00826      tIVAR = 310,
00827      tCONSTANT = 311,
00828      tCVAR = 312,
00829      tLABEL = 313,
00830      tINTEGER = 314,
00831      tFLOAT = 315,
00832      tSTRING_CONTENT = 316,
00833      tCHAR = 317,
00834      tNTH_REF = 318,
00835      tBACK_REF = 319,
00836      tREGEXP_END = 320,
00837      tUPLUS = 130,
00838      tUMINUS = 131,
00839      tPOW = 132,
00840      tCMP = 134,
00841      tEQ = 139,
00842      tEQQ = 140,
00843      tNEQ = 141,
00844      tGEQ = 138,
00845      tLEQ = 137,
00846      tANDOP = 321,
00847      tOROP = 322,
00848      tMATCH = 142,
00849      tNMATCH = 143,
00850      tDOT2 = 128,
00851      tDOT3 = 129,
00852      tAREF = 144,
00853      tASET = 145,
00854      tLSHFT = 135,
00855      tRSHFT = 136,
00856      tCOLON2 = 323,
00857      tCOLON3 = 324,
00858      tOP_ASGN = 325,
00859      tASSOC = 326,
00860      tLPAREN = 327,
00861      tLPAREN_ARG = 328,
00862      tRPAREN = 329,
00863      tLBRACK = 330,
00864      tLBRACE = 331,
00865      tLBRACE_ARG = 332,
00866      tSTAR = 333,
00867      tDSTAR = 334,
00868      tAMPER = 335,
00869      tLAMBDA = 336,
00870      tSYMBEG = 337,
00871      tSTRING_BEG = 338,
00872      tXSTRING_BEG = 339,
00873      tREGEXP_BEG = 340,
00874      tWORDS_BEG = 341,
00875      tQWORDS_BEG = 342,
00876      tSYMBOLS_BEG = 343,
00877      tQSYMBOLS_BEG = 344,
00878      tSTRING_DBEG = 345,
00879      tSTRING_DEND = 346,
00880      tSTRING_DVAR = 347,
00881      tSTRING_END = 348,
00882      tLAMBEG = 349,
00883      tLOWEST = 350,
00884      tUMINUS_NUM = 351,
00885      tLAST_TOKEN = 352
00886    };
00887 #endif
00888 
00889 
00890 
00891 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00892 typedef union YYSTYPE
00893 {
00894 
00895 /* Line 293 of yacc.c  */
00896 #line 691 "ripper.y"
00897 
00898     VALUE val;
00899     NODE *node;
00900     ID id;
00901     int num;
00902     const struct vtable *vars;
00903 
00904 
00905 
00906 /* Line 293 of yacc.c  */
00907 #line 908 "parse.c"
00908 } YYSTYPE;
00909 # define YYSTYPE_IS_TRIVIAL 1
00910 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00911 # define YYSTYPE_IS_DECLARED 1
00912 #endif
00913 
00914 
00915 /* Copy the second part of user declarations.  */
00916 
00917 
00918 /* Line 343 of yacc.c  */
00919 #line 920 "parse.c"
00920 
00921 #ifdef short
00922 # undef short
00923 #endif
00924 
00925 #ifdef YYTYPE_UINT8
00926 typedef YYTYPE_UINT8 yytype_uint8;
00927 #else
00928 typedef unsigned char yytype_uint8;
00929 #endif
00930 
00931 #ifdef YYTYPE_INT8
00932 typedef YYTYPE_INT8 yytype_int8;
00933 #elif (defined __STDC__ || defined __C99__FUNC__ \
00934      || defined __cplusplus || defined _MSC_VER)
00935 typedef signed char yytype_int8;
00936 #else
00937 typedef short int yytype_int8;
00938 #endif
00939 
00940 #ifdef YYTYPE_UINT16
00941 typedef YYTYPE_UINT16 yytype_uint16;
00942 #else
00943 typedef unsigned short int yytype_uint16;
00944 #endif
00945 
00946 #ifdef YYTYPE_INT16
00947 typedef YYTYPE_INT16 yytype_int16;
00948 #else
00949 typedef short int yytype_int16;
00950 #endif
00951 
00952 #ifndef YYSIZE_T
00953 # ifdef __SIZE_TYPE__
00954 #  define YYSIZE_T __SIZE_TYPE__
00955 # elif defined size_t
00956 #  define YYSIZE_T size_t
00957 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00958      || defined __cplusplus || defined _MSC_VER)
00959 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00960 #  define YYSIZE_T size_t
00961 # else
00962 #  define YYSIZE_T unsigned int
00963 # endif
00964 #endif
00965 
00966 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00967 
00968 #ifndef YY_
00969 # if defined YYENABLE_NLS && YYENABLE_NLS
00970 #  if ENABLE_NLS
00971 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00972 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00973 #  endif
00974 # endif
00975 # ifndef YY_
00976 #  define YY_(msgid) msgid
00977 # endif
00978 #endif
00979 
00980 /* Suppress unused-variable warnings by "using" E.  */
00981 #if ! defined lint || defined __GNUC__
00982 # define YYUSE(e) ((void) (e))
00983 #else
00984 # define YYUSE(e) /* empty */
00985 #endif
00986 
00987 /* Identity function, used to suppress warnings about constant conditions.  */
00988 #ifndef lint
00989 # define YYID(n) (n)
00990 #else
00991 #if (defined __STDC__ || defined __C99__FUNC__ \
00992      || defined __cplusplus || defined _MSC_VER)
00993 static int
00994 YYID (int yyi)
00995 #else
00996 static int
00997 YYID (yyi)
00998     int yyi;
00999 #endif
01000 {
01001   return yyi;
01002 }
01003 #endif
01004 
01005 #if ! defined yyoverflow || YYERROR_VERBOSE
01006 
01007 /* The parser invokes alloca or malloc; define the necessary symbols.  */
01008 
01009 # ifdef YYSTACK_USE_ALLOCA
01010 #  if YYSTACK_USE_ALLOCA
01011 #   ifdef __GNUC__
01012 #    define YYSTACK_ALLOC __builtin_alloca
01013 #   elif defined __BUILTIN_VA_ARG_INCR
01014 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
01015 #   elif defined _AIX
01016 #    define YYSTACK_ALLOC __alloca
01017 #   elif defined _MSC_VER
01018 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
01019 #    define alloca _alloca
01020 #   else
01021 #    define YYSTACK_ALLOC alloca
01022 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01023      || defined __cplusplus || defined _MSC_VER)
01024 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01025 #     ifndef EXIT_SUCCESS
01026 #      define EXIT_SUCCESS 0
01027 #     endif
01028 #    endif
01029 #   endif
01030 #  endif
01031 # endif
01032 
01033 # ifdef YYSTACK_ALLOC
01034    /* Pacify GCC's `empty if-body' warning.  */
01035 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
01036 #  ifndef YYSTACK_ALLOC_MAXIMUM
01037     /* The OS might guarantee only one guard page at the bottom of the stack,
01038        and a page size can be as small as 4096 bytes.  So we cannot safely
01039        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01040        to allow for a few compiler-allocated temporary stack slots.  */
01041 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01042 #  endif
01043 # else
01044 #  define YYSTACK_ALLOC YYMALLOC
01045 #  define YYSTACK_FREE YYFREE
01046 #  ifndef YYSTACK_ALLOC_MAXIMUM
01047 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01048 #  endif
01049 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
01050        && ! ((defined YYMALLOC || defined malloc) \
01051              && (defined YYFREE || defined free)))
01052 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01053 #   ifndef EXIT_SUCCESS
01054 #    define EXIT_SUCCESS 0
01055 #   endif
01056 #  endif
01057 #  ifndef YYMALLOC
01058 #   define YYMALLOC malloc
01059 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01060      || defined __cplusplus || defined _MSC_VER)
01061 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01062 #   endif
01063 #  endif
01064 #  ifndef YYFREE
01065 #   define YYFREE free
01066 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01067      || defined __cplusplus || defined _MSC_VER)
01068 void free (void *); /* INFRINGES ON USER NAME SPACE */
01069 #   endif
01070 #  endif
01071 # endif
01072 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01073 
01074 
01075 #if (! defined yyoverflow \
01076      && (! defined __cplusplus \
01077          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01078 
01079 /* A type that is properly aligned for any stack member.  */
01080 union yyalloc
01081 {
01082   yytype_int16 yyss_alloc;
01083   YYSTYPE yyvs_alloc;
01084 };
01085 
01086 /* The size of the maximum gap between one aligned stack and the next.  */
01087 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01088 
01089 /* The size of an array large to enough to hold all stacks, each with
01090    N elements.  */
01091 # define YYSTACK_BYTES(N) \
01092      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01093       + YYSTACK_GAP_MAXIMUM)
01094 
01095 # define YYCOPY_NEEDED 1
01096 
01097 /* Relocate STACK from its old location to the new one.  The
01098    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01099    elements in the stack, and YYPTR gives the new location of the
01100    stack.  Advance YYPTR to a properly aligned location for the next
01101    stack.  */
01102 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01103     do                                                                  \
01104       {                                                                 \
01105         YYSIZE_T yynewbytes;                                            \
01106         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01107         Stack = &yyptr->Stack_alloc;                                    \
01108         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01109         yyptr += yynewbytes / sizeof (*yyptr);                          \
01110       }                                                                 \
01111     while (YYID (0))
01112 
01113 #endif
01114 
01115 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
01116 /* Copy COUNT objects from FROM to TO.  The source and destination do
01117    not overlap.  */
01118 # ifndef YYCOPY
01119 #  if defined __GNUC__ && 1 < __GNUC__
01120 #   define YYCOPY(To, From, Count) \
01121       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01122 #  else
01123 #   define YYCOPY(To, From, Count)              \
01124       do                                        \
01125         {                                       \
01126           YYSIZE_T yyi;                         \
01127           for (yyi = 0; yyi < (Count); yyi++)   \
01128             (To)[yyi] = (From)[yyi];            \
01129         }                                       \
01130       while (YYID (0))
01131 #  endif
01132 # endif
01133 #endif /* !YYCOPY_NEEDED */
01134 
01135 /* YYFINAL -- State number of the termination state.  */
01136 #define YYFINAL  3
01137 /* YYLAST -- Last index in YYTABLE.  */
01138 #define YYLAST   10700
01139 
01140 /* YYNTOKENS -- Number of terminals.  */
01141 #define YYNTOKENS  142
01142 /* YYNNTS -- Number of nonterminals.  */
01143 #define YYNNTS  199
01144 /* YYNRULES -- Number of rules.  */
01145 #define YYNRULES  620
01146 /* YYNRULES -- Number of states.  */
01147 #define YYNSTATES  1057
01148 
01149 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01150 #define YYUNDEFTOK  2
01151 #define YYMAXUTOK   352
01152 
01153 #define YYTRANSLATE(YYX)                                                \
01154   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01155 
01156 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01157 static const yytype_uint8 yytranslate[] =
01158 {
01159        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01160      141,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01161        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01162        2,     2,   140,   127,     2,     2,     2,   125,   120,     2,
01163      136,   137,   123,   121,   134,   122,   133,   124,     2,     2,
01164        2,     2,     2,     2,     2,     2,     2,     2,   115,   139,
01165      117,   113,   116,   114,     2,     2,     2,     2,     2,     2,
01166        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01167        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01168        2,   132,     2,   138,   119,     2,   135,     2,     2,     2,
01169        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01170        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01171        2,     2,     2,   130,   118,   131,   128,     2,    79,    80,
01172       66,    67,    68,     2,    69,    83,    84,    74,    73,    70,
01173       71,    72,    77,    78,    81,    82,     2,     2,     2,     2,
01174        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01175        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01176        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01177        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01178        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01179        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01180        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01181        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01182        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01183        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01184        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01185        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01186       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01187       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01188       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01189       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01190       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01191       65,    75,    76,    85,    86,    87,    88,    89,    90,    91,
01192       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
01193      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
01194      112,   126,   129
01195 };
01196 
01197 #if YYDEBUG
01198 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01199    YYRHS.  */
01200 static const yytype_uint16 yyprhs[] =
01201 {
01202        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01203       23,    24,    30,    35,    38,    40,    42,    46,    49,    51,
01204       52,    58,    59,    64,    68,    72,    76,    79,    83,    87,
01205       91,    95,    99,   104,   106,   110,   114,   121,   127,   133,
01206      139,   145,   149,   153,   157,   161,   163,   167,   171,   173,
01207      177,   181,   185,   188,   190,   192,   194,   196,   198,   203,
01208      204,   210,   212,   215,   219,   224,   230,   235,   241,   244,
01209      247,   250,   253,   256,   258,   262,   264,   268,   270,   273,
01210      277,   283,   286,   291,   294,   299,   301,   305,   307,   311,
01211      314,   318,   320,   324,   326,   328,   333,   337,   341,   345,
01212      349,   352,   354,   356,   358,   363,   367,   371,   375,   379,
01213      382,   384,   386,   388,   391,   393,   397,   399,   401,   403,
01214      405,   407,   409,   411,   413,   415,   417,   418,   423,   425,
01215      427,   429,   431,   433,   435,   437,   439,   441,   443,   445,
01216      447,   449,   451,   453,   455,   457,   459,   461,   463,   465,
01217      467,   469,   471,   473,   475,   477,   479,   481,   483,   485,
01218      487,   489,   491,   493,   495,   497,   499,   501,   503,   505,
01219      507,   509,   511,   513,   515,   517,   519,   521,   523,   525,
01220      527,   529,   531,   533,   535,   537,   539,   541,   543,   545,
01221      547,   549,   551,   553,   555,   557,   559,   561,   563,   565,
01222      569,   575,   579,   585,   592,   598,   604,   610,   616,   621,
01223      625,   629,   633,   637,   641,   645,   649,   653,   657,   662,
01224      667,   670,   673,   677,   681,   685,   689,   693,   697,   701,
01225      705,   709,   713,   717,   721,   725,   728,   731,   735,   739,
01226      743,   747,   748,   753,   760,   762,   764,   766,   769,   774,
01227      777,   781,   783,   785,   787,   789,   792,   797,   800,   802,
01228      805,   808,   813,   815,   816,   819,   822,   825,   827,   829,
01229      832,   836,   841,   845,   850,   853,   855,   857,   859,   861,
01230      863,   865,   867,   869,   871,   873,   875,   876,   881,   882,
01231      886,   887,   888,   894,   898,   902,   905,   909,   913,   915,
01232      920,   924,   926,   927,   934,   939,   943,   946,   948,   951,
01233      954,   961,   968,   969,   970,   978,   979,   980,   988,   994,
01234      999,  1000,  1001,  1011,  1012,  1019,  1020,  1021,  1030,  1031,
01235     1037,  1038,  1045,  1046,  1047,  1057,  1059,  1061,  1063,  1065,
01236     1067,  1069,  1071,  1073,  1075,  1077,  1079,  1081,  1083,  1085,
01237     1087,  1089,  1091,  1093,  1096,  1098,  1100,  1102,  1108,  1110,
01238     1113,  1115,  1117,  1119,  1123,  1125,  1129,  1131,  1136,  1143,
01239     1147,  1153,  1156,  1161,  1163,  1167,  1172,  1175,  1178,  1180,
01240     1183,  1184,  1191,  1200,  1205,  1212,  1217,  1220,  1227,  1230,
01241     1235,  1242,  1245,  1250,  1253,  1258,  1260,  1262,  1264,  1268,
01242     1270,  1275,  1277,  1282,  1284,  1288,  1290,  1292,  1293,  1294,
01243     1295,  1301,  1306,  1308,  1312,  1316,  1317,  1323,  1326,  1331,
01244     1337,  1343,  1346,  1347,  1353,  1354,  1360,  1364,  1365,  1370,
01245     1371,  1376,  1379,  1381,  1386,  1387,  1393,  1394,  1400,  1406,
01246     1408,  1410,  1417,  1419,  1421,  1423,  1425,  1428,  1430,  1433,
01247     1435,  1437,  1439,  1441,  1443,  1445,  1447,  1450,  1454,  1458,
01248     1462,  1466,  1470,  1471,  1475,  1477,  1480,  1484,  1488,  1489,
01249     1493,  1497,  1501,  1505,  1509,  1510,  1514,  1515,  1519,  1520,
01250     1523,  1524,  1527,  1528,  1531,  1533,  1534,  1538,  1539,  1540,
01251     1541,  1548,  1550,  1552,  1554,  1556,  1559,  1561,  1563,  1565,
01252     1567,  1571,  1573,  1575,  1578,  1581,  1583,  1585,  1587,  1589,
01253     1591,  1593,  1595,  1597,  1599,  1601,  1603,  1605,  1607,  1609,
01254     1611,  1613,  1615,  1617,  1619,  1620,  1625,  1628,  1632,  1635,
01255     1640,  1643,  1646,  1648,  1651,  1652,  1659,  1668,  1673,  1680,
01256     1685,  1692,  1695,  1700,  1707,  1710,  1715,  1718,  1723,  1725,
01257     1726,  1728,  1730,  1732,  1734,  1736,  1738,  1740,  1744,  1746,
01258     1750,  1753,  1756,  1758,  1762,  1764,  1768,  1770,  1772,  1775,
01259     1777,  1781,  1785,  1787,  1791,  1793,  1797,  1799,  1801,  1804,
01260     1806,  1808,  1810,  1813,  1816,  1818,  1820,  1821,  1826,  1828,
01261     1831,  1833,  1837,  1841,  1844,  1847,  1849,  1851,  1853,  1855,
01262     1857,  1859,  1861,  1863,  1865,  1867,  1869,  1871,  1872,  1874,
01263     1875,  1877,  1880,  1883,  1884,  1886,  1888,  1890,  1892,  1894,
01264     1897
01265 };
01266 
01267 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01268 static const yytype_int16 yyrhs[] =
01269 {
01270      143,     0,    -1,    -1,   144,   145,    -1,   146,   333,    -1,
01271      340,    -1,   147,    -1,   146,   339,   147,    -1,     1,   147,
01272       -1,   154,    -1,    -1,    47,   148,   130,   145,   131,    -1,
01273      150,   262,   230,   265,    -1,   151,   333,    -1,   340,    -1,
01274      152,    -1,   151,   339,   152,    -1,     1,   154,    -1,   154,
01275       -1,    -1,    47,   153,   130,   145,   131,    -1,    -1,    45,
01276      177,   155,   177,    -1,    45,    54,    54,    -1,    45,    54,
01277       64,    -1,    45,    54,    63,    -1,     6,   178,    -1,   154,
01278       40,   158,    -1,   154,    41,   158,    -1,   154,    42,   158,
01279       -1,   154,    43,   158,    -1,   154,    44,   154,    -1,    48,
01280      130,   150,   131,    -1,   156,    -1,   165,   113,   159,    -1,
01281      297,    87,   159,    -1,   215,   132,   188,   336,    87,   159,
01282       -1,   215,   133,    52,    87,   159,    -1,   215,   133,    56,
01283       87,   159,    -1,   215,    85,    56,    87,   159,    -1,   215,
01284       85,    52,    87,   159,    -1,   298,    87,   159,    -1,   172,
01285      113,   195,    -1,   165,   113,   184,    -1,   165,   113,   195,
01286       -1,   157,    -1,   172,   113,   159,    -1,   172,   113,   156,
01287       -1,   159,    -1,   157,    37,   157,    -1,   157,    38,   157,
01288       -1,    39,   334,   157,    -1,   127,   159,    -1,   182,    -1,
01289      157,    -1,   164,    -1,   160,    -1,   251,    -1,   251,   332,
01290      330,   190,    -1,    -1,    94,   162,   238,   150,   131,    -1,
01291      329,    -1,   163,   190,    -1,   163,   190,   161,    -1,   215,
01292      133,   330,   190,    -1,   215,   133,   330,   190,   161,    -1,
01293      215,    85,   330,   190,    -1,   215,    85,   330,   190,   161,
01294       -1,    32,   190,    -1,    31,   190,    -1,    30,   189,    -1,
01295       21,   189,    -1,    22,   189,    -1,   167,    -1,    89,   166,
01296      335,    -1,   167,    -1,    89,   166,   335,    -1,   169,    -1,
01297      169,   168,    -1,   169,    95,   171,    -1,   169,    95,   171,
01298      134,   170,    -1,   169,    95,    -1,   169,    95,   134,   170,
01299       -1,    95,   171,    -1,    95,   171,   134,   170,    -1,    95,
01300       -1,    95,   134,   170,    -1,   171,    -1,    89,   166,   335,
01301       -1,   168,   134,    -1,   169,   168,   134,    -1,   168,    -1,
01302      170,   134,   168,    -1,   294,    -1,   295,    -1,   215,   132,
01303      188,   336,    -1,   215,   133,    52,    -1,   215,    85,    52,
01304       -1,   215,   133,    56,    -1,   215,    85,    56,    -1,    86,
01305       56,    -1,   298,    -1,   294,    -1,   295,    -1,   215,   132,
01306      188,   336,    -1,   215,   133,    52,    -1,   215,    85,    52,
01307       -1,   215,   133,    56,    -1,   215,    85,    56,    -1,    86,
01308       56,    -1,   298,    -1,    52,    -1,    56,    -1,    86,   173,
01309       -1,   173,    -1,   215,    85,   173,    -1,    52,    -1,    56,
01310       -1,    53,    -1,   180,    -1,   181,    -1,   175,    -1,   290,
01311       -1,   176,    -1,   292,    -1,   177,    -1,    -1,   178,   134,
01312      179,   177,    -1,   118,    -1,   119,    -1,   120,    -1,    69,
01313       -1,    70,    -1,    71,    -1,    77,    -1,    78,    -1,   116,
01314       -1,    73,    -1,   117,    -1,    74,    -1,    72,    -1,    83,
01315       -1,    84,    -1,   121,    -1,   122,    -1,   123,    -1,    95,
01316       -1,   124,    -1,   125,    -1,    68,    -1,    96,    -1,   127,
01317       -1,   128,    -1,    66,    -1,    67,    -1,    81,    -1,    82,
01318       -1,   135,    -1,    49,    -1,    50,    -1,    51,    -1,    47,
01319       -1,    48,    -1,    45,    -1,    37,    -1,     7,    -1,    21,
01320       -1,    16,    -1,     3,    -1,     5,    -1,    46,    -1,    26,
01321       -1,    15,    -1,    14,    -1,    10,    -1,     9,    -1,    36,
01322       -1,    20,    -1,    25,    -1,     4,    -1,    22,    -1,    34,
01323       -1,    39,    -1,    38,    -1,    23,    -1,     8,    -1,    24,
01324       -1,    30,    -1,    33,    -1,    32,    -1,    13,    -1,    35,
01325       -1,     6,    -1,    17,    -1,    31,    -1,    11,    -1,    12,
01326       -1,    18,    -1,    19,    -1,   172,   113,   182,    -1,   172,
01327      113,   182,    44,   182,    -1,   297,    87,   182,    -1,   297,
01328       87,   182,    44,   182,    -1,   215,   132,   188,   336,    87,
01329      182,    -1,   215,   133,    52,    87,   182,    -1,   215,   133,
01330       56,    87,   182,    -1,   215,    85,    52,    87,   182,    -1,
01331      215,    85,    56,    87,   182,    -1,    86,    56,    87,   182,
01332       -1,   298,    87,   182,    -1,   182,    79,   182,    -1,   182,
01333       80,   182,    -1,   182,   121,   182,    -1,   182,   122,   182,
01334       -1,   182,   123,   182,    -1,   182,   124,   182,    -1,   182,
01335      125,   182,    -1,   182,    68,   182,    -1,   126,    59,    68,
01336      182,    -1,   126,    60,    68,   182,    -1,    66,   182,    -1,
01337       67,   182,    -1,   182,   118,   182,    -1,   182,   119,   182,
01338       -1,   182,   120,   182,    -1,   182,    69,   182,    -1,   182,
01339      116,   182,    -1,   182,    73,   182,    -1,   182,   117,   182,
01340       -1,   182,    74,   182,    -1,   182,    70,   182,    -1,   182,
01341       71,   182,    -1,   182,    72,   182,    -1,   182,    77,   182,
01342       -1,   182,    78,   182,    -1,   127,   182,    -1,   128,   182,
01343       -1,   182,    83,   182,    -1,   182,    84,   182,    -1,   182,
01344       75,   182,    -1,   182,    76,   182,    -1,    -1,    46,   334,
01345      183,   182,    -1,   182,   114,   182,   334,   115,   182,    -1,
01346      196,    -1,   182,    -1,   340,    -1,   194,   337,    -1,   194,
01347      134,   327,   337,    -1,   327,   337,    -1,   136,   188,   335,
01348       -1,   340,    -1,   186,    -1,   340,    -1,   189,    -1,   194,
01349      134,    -1,   194,   134,   327,   134,    -1,   327,   134,    -1,
01350      164,    -1,   194,   193,    -1,   327,   193,    -1,   194,   134,
01351      327,   193,    -1,   192,    -1,    -1,   191,   189,    -1,    97,
01352      184,    -1,   134,   192,    -1,   340,    -1,   184,    -1,    95,
01353      184,    -1,   194,   134,   184,    -1,   194,   134,    95,   184,
01354       -1,   194,   134,   184,    -1,   194,   134,    95,   184,    -1,
01355       95,   184,    -1,   266,    -1,   267,    -1,   270,    -1,   271,
01356       -1,   272,    -1,   277,    -1,   275,    -1,   278,    -1,   296,
01357       -1,   298,    -1,    53,    -1,    -1,   216,   197,   149,   226,
01358       -1,    -1,    90,   198,   335,    -1,    -1,    -1,    90,   199,
01359      157,   200,   335,    -1,    89,   150,   137,    -1,   215,    85,
01360       56,    -1,    86,    56,    -1,    92,   185,   138,    -1,    93,
01361      326,   131,    -1,    30,    -1,    31,   136,   189,   335,    -1,
01362       31,   136,   335,    -1,    31,    -1,    -1,    46,   334,   136,
01363      201,   157,   335,    -1,    39,   136,   157,   335,    -1,    39,
01364      136,   335,    -1,   163,   257,    -1,   252,    -1,   252,   257,
01365       -1,    98,   243,    -1,   217,   158,   227,   150,   229,   226,
01366       -1,   218,   158,   227,   150,   230,   226,    -1,    -1,    -1,
01367      219,   202,   158,   228,   203,   150,   226,    -1,    -1,    -1,
01368      220,   204,   158,   228,   205,   150,   226,    -1,   221,   158,
01369      333,   260,   226,    -1,   221,   333,   260,   226,    -1,    -1,
01370       -1,   222,   231,    25,   206,   158,   228,   207,   150,   226,
01371       -1,    -1,   223,   174,   299,   208,   149,   226,    -1,    -1,
01372       -1,   223,    83,   157,   209,   338,   210,   149,   226,    -1,
01373       -1,   224,   174,   211,   149,   226,    -1,    -1,   225,   175,
01374      212,   301,   149,   226,    -1,    -1,    -1,   225,   324,   332,
01375      213,   175,   214,   301,   149,   226,    -1,    21,    -1,    22,
01376       -1,    23,    -1,    24,    -1,   196,    -1,     7,    -1,    11,
01377       -1,    12,    -1,    18,    -1,    19,    -1,    16,    -1,    20,
01378       -1,     3,    -1,     4,    -1,     5,    -1,    10,    -1,   338,
01379       -1,    13,    -1,   338,    13,    -1,   338,    -1,    27,    -1,
01380      230,    -1,    14,   158,   227,   150,   229,    -1,   340,    -1,
01381       15,   150,    -1,   172,    -1,   165,    -1,   306,    -1,    89,
01382      234,   335,    -1,   232,    -1,   233,   134,   232,    -1,   233,
01383       -1,   233,   134,    95,   306,    -1,   233,   134,    95,   306,
01384      134,   233,    -1,   233,   134,    95,    -1,   233,   134,    95,
01385      134,   233,    -1,    95,   306,    -1,    95,   306,   134,   233,
01386       -1,    95,    -1,    95,   134,   233,    -1,   311,   134,   314,
01387      323,    -1,   311,   323,    -1,   314,   323,    -1,   322,    -1,
01388      134,   235,    -1,    -1,   308,   134,   317,   134,   320,   236,
01389       -1,   308,   134,   317,   134,   320,   134,   308,   236,    -1,
01390      308,   134,   317,   236,    -1,   308,   134,   317,   134,   308,
01391      236,    -1,   308,   134,   320,   236,    -1,   308,   134,    -1,
01392      308,   134,   320,   134,   308,   236,    -1,   308,   236,    -1,
01393      317,   134,   320,   236,    -1,   317,   134,   320,   134,   308,
01394      236,    -1,   317,   236,    -1,   317,   134,   308,   236,    -1,
01395      320,   236,    -1,   320,   134,   308,   236,    -1,   235,    -1,
01396      340,    -1,   239,    -1,   118,   240,   118,    -1,    76,    -1,
01397      118,   237,   240,   118,    -1,   334,    -1,   334,   139,   241,
01398      334,    -1,   242,    -1,   241,   134,   242,    -1,    52,    -1,
01399      305,    -1,    -1,    -1,    -1,   244,   245,   247,   246,   248,
01400       -1,   136,   304,   240,   137,    -1,   304,    -1,   111,   150,
01401      131,    -1,    29,   150,    10,    -1,    -1,    28,   250,   238,
01402      150,    10,    -1,   164,   249,    -1,   251,   332,   330,   187,
01403       -1,   251,   332,   330,   187,   257,    -1,   251,   332,   330,
01404      190,   249,    -1,   163,   186,    -1,    -1,   215,   133,   330,
01405      253,   187,    -1,    -1,   215,    85,   330,   254,   186,    -1,
01406      215,    85,   331,    -1,    -1,   215,   133,   255,   186,    -1,
01407       -1,   215,    85,   256,   186,    -1,    32,   186,    -1,    32,
01408       -1,   215,   132,   188,   336,    -1,    -1,   130,   258,   238,
01409      150,   131,    -1,    -1,    26,   259,   238,   150,    10,    -1,
01410       17,   194,   227,   150,   261,    -1,   230,    -1,   260,    -1,
01411        8,   263,   264,   227,   150,   262,    -1,   340,    -1,   184,
01412       -1,   195,    -1,   340,    -1,    88,   172,    -1,   340,    -1,
01413        9,   150,    -1,   340,    -1,   293,    -1,   290,    -1,   292,
01414       -1,   268,    -1,    62,    -1,   269,    -1,   268,   269,    -1,
01415      100,   281,   110,    -1,   101,   282,   110,    -1,   102,   283,
01416       65,    -1,   103,   140,   110,    -1,   103,   273,   110,    -1,
01417       -1,   273,   274,   140,    -1,   284,    -1,   274,   284,    -1,
01418      105,   140,   110,    -1,   105,   276,   110,    -1,    -1,   276,
01419      274,   140,    -1,   104,   140,   110,    -1,   104,   279,   110,
01420       -1,   106,   140,   110,    -1,   106,   280,   110,    -1,    -1,
01421      279,    61,   140,    -1,    -1,   280,    61,   140,    -1,    -1,
01422      281,   284,    -1,    -1,   282,   284,    -1,    -1,   283,   284,
01423       -1,    61,    -1,    -1,   109,   285,   289,    -1,    -1,    -1,
01424       -1,   107,   286,   287,   288,   150,   108,    -1,    54,    -1,
01425       55,    -1,    57,    -1,   298,    -1,    99,   291,    -1,   175,
01426       -1,    55,    -1,    54,    -1,    57,    -1,    99,   282,   110,
01427       -1,    59,    -1,    60,    -1,   126,    59,    -1,   126,    60,
01428       -1,    52,    -1,    55,    -1,    54,    -1,    56,    -1,    57,
01429       -1,    34,    -1,    33,    -1,    35,    -1,    36,    -1,    50,
01430       -1,    49,    -1,    51,    -1,   294,    -1,   295,    -1,   294,
01431       -1,   295,    -1,    63,    -1,    64,    -1,   338,    -1,    -1,
01432      117,   300,   158,   338,    -1,     1,   338,    -1,   136,   304,
01433      335,    -1,   304,   338,    -1,   312,   134,   314,   323,    -1,
01434      312,   323,    -1,   314,   323,    -1,   322,    -1,   134,   302,
01435       -1,    -1,   308,   134,   318,   134,   320,   303,    -1,   308,
01436      134,   318,   134,   320,   134,   308,   303,    -1,   308,   134,
01437      318,   303,    -1,   308,   134,   318,   134,   308,   303,    -1,
01438      308,   134,   320,   303,    -1,   308,   134,   320,   134,   308,
01439      303,    -1,   308,   303,    -1,   318,   134,   320,   303,    -1,
01440      318,   134,   320,   134,   308,   303,    -1,   318,   303,    -1,
01441      318,   134,   308,   303,    -1,   320,   303,    -1,   320,   134,
01442      308,   303,    -1,   302,    -1,    -1,    56,    -1,    55,    -1,
01443       54,    -1,    57,    -1,   305,    -1,    52,    -1,   306,    -1,
01444       89,   234,   335,    -1,   307,    -1,   308,   134,   307,    -1,
01445       58,   184,    -1,    58,   215,    -1,   310,    -1,   311,   134,
01446      310,    -1,   309,    -1,   312,   134,   309,    -1,    68,    -1,
01447       96,    -1,   313,    52,    -1,   313,    -1,    52,   113,   184,
01448       -1,    52,   113,   215,    -1,   316,    -1,   317,   134,   316,
01449       -1,   315,    -1,   318,   134,   315,    -1,   123,    -1,    95,
01450       -1,   319,    52,    -1,   319,    -1,   120,    -1,    97,    -1,
01451      321,    52,    -1,   134,   322,    -1,   340,    -1,   296,    -1,
01452       -1,   136,   325,   157,   335,    -1,   340,    -1,   327,   337,
01453       -1,   328,    -1,   327,   134,   328,    -1,   184,    88,   184,
01454       -1,    58,   184,    -1,    96,   184,    -1,    52,    -1,    56,
01455       -1,    53,    -1,    52,    -1,    56,    -1,    53,    -1,   180,
01456       -1,    52,    -1,    53,    -1,   180,    -1,   133,    -1,    85,
01457       -1,    -1,   339,    -1,    -1,   141,    -1,   334,   137,    -1,
01458      334,   138,    -1,    -1,   141,    -1,   134,    -1,   139,    -1,
01459      141,    -1,   338,    -1,   339,   139,    -1,    -1
01460 };
01461 
01462 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01463 static const yytype_uint16 yyrline[] =
01464 {
01465        0,   855,   855,   855,   886,   897,   906,   914,   922,   928,
01466      930,   929,   950,   983,   994,  1003,  1011,  1019,  1025,  1030,
01467     1029,  1050,  1050,  1058,  1066,  1077,  1087,  1095,  1104,  1113,
01468     1126,  1139,  1148,  1160,  1161,  1171,  1176,  1197,  1202,  1207,
01469     1217,  1222,  1232,  1241,  1250,  1259,  1262,  1271,  1283,  1284,
01470     1292,  1300,  1308,  1316,  1319,  1331,  1332,  1335,  1336,  1348,
01471     1347,  1369,  1379,  1388,  1401,  1410,  1422,  1431,  1443,  1452,
01472     1461,  1469,  1477,  1487,  1488,  1498,  1499,  1509,  1517,  1525,
01473     1533,  1542,  1550,  1559,  1567,  1576,  1584,  1595,  1596,  1606,
01474     1614,  1624,  1632,  1642,  1646,  1650,  1658,  1666,  1674,  1682,
01475     1694,  1704,  1716,  1725,  1734,  1742,  1750,  1758,  1766,  1779,
01476     1792,  1803,  1811,  1814,  1822,  1830,  1840,  1841,  1842,  1843,
01477     1848,  1859,  1860,  1863,  1871,  1874,  1882,  1882,  1892,  1893,
01478     1894,  1895,  1896,  1897,  1898,  1899,  1900,  1901,  1902,  1903,
01479     1904,  1905,  1906,  1907,  1908,  1909,  1910,  1911,  1912,  1913,
01480     1914,  1915,  1916,  1917,  1918,  1919,  1920,  1921,  1924,  1924,
01481     1924,  1925,  1925,  1926,  1926,  1926,  1927,  1927,  1927,  1927,
01482     1928,  1928,  1928,  1928,  1929,  1929,  1929,  1930,  1930,  1930,
01483     1930,  1931,  1931,  1931,  1931,  1932,  1932,  1932,  1932,  1933,
01484     1933,  1933,  1933,  1934,  1934,  1934,  1934,  1935,  1935,  1938,
01485     1947,  1957,  1962,  1972,  1998,  2003,  2008,  2013,  2023,  2033,
01486     2044,  2058,  2072,  2080,  2088,  2096,  2104,  2112,  2120,  2129,
01487     2138,  2146,  2154,  2162,  2170,  2178,  2186,  2194,  2202,  2210,
01488     2218,  2226,  2234,  2242,  2253,  2261,  2269,  2277,  2285,  2293,
01489     2301,  2309,  2309,  2319,  2329,  2335,  2347,  2348,  2352,  2360,
01490     2370,  2380,  2381,  2384,  2385,  2386,  2390,  2398,  2408,  2417,
01491     2425,  2435,  2444,  2453,  2453,  2465,  2475,  2479,  2485,  2493,
01492     2501,  2515,  2531,  2545,  2560,  2570,  2571,  2572,  2573,  2574,
01493     2575,  2576,  2577,  2578,  2579,  2580,  2589,  2588,  2616,  2616,
01494     2625,  2629,  2624,  2638,  2646,  2654,  2662,  2675,  2683,  2691,
01495     2699,  2707,  2715,  2715,  2725,  2733,  2741,  2751,  2752,  2762,
01496     2766,  2778,  2790,  2790,  2790,  2801,  2801,  2801,  2812,  2823,
01497     2832,  2834,  2831,  2898,  2897,  2919,  2924,  2918,  2943,  2942,
01498     2964,  2963,  2986,  2987,  2986,  3007,  3015,  3023,  3031,  3041,
01499     3053,  3059,  3065,  3071,  3077,  3083,  3089,  3095,  3101,  3107,
01500     3117,  3123,  3128,  3129,  3136,  3141,  3144,  3145,  3158,  3159,
01501     3169,  3170,  3173,  3181,  3191,  3199,  3209,  3217,  3226,  3235,
01502     3243,  3251,  3260,  3272,  3280,  3291,  3295,  3299,  3303,  3309,
01503     3314,  3319,  3323,  3327,  3331,  3335,  3339,  3347,  3351,  3355,
01504     3359,  3363,  3367,  3371,  3375,  3379,  3385,  3386,  3392,  3401,
01505     3410,  3421,  3425,  3435,  3442,  3451,  3459,  3465,  3468,  3473,
01506     3465,  3489,  3497,  3507,  3511,  3518,  3517,  3538,  3554,  3563,
01507     3575,  3589,  3599,  3598,  3615,  3614,  3630,  3639,  3638,  3656,
01508     3655,  3672,  3680,  3688,  3703,  3702,  3722,  3721,  3742,  3754,
01509     3755,  3758,  3777,  3780,  3788,  3796,  3799,  3803,  3806,  3814,
01510     3817,  3818,  3826,  3829,  3846,  3847,  3848,  3858,  3868,  3895,
01511     3960,  3969,  3980,  3987,  3997,  4005,  4015,  4024,  4035,  4042,
01512     4060,  4069,  4079,  4088,  4099,  4106,  4117,  4124,  4139,  4146,
01513     4157,  4164,  4175,  4182,  4211,  4213,  4212,  4229,  4235,  4240,
01514     4228,  4259,  4267,  4275,  4283,  4286,  4297,  4298,  4299,  4300,
01515     4303,  4314,  4315,  4316,  4324,  4334,  4335,  4336,  4337,  4338,
01516     4341,  4342,  4343,  4344,  4345,  4346,  4347,  4350,  4363,  4373,
01517     4381,  4391,  4392,  4395,  4404,  4403,  4412,  4424,  4434,  4442,
01518     4446,  4450,  4454,  4460,  4465,  4470,  4474,  4478,  4482,  4486,
01519     4490,  4494,  4498,  4502,  4506,  4510,  4514,  4518,  4522,  4527,
01520     4533,  4542,  4551,  4560,  4571,  4572,  4579,  4588,  4607,  4614,
01521     4627,  4639,  4651,  4659,  4676,  4684,  4700,  4701,  4704,  4709,
01522     4715,  4727,  4739,  4747,  4763,  4771,  4787,  4788,  4791,  4804,
01523     4815,  4816,  4819,  4836,  4840,  4850,  4860,  4860,  4889,  4890,
01524     4900,  4907,  4917,  4925,  4933,  4945,  4946,  4947,  4950,  4951,
01525     4952,  4953,  4956,  4957,  4958,  4961,  4966,  4973,  4974,  4977,
01526     4978,  4981,  4984,  4987,  4988,  4989,  4992,  4993,  4996,  4997,
01527     5001
01528 };
01529 #endif
01530 
01531 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01533    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01534 static const char *const yytname[] =
01535 {
01536   "\"end-of-input\"", "error", "$undefined", "keyword_class",
01537   "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
01538   "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
01539   "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
01540   "keyword_case", "keyword_when", "keyword_while", "keyword_until",
01541   "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
01542   "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
01543   "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
01544   "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
01545   "keyword_true", "keyword_false", "keyword_and", "keyword_or",
01546   "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
01547   "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
01548   "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
01549   "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
01550   "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
01551   "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
01552   "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
01553   "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
01554   "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
01555   "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
01556   "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
01557   "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
01558   "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
01559   "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
01560   "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
01561   "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
01562   "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
01563   "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
01564   "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
01565   "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
01566   "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
01567   "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
01568   "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
01569   "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
01570   "arg_value", "aref_args", "paren_args", "opt_paren_args",
01571   "opt_call_args", "call_args", "command_args", "@8", "block_arg",
01572   "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
01573   "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "@20", "@21",
01574   "@22", "@23", "@24", "$@25", "$@26", "primary_value", "k_begin", "k_if",
01575   "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
01576   "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
01577   "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
01578   "opt_block_args_tail", "block_param", "opt_block_param",
01579   "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@27",
01580   "@28", "@29", "f_larglist", "lambda_body", "do_block", "@30",
01581   "block_call", "method_call", "@31", "@32", "@33", "@34", "brace_block",
01582   "@35", "@36", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
01583   "opt_ensure", "literal", "strings", "string", "string1", "xstring",
01584   "regexp", "words", "word_list", "word", "symbols", "symbol_list",
01585   "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
01586   "xstring_contents", "regexp_contents", "string_content", "@37", "@38",
01587   "@39", "@40", "string_dvar", "symbol", "sym", "dsym", "numeric",
01588   "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
01589   "superclass", "$@41", "f_arglist", "args_tail", "opt_args_tail",
01590   "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
01591   "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
01592   "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
01593   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
01594   "singleton", "$@42", "assoc_list", "assocs", "assoc", "operation",
01595   "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
01596   "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01597 };
01598 #endif
01599 
01600 # ifdef YYPRINT
01601 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01602    token YYLEX-NUM.  */
01603 static const yytype_uint16 yytoknum[] =
01604 {
01605        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01606      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01607      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01608      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01609      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01610      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01611      315,   316,   317,   318,   319,   320,   130,   131,   132,   134,
01612      139,   140,   141,   138,   137,   321,   322,   142,   143,   128,
01613      129,   144,   145,   135,   136,   323,   324,   325,   326,   327,
01614      328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
01615      338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
01616      348,   349,   350,    61,    63,    58,    62,    60,   124,    94,
01617       38,    43,    45,    42,    47,    37,   351,    33,   126,   352,
01618      123,   125,    91,    46,    44,    96,    40,    41,    93,    59,
01619       32,    10
01620 };
01621 # endif
01622 
01623 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01624 static const yytype_uint16 yyr1[] =
01625 {
01626        0,   142,   144,   143,   145,   146,   146,   146,   146,   147,
01627      148,   147,   149,   150,   151,   151,   151,   151,   152,   153,
01628      152,   155,   154,   154,   154,   154,   154,   154,   154,   154,
01629      154,   154,   154,   154,   154,   154,   154,   154,   154,   154,
01630      154,   154,   154,   154,   154,   154,   156,   156,   157,   157,
01631      157,   157,   157,   157,   158,   159,   159,   160,   160,   162,
01632      161,   163,   164,   164,   164,   164,   164,   164,   164,   164,
01633      164,   164,   164,   165,   165,   166,   166,   167,   167,   167,
01634      167,   167,   167,   167,   167,   167,   167,   168,   168,   169,
01635      169,   170,   170,   171,   171,   171,   171,   171,   171,   171,
01636      171,   171,   172,   172,   172,   172,   172,   172,   172,   172,
01637      172,   173,   173,   174,   174,   174,   175,   175,   175,   175,
01638      175,   176,   176,   177,   177,   178,   179,   178,   180,   180,
01639      180,   180,   180,   180,   180,   180,   180,   180,   180,   180,
01640      180,   180,   180,   180,   180,   180,   180,   180,   180,   180,
01641      180,   180,   180,   180,   180,   180,   180,   180,   181,   181,
01642      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01643      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01644      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01645      181,   181,   181,   181,   181,   181,   181,   181,   181,   182,
01646      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01647      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01648      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01649      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01650      182,   183,   182,   182,   182,   184,   185,   185,   185,   185,
01651      186,   187,   187,   188,   188,   188,   188,   188,   189,   189,
01652      189,   189,   189,   191,   190,   192,   193,   193,   194,   194,
01653      194,   194,   195,   195,   195,   196,   196,   196,   196,   196,
01654      196,   196,   196,   196,   196,   196,   197,   196,   198,   196,
01655      199,   200,   196,   196,   196,   196,   196,   196,   196,   196,
01656      196,   196,   201,   196,   196,   196,   196,   196,   196,   196,
01657      196,   196,   202,   203,   196,   204,   205,   196,   196,   196,
01658      206,   207,   196,   208,   196,   209,   210,   196,   211,   196,
01659      212,   196,   213,   214,   196,   196,   196,   196,   196,   215,
01660      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
01661      226,   227,   227,   227,   228,   228,   229,   229,   230,   230,
01662      231,   231,   232,   232,   233,   233,   234,   234,   234,   234,
01663      234,   234,   234,   234,   234,   235,   235,   235,   235,   236,
01664      236,   237,   237,   237,   237,   237,   237,   237,   237,   237,
01665      237,   237,   237,   237,   237,   237,   238,   238,   239,   239,
01666      239,   240,   240,   241,   241,   242,   242,   244,   245,   246,
01667      243,   247,   247,   248,   248,   250,   249,   251,   251,   251,
01668      251,   252,   253,   252,   254,   252,   252,   255,   252,   256,
01669      252,   252,   252,   252,   258,   257,   259,   257,   260,   261,
01670      261,   262,   262,   263,   263,   263,   264,   264,   265,   265,
01671      266,   266,   266,   267,   268,   268,   268,   269,   270,   271,
01672      272,   272,   273,   273,   274,   274,   275,   275,   276,   276,
01673      277,   277,   278,   278,   279,   279,   280,   280,   281,   281,
01674      282,   282,   283,   283,   284,   285,   284,   286,   287,   288,
01675      284,   289,   289,   289,   289,   290,   291,   291,   291,   291,
01676      292,   293,   293,   293,   293,   294,   294,   294,   294,   294,
01677      295,   295,   295,   295,   295,   295,   295,   296,   296,   297,
01678      297,   298,   298,   299,   300,   299,   299,   301,   301,   302,
01679      302,   302,   302,   303,   303,   304,   304,   304,   304,   304,
01680      304,   304,   304,   304,   304,   304,   304,   304,   304,   304,
01681      305,   305,   305,   305,   306,   306,   307,   307,   308,   308,
01682      309,   310,   311,   311,   312,   312,   313,   313,   314,   314,
01683      315,   316,   317,   317,   318,   318,   319,   319,   320,   320,
01684      321,   321,   322,   323,   323,   324,   325,   324,   326,   326,
01685      327,   327,   328,   328,   328,   329,   329,   329,   330,   330,
01686      330,   330,   331,   331,   331,   332,   332,   333,   333,   334,
01687      334,   335,   336,   337,   337,   337,   338,   338,   339,   339,
01688      340
01689 };
01690 
01691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01692 static const yytype_uint8 yyr2[] =
01693 {
01694        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01695        0,     5,     4,     2,     1,     1,     3,     2,     1,     0,
01696        5,     0,     4,     3,     3,     3,     2,     3,     3,     3,
01697        3,     3,     4,     1,     3,     3,     6,     5,     5,     5,
01698        5,     3,     3,     3,     3,     1,     3,     3,     1,     3,
01699        3,     3,     2,     1,     1,     1,     1,     1,     4,     0,
01700        5,     1,     2,     3,     4,     5,     4,     5,     2,     2,
01701        2,     2,     2,     1,     3,     1,     3,     1,     2,     3,
01702        5,     2,     4,     2,     4,     1,     3,     1,     3,     2,
01703        3,     1,     3,     1,     1,     4,     3,     3,     3,     3,
01704        2,     1,     1,     1,     4,     3,     3,     3,     3,     2,
01705        1,     1,     1,     2,     1,     3,     1,     1,     1,     1,
01706        1,     1,     1,     1,     1,     1,     0,     4,     1,     1,
01707        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01708        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01709        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01710        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01711        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01712        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01713        1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
01714        5,     3,     5,     6,     5,     5,     5,     5,     4,     3,
01715        3,     3,     3,     3,     3,     3,     3,     3,     4,     4,
01716        2,     2,     3,     3,     3,     3,     3,     3,     3,     3,
01717        3,     3,     3,     3,     3,     2,     2,     3,     3,     3,
01718        3,     0,     4,     6,     1,     1,     1,     2,     4,     2,
01719        3,     1,     1,     1,     1,     2,     4,     2,     1,     2,
01720        2,     4,     1,     0,     2,     2,     2,     1,     1,     2,
01721        3,     4,     3,     4,     2,     1,     1,     1,     1,     1,
01722        1,     1,     1,     1,     1,     1,     0,     4,     0,     3,
01723        0,     0,     5,     3,     3,     2,     3,     3,     1,     4,
01724        3,     1,     0,     6,     4,     3,     2,     1,     2,     2,
01725        6,     6,     0,     0,     7,     0,     0,     7,     5,     4,
01726        0,     0,     9,     0,     6,     0,     0,     8,     0,     5,
01727        0,     6,     0,     0,     9,     1,     1,     1,     1,     1,
01728        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01729        1,     1,     1,     2,     1,     1,     1,     5,     1,     2,
01730        1,     1,     1,     3,     1,     3,     1,     4,     6,     3,
01731        5,     2,     4,     1,     3,     4,     2,     2,     1,     2,
01732        0,     6,     8,     4,     6,     4,     2,     6,     2,     4,
01733        6,     2,     4,     2,     4,     1,     1,     1,     3,     1,
01734        4,     1,     4,     1,     3,     1,     1,     0,     0,     0,
01735        5,     4,     1,     3,     3,     0,     5,     2,     4,     5,
01736        5,     2,     0,     5,     0,     5,     3,     0,     4,     0,
01737        4,     2,     1,     4,     0,     5,     0,     5,     5,     1,
01738        1,     6,     1,     1,     1,     1,     2,     1,     2,     1,
01739        1,     1,     1,     1,     1,     1,     2,     3,     3,     3,
01740        3,     3,     0,     3,     1,     2,     3,     3,     0,     3,
01741        3,     3,     3,     3,     0,     3,     0,     3,     0,     2,
01742        0,     2,     0,     2,     1,     0,     3,     0,     0,     0,
01743        6,     1,     1,     1,     1,     2,     1,     1,     1,     1,
01744        3,     1,     1,     2,     2,     1,     1,     1,     1,     1,
01745        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01746        1,     1,     1,     1,     0,     4,     2,     3,     2,     4,
01747        2,     2,     1,     2,     0,     6,     8,     4,     6,     4,
01748        6,     2,     4,     6,     2,     4,     2,     4,     1,     0,
01749        1,     1,     1,     1,     1,     1,     1,     3,     1,     3,
01750        2,     2,     1,     3,     1,     3,     1,     1,     2,     1,
01751        3,     3,     1,     3,     1,     3,     1,     1,     2,     1,
01752        1,     1,     2,     2,     1,     1,     0,     4,     1,     2,
01753        1,     3,     3,     2,     2,     1,     1,     1,     1,     1,
01754        1,     1,     1,     1,     1,     1,     1,     0,     1,     0,
01755        1,     2,     2,     0,     1,     1,     1,     1,     1,     2,
01756        0
01757 };
01758 
01759 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
01760    Performed when YYTABLE doesn't specify something else to do.  Zero
01761    means the default is an error.  */
01762 static const yytype_uint16 yydefact[] =
01763 {
01764        2,     0,     0,     1,     0,   347,   348,   349,     0,   340,
01765      341,   342,   345,   343,   344,   346,   335,   336,   337,   338,
01766      298,   263,   263,   511,   510,   512,   513,   609,     0,   609,
01767       10,     0,   515,   514,   516,   595,   597,   507,   506,   596,
01768      509,   501,   502,   454,   521,   522,     0,     0,     0,     0,
01769      290,   620,   620,    85,   407,   480,   478,   480,   482,   462,
01770      474,   468,   476,     0,     0,     0,     3,   607,     6,     9,
01771       33,    45,    48,    56,   263,    55,     0,    73,     0,    77,
01772       87,     0,    53,   244,     0,   286,     0,     0,   312,   315,
01773      607,     0,     0,     0,     0,    57,   307,   275,   276,   453,
01774      455,   277,   278,   279,   281,   280,   282,   451,   452,   450,
01775      517,   518,   283,     0,   284,    61,     5,     8,   168,   179,
01776      169,   192,   165,   185,   175,   174,   195,   196,   190,   173,
01777      172,   167,   193,   197,   198,   177,   166,   180,   184,   186,
01778      178,   171,   187,   194,   189,   188,   181,   191,   176,   164,
01779      183,   182,   163,   170,   161,   162,   158,   159,   160,   116,
01780      118,   117,   153,   154,   149,   131,   132,   133,   140,   137,
01781      139,   134,   135,   155,   156,   141,   142,   146,   150,   136,
01782      138,   128,   129,   130,   143,   144,   145,   147,   148,   151,
01783      152,   157,   121,   123,   125,    26,   119,   120,   122,   124,
01784        0,     0,     0,     0,     0,     0,     0,     0,   258,     0,
01785      245,   268,    71,   262,   620,     0,   517,   518,     0,   284,
01786      620,   590,    72,    70,   609,    69,     0,   620,   431,    68,
01787      609,   610,     0,     0,    21,   241,     0,     0,   335,   336,
01788      298,   301,   432,     0,   220,     0,   221,   295,     0,    19,
01789        0,     0,   607,    15,    18,   609,    75,    14,   609,     0,
01790        0,   613,   613,   246,     0,     0,   613,   588,   609,     0,
01791        0,     0,    83,   339,     0,    93,    94,   101,   309,   408,
01792      498,   497,   499,   496,     0,   495,     0,     0,     0,     0,
01793        0,     0,     0,     0,     0,     0,     0,   503,   504,    52,
01794      235,   236,   616,   617,     4,   618,   608,     0,     0,     0,
01795        0,     0,     0,     0,   436,   434,   421,    62,   306,   415,
01796      417,     0,    89,     0,    81,    78,     0,     0,     0,     0,
01797        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01798        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01799        0,     0,     0,   429,   620,   427,     0,    54,     0,     0,
01800        0,     0,   607,     0,   608,     0,   361,   360,     0,     0,
01801      517,   518,   284,   111,   112,     0,     0,   114,     0,     0,
01802      517,   518,   284,   328,   188,   181,   191,   176,   158,   159,
01803      160,   116,   117,   586,   330,   585,     0,   606,   605,     0,
01804      308,   456,     0,     0,   126,   593,   295,   269,   594,   265,
01805        0,     0,     0,   259,   267,   429,   620,   427,     0,     0,
01806        0,   260,   609,     0,   300,   264,   609,   254,   620,   620,
01807      253,   609,   305,    51,    23,    25,    24,     0,   302,     0,
01808        0,     0,   429,   427,     0,    17,     0,   609,   293,    13,
01809      608,    74,   289,   291,   296,   615,   614,   247,   615,   249,
01810      297,   589,     0,   100,   503,   504,    91,    86,     0,   429,
01811      620,   427,   549,   484,   487,   485,   500,   481,   457,   479,
01812      458,   459,   483,   460,   461,     0,   464,   470,     0,   471,
01813      466,   467,     0,   472,     0,   473,     0,     0,   619,     7,
01814       27,    28,    29,    30,    31,    49,    50,   620,   620,    59,
01815       63,   620,     0,    34,    43,     0,    44,   609,     0,    79,
01816       90,    47,    46,     0,   199,   268,    42,   217,   225,   230,
01817      231,   232,   227,   229,   239,   240,   233,   234,   210,   211,
01818      237,   238,   609,   226,   228,   222,   223,   224,   212,   213,
01819      214,   215,   216,   598,   600,   599,   601,     0,   263,   426,
01820      609,   598,   600,   599,   601,     0,   263,     0,   620,   352,
01821        0,   351,     0,     0,     0,     0,     0,     0,   295,   429,
01822      620,   427,   320,   325,   111,   112,   113,     0,   524,   323,
01823      523,   429,   620,   427,     0,     0,   549,   332,   598,   599,
01824      263,    35,   201,    41,   209,     0,   199,   592,     0,   270,
01825      266,   620,   598,   599,   609,   598,   599,   591,   299,   611,
01826      250,   255,   257,   304,    22,     0,   242,     0,    32,   424,
01827      422,   208,     0,    76,    16,   609,   613,     0,    84,    97,
01828       99,   609,   598,   599,   555,   552,   551,   550,   553,     0,
01829      566,     0,   577,   567,   581,   580,   576,   549,   409,   548,
01830      412,   554,   556,   558,   534,   564,   620,   569,   620,   574,
01831      534,   579,   534,     0,   532,   488,     0,   463,   465,   475,
01832      469,   477,   218,   219,   399,   609,     0,   397,   396,     0,
01833      620,     0,   274,     0,    88,    82,     0,     0,     0,     0,
01834        0,     0,   430,    66,     0,     0,   433,     0,     0,   428,
01835       64,   620,   350,   287,   620,   620,   442,   620,   353,   620,
01836      355,   313,   354,   316,     0,     0,   319,   602,   294,   609,
01837      598,   599,     0,     0,   526,     0,     0,   111,   112,   115,
01838      609,     0,   609,   549,     0,     0,     0,   252,   418,    58,
01839      251,     0,   127,   271,   261,     0,     0,   433,     0,     0,
01840      620,   609,    11,     0,   292,   248,    92,    95,     0,   560,
01841      555,     0,   373,   364,   366,   609,   362,   609,     0,     0,
01842      541,     0,   530,   584,   568,     0,   531,     0,   544,   578,
01843        0,   546,   582,   489,   491,   492,   493,   486,   494,   555,
01844        0,   395,   609,     0,   380,   562,   620,   620,   572,   380,
01845      380,   378,   401,     0,     0,     0,     0,     0,   272,    80,
01846      200,     0,    40,   206,    39,   207,    67,   425,   612,     0,
01847       37,   204,    38,   205,    65,   423,   443,   444,   620,   445,
01848        0,   620,   358,     0,     0,   356,     0,     0,     0,   318,
01849        0,     0,   433,     0,   326,     0,     0,   433,   329,   587,
01850      609,     0,   528,   333,   419,   420,   202,     0,   256,   303,
01851       20,   570,   609,     0,   371,     0,   557,     0,     0,     0,
01852      410,   533,   559,   534,   534,   565,   620,   583,   534,   575,
01853      534,   534,     0,     0,     0,   561,     0,   398,   386,   388,
01854        0,   376,   377,     0,   391,     0,   393,     0,   437,   435,
01855        0,   416,   273,   243,    36,   203,     0,     0,   447,   359,
01856        0,    12,   449,     0,   310,   311,     0,     0,   270,   620,
01857      321,     0,   525,   324,   527,   331,   549,   363,   374,     0,
01858      369,   365,   411,     0,     0,     0,   537,     0,   539,   529,
01859        0,   545,     0,   542,   547,     0,   571,   295,   429,   400,
01860      379,   380,   380,   563,   620,   380,   573,   380,   380,   405,
01861      609,   403,   406,    60,     0,   446,     0,   102,   103,   110,
01862        0,   448,     0,   314,   317,   439,   440,   438,     0,     0,
01863        0,     0,   372,     0,   367,   414,   413,   534,   534,   534,
01864      534,   490,   602,   294,     0,   383,     0,   385,   375,     0,
01865      392,     0,   389,   394,     0,   402,   109,   429,   620,   427,
01866      620,   620,     0,   327,     0,   370,     0,   538,     0,   535,
01867      540,   543,   380,   380,   380,   380,   404,   602,   108,   609,
01868      598,   599,   441,   357,   322,   334,   368,   534,   384,     0,
01869      381,   387,   390,   433,   536,   380,   382
01870 };
01871 
01872 /* YYDEFGOTO[NTERM-NUM].  */
01873 static const yytype_int16 yydefgoto[] =
01874 {
01875       -1,     1,     2,    66,    67,    68,   236,   567,   568,   252,
01876      253,   446,   254,   437,    70,    71,   358,    72,    73,   510,
01877      690,   243,    75,    76,   255,    77,    78,    79,   467,    80,
01878      209,   377,   378,   192,   193,   194,   195,   605,   556,   197,
01879       82,   439,   211,   260,   228,   748,   426,   427,   225,   226,
01880      213,   413,   428,   516,    83,   356,   258,   259,   635,   625,
01881      360,   847,   361,   848,   732,   988,   736,   733,   931,   594,
01882      596,   746,   936,   245,    85,    86,    87,    88,    89,    90,
01883       91,    92,    93,    94,   713,   570,   721,   844,   845,   369,
01884      773,   774,   775,   960,   899,   802,   686,   687,   803,   970,
01885      971,   278,   279,   472,   778,   658,   880,   320,   511,    95,
01886       96,   711,   704,   565,   557,   318,   508,   507,   577,   987,
01887      715,   838,   917,   921,    97,    98,    99,   100,   101,   102,
01888      103,   290,   485,   104,   294,   105,   106,   292,   296,   286,
01889      284,   288,   477,   676,   675,   793,   892,   797,   107,   285,
01890      108,   109,   216,   217,   112,   218,   219,   589,   735,   744,
01891      881,   780,   745,   661,   662,   663,   664,   665,   805,   806,
01892      666,   667,   668,   669,   808,   809,   670,   671,   672,   673,
01893      674,   782,   396,   595,   265,   429,   221,   115,   629,   559,
01894      399,   304,   423,   424,   706,   457,   571,   364,   257
01895 };
01896 
01897 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01898    STATE-NUM.  */
01899 #define YYPACT_NINF -808
01900 static const yytype_int16 yypact[] =
01901 {
01902     -808,   134,  2562,  -808,  7195,  -808,  -808,  -808,  6718,  -808,
01903     -808,  -808,  -808,  -808,  -808,  -808,  7308,  7308,  -808,  -808,
01904     7308,  3884,  3479,  -808,  -808,  -808,  -808,   455,  6585,    17,
01905     -808,    60,  -808,  -808,  -808,  2804,  3614,  -808,  -808,  2939,
01906     -808,  -808,  -808,  -808,  -808,  -808,  8664,  8664,   140,  4955,
01907      462,  7647,  7986,  6977,  -808,  6452,  -808,  -808,  -808,   103,
01908      115,   126,   206,   117,  8777,  8664,  -808,   -25,  -808,  1007,
01909     -808,   322,  -808,  -808,   141,   372,   352,  -808,   337,  9003,
01910     -808,   379,  2918,   247,   278,  -808,  8890,  8890,  -808,  -808,
01911     5842,  9112,  9221,  9330,  6318,    33,    65,  -808,  -808,   410,
01912     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01913      205,   409,  -808,   441,   433,  -808,  -808,  -808,  -808,  -808,
01914     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01915     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01916     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01917     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01918     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01919     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01920     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01921     -808,  -808,  -808,  -808,  -808,   396,  -808,  -808,  -808,  -808,
01922      427,  8664,   519,  5094,  8664,  8664,  8664,  8664,  -808,   468,
01923     2918,   500,  -808,  -808,   463,   304,    22,   344,   517,   363,
01924      479,  -808,  -808,  -808,  5729,  -808,  7308,  7308,  -808,  -808,
01925     5955,  -808,  8890,   498,  -808,   482,   491,  5233,  -808,  -808,
01926     -808,   497,   499,   141,  -808,   361,   570,   458,  7421,  -808,
01927     4955,   505,   -25,  -808,  1007,    17,   538,  -808,    17,  8890,
01928      515,   188,   318,  -808,   500,   523,   318,  -808,    17,   617,
01929      338,  9439,   540,  -808,   474,   572,   613,   674,  -808,  -808,
01930     -808,  -808,  -808,  -808,   522,  -808,   601,   669,   284,   576,
01931      752,   577,    58,   582,   759,   584,    68,   609,   612,  -808,
01932     -808,  -808,  -808,  -808,  -808,  -808,  6068,  8890,  8890,  8890,
01933     8890,  7421,  8890,  8890,  -808,  -808,  -808,   588,  -808,  -808,
01934     -808,  8099,  -808,  4955,  7086,   561,  8099,  8664,  8664,  8664,
01935     8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,
01936     8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,  8664,
01937     8664,  8664,  8664,  2012,  7308,  9718,  4312,   322,   109,   109,
01938     8890,  8890,   -25,   689,   563,   651,  -808,  -808,   685,   691,
01939       53,    57,   100,   328,   393,  8890,   568,  -808,   199,   708,
01940     -808,  -808,  -808,  -808,    55,   223,   249,   279,   283,   301,
01941      316,   384,   417,  -808,  -808,  -808,    33,  -808,  -808,  9795,
01942     -808,  -808,  8777,  8777,  -808,  -808,   414,  -808,  -808,  -808,
01943     8664,  8664,  7534,  -808,  -808,  9872,  7308,  9949,  8664,  8664,
01944     7760,  -808,    17,   595,  -808,  -808,    17,  -808,   580,   599,
01945     -808,    61,  -808,  -808,  -808,  -808,  -808,  6718,  -808,  8664,
01946     5364,   604,  9872,  9949,  8664,  1007,   607,    17,  -808,  -808,
01947     6181,   618,  -808,   322,  -808,  7873,  -808,  -808,  7986,  -808,
01948     -808,  -808,   482,   769,  -808,  -808,  -808,   622,  9439, 10026,
01949     7308, 10103,  1417,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
01950     -808,  -808,  -808,  -808,  -808,   244,  -808,  -808,   611,  -808,
01951     -808,  -808,   347,  -808,   623,  -808,  8664,  8664,  -808,  -808,
01952     -808,  -808,  -808,  -808,  -808,  -808,  -808,    51,    51,  -808,
01953     -808,    51,  8664,  -808,   628,   634,  -808,    17,  9439,   655,
01954     -808,  -808,  -808,   678,  1866,  -808,  -808,   570,  2240,  2240,
01955     2240,  2240,   727,   727,  3323,  3188,  2240,  2240,  3053,  3053,
01956      415,   415,  1674,   727,   727,   907,   907,   660,    40,    40,
01957      570,   570,   570,  4019,  3074,  4154,  3209,   499,   661,  -808,
01958       17,   535,  -808,   688,  -808,   499,  3749,   737,   790,  -808,
01959     4451,   799,  4729,    66,    66,   689,  8212,   737,   147, 10180,
01960     7308, 10257,  -808,   322,  -808,   769,  -808,   -25,  -808,  -808,
01961     -808, 10334,  7308,  9795,  4312,  8890,  1538,  -808,  -808,  -808,
01962     4173,  -808,  2648,  -808,  2918,  6718,  2783,  -808,  8664,   500,
01963     -808,   479,  2669,  3344,    17,   420,   444,  -808,  -808,  -808,
01964     -808,  7534,  7760,  -808,  -808,  8890,  2918,   672,  -808,  -808,
01965     -808,  2918,  5364,     2,  -808,    17,   318,  9439,   622,   701,
01966      469,    17,   207,   224,   711,  -808,  -808,  -808,  -808,  8664,
01967     -808,   947,  -808,  -808,  -808,  -808,  -808,  1789,  -808,  -808,
01968     -808,  -808,  -808,  -808,   680,  -808,   687,   773,   694,  -808,
01969      698,   783,   704,   791,  -808,  -808,   834,  -808,  -808,  -808,
01970     -808,  -808,   570,   570,  -808,  1322,  5503,  -808,  -808,  5233,
01971       51,  5503,   721,  8325,  -808,   622,  9439,  8777,  8664,   741,
01972     8777,  8777,  -808,   588,   499,   722,   818,  8777,  8777,  -808,
01973      588,   499,  -808,  -808,  8438,   827,  -808,   597,  -808,   827,
01974     -808,  -808,  -808,  -808,   737,    70,  -808,    67,   136,    17,
01975      148,   149,  8890,   -25,  -808,  8890,  4312,   701,   469,  -808,
01976       17,   737,    61,  1789,  4312,   -25,  6851,  -808,    65,   372,
01977     -808,  8664,  -808,  -808,  -808,  8664,  8664,   466,  8664,  8664,
01978      731,    61,  -808,   736,  -808,  -808,  -808,   567,  8664,  -808,
01979     -808,   947,   350,  -808,   738,    17,  -808,    17,    72,  1789,
01980     -808,    42,  -808,  -808,  -808,   272,  -808,  1789,  -808,  -808,
01981      892,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,   762,
01982     9548,  -808,    17,   764,   746,  -808,   751,   694,  -808,   758,
01983      760,  -808,   761,   893,   775,  5233,   899,  8664,   776,   622,
01984     2918,  8664,  -808,  2918,  -808,  2918,  -808,  -808,  -808,  8777,
01985     -808,  2918,  -808,  2918,  -808,  -808,   628,  -808,   826,  -808,
01986     4842,   909,  -808,  8890,   737,  -808,   737,  5503,  5503,  -808,
01987     8551,  4590,   155,    66,  -808,   -25,   737,  -808,  -808,  -808,
01988       17,   737,  -808,  -808,  -808,  -808,  2918,  8664,  7760,  -808,
01989     -808,  -808,    17,  1011,   789,  1003,  -808,   793,  5503,  5233,
01990     -808,  -808,  -808,   798,   803,  -808,   694,  -808,   804,  -808,
01991      811,   804,  5616,  9548,   877,   792,   808,  -808,  1910,  -808,
01992      490,  -808,  -808,  1910,  -808,  1368,  -808,  1032,  -808,  -808,
01993      820,  -808,   819,  2918,  -808,  2918,  9657,   109,  -808,  -808,
01994     5503,  -808,  -808,   109,  -808,  -808,   737,   737,  -808,   130,
01995     -808,  4312,  -808,  -808,  -808,  -808,  1538,  -808,   821,  1011,
01996      434,  -808,  -808,   944,   832,  1789,  -808,   892,  -808,  -808,
01997      892,  -808,   892,  -808,  -808,   850,   792,  -808, 10411,  -808,
01998     -808,   830,   831,  -808,   694,   835,  -808,   837,   835,  -808,
01999      443,  -808,  -808,  -808,   910,  -808,   796,   572,   613,   674,
02000     4312,  -808,  4451,  -808,  -808,  -808,  -808,  -808,  5503,   737,
02001     4312,  1011,   821,  1011,   838,  -808,  -808,   804,   839,   804,
02002      804,  -808,   840,   841,  1910,  -808,  1368,  -808,  -808,  1368,
02003     -808,  1368,  -808,  -808,  1032,  -808,   769, 10488,  7308, 10565,
02004      790,   597,   737,  -808,   737,   821,  1011,  -808,   892,  -808,
02005     -808,  -808,   835,   844,   835,   835,  -808,    74,   469,    17,
02006      146,   158,  -808,  -808,  -808,  -808,   821,   804,  -808,  1368,
02007     -808,  -808,  -808,   176,  -808,   835,  -808
02008 };
02009 
02010 /* YYPGOTO[NTERM-NUM].  */
02011 static const yytype_int16 yypgoto[] =
02012 {
02013     -808,  -808,  -808,  -363,  -808,    27,  -808,  -550,   -21,  -808,
02014      518,  -808,    15,  -808,  -301,   -51,   -86,    41,  -808,  -268,
02015     -808,   413,    -7,   888,  -153,    -4,   -73,  -808,  -416,     7,
02016     1571,  -315,   889,   -53,  -808,    -5,  -808,  -808,    98,  -808,
02017      870,  -808,   735,  -808,   -44,   275,  -340,    87,   -11,  -808,
02018     -386,  -188,     4,  -311,   -20,  -808,  -808,  -808,  -808,  -808,
02019     -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
02020     -808,  -808,  -808,    64,  -808,  -808,  -808,  -808,  -808,  -808,
02021     -808,  -808,  -808,  -808,   154,  -347,  -526,   -34,  -645,  -808,
02022     -785,  -779,   221,   309,   374,  -808,  -446,  -808,  -665,  -808,
02023      -18,  -808,  -808,  -808,  -808,  -808,  -808,   248,  -808,  -808,
02024     -808,  -808,  -808,  -808,  -808,   -93,  -808,  -808,  -535,  -808,
02025       -6,  -808,  -808,  -808,  -808,  -808,  -808,   918,  -808,  -808,
02026     -808,  -808,   712,  -808,  -808,  -808,  -808,  -808,  -808,  -808,
02027      963,  -808,  -142,  -808,  -808,  -808,  -808,  -808,    10,  -808,
02028       14,  -808,  1081,  1361,   928,  1531,  1552,  -808,  -808,    89,
02029     -464,  -372,  -415,  -783,  -518,  -723,   234,   242,   133,  -808,
02030     -808,  -808,   289,  -708,  -807,   128,   255,  -808,  -638,  -808,
02031      228,  -622,  -808,  -808,  -808,    69,  -383,  -808,  -348,  -808,
02032      639,   -26,     0,    48,  -598,  -208,    21,   -14,    -2
02033 };
02034 
02035 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
02036    positive, shift that token.  If negative, reduce the rule which
02037    number is the opposite.  If YYTABLE_NINF, syntax error.  */
02038 #define YYTABLE_NINF -621
02039 static const yytype_int16 yytable[] =
02040 {
02041      116,   359,   283,   400,   362,   558,   325,   566,   659,   208,
02042      208,   229,   572,   208,   560,   526,   757,    69,   198,    69,
02043      214,   214,   199,   234,   214,   521,   610,   232,   251,   235,
02044      316,   117,   421,   273,   610,   357,   357,   617,   198,   357,
02045      724,   394,   199,   767,   741,   256,   786,   810,   723,   263,
02046      267,   600,   638,   306,   459,   261,   882,   660,   461,   273,
02047      272,   586,   689,   317,   363,   691,    84,   558,    84,   566,
02048      841,   273,   273,   273,   846,   617,   614,   627,  -102,   889,
02049      215,   215,  -103,   569,   215,   220,   220,  -106,   305,   220,
02050      941,   314,  -106,   720,   938,   630,   966,   447,   312,   313,
02051      649,   878,   695,   212,   222,   299,   196,   223,   327,  -519,
02052      650,   305,   877,    84,   302,   -74,   303,   274,   397,   488,
02053      262,   266,   569,   630,   972,  -110,   196,   684,   215,   494,
02054      641,   852,   659,   776,     3,  -102,   -88,   896,   653,   654,
02055     -511,   884,   857,   274,   479,   840,   482,   576,   486,   890,
02056      215,   215,   486,   196,   215,   368,   379,   379,   231,  -105,
02057      992,  -108,   655,   350,   351,   352,   398,   314,   489,   685,
02058      517,  -107,  -109,  -105,  -107,   882,   297,   298,   495,   431,
02059     -104,   433,   251,   879,   901,   902,   856,   -93,  -511,  -104,
02060      237,   -94,   196,   659,   861,   315,   247,   966,   466,   316,
02061      587,   -97,   231,  -598,   850,   302,   941,   303,   453,   302,
02062     -598,   303,   414,  -106,  1025,  -106,   441,   208,   414,   208,
02063      208,   500,   501,   502,   503,   430,   449,   882,   214,   251,
02064      214,   972,   -96,   630,  -101,   610,   610,   889,   450,   617,
02065      729,   421,   777,   289,   815,   630,   256,  1046,   302,   -98,
02066      303,   273,   740,   776,   874,   291,   357,   357,   357,   357,
02067      962,   505,   506,   445,   949,   967,   293,    84,   462,   763,
02068      -99,   315,  -599,   305,   573,   574,   739,   227,   432,   659,
02069      819,  -100,   -96,   -98,   985,  -105,   882,  -105,   215,   -95,
02070      215,   215,  -519,   220,   215,   220,   215,  -107,   788,  -107,
02071      791,    84,   251,   451,   273,   473,   452,   998,  -510,   357,
02072      357,   422,    84,   425,    84,  -104,   588,  -104,  -102,   256,
02073      -96,    69,   455,   215,   583,   515,   504,   930,   860,   456,
02074      515,   519,  -339,   499,  -512,   274,   575,   -98,   302,   -93,
02075      303,   -96,  1008,   678,   -96,   473,   295,   208,   -96,   481,
02076      678,   474,   430,   475,  -595,   776,  -510,   776,   -98,   312,
02077      313,   -98,   513,   353,  -513,   -98,  1033,   522,  -515,   654,
02078       84,   215,   215,   215,   215,    84,   215,   215,   851,  -339,
02079     -339,   989,  -512,   305,   677,   215,  -514,    84,   274,   415,
02080      215,   474,   655,   475,   986,   466,   521,   464,   465,   590,
02081      319,  -516,   770,   837,   645,   646,   647,   648,   473,   208,
02082      354,   355,  -513,  -505,   430,    74,  -515,    74,   215,  -596,
02083       84,   776,   994,   754,   215,   215,   414,   414,   765,    74,
02084       74,  -520,   624,    74,  -514,   826,   416,   417,   116,   215,
02085     1024,  1053,   834,   601,   603,   466,   442,   198,   273,  -516,
02086      419,   199,   458,   564,   474,    69,   475,  -103,  -595,   456,
02087     -505,  -505,    74,   208,  -595,   321,   215,   215,   430,  -505,
02088      618,   322,   659,   776,   620,   776,  -110,    74,  -508,   623,
02089      215,   611,   610,   327,   873,   617,   770,   680,   645,   646,
02090      647,   648,   326,   416,   443,   633,  -520,   564,   273,    74,
02091       74,   444,  -508,    74,    84,   688,   688,   758,   776,   688,
02092       56,   946,   948,   702,    84,   564,   951,  -505,   953,   954,
02093      403,   709,  -103,  -596,   636,  -508,  -508,  -109,   402,  -596,
02094      404,   759,   274,  -105,   215,   196,   348,   349,   350,   351,
02095      352,   564,   699,   -94,   742,   444,  -110,   703,   800,   717,
02096     -508,   719,   434,   867,  -294,   710,   747,  -107,   650,   469,
02097      705,   435,   436,   230,   766,   694,   716,  -101,   993,   564,
02098      980,  -109,   754,   208,   761,   406,   982,  1014,   430,  -104,
02099      725,   410,   274,   473,   231,   208,   653,   654,   411,   749,
02100      430,   230,  -100,  -433,   722,   722,   231,   412,   750,  -288,
02101      752,  -294,  -294,  -288,   418,  -599,   470,   471,   734,   414,
02102      655,   843,   840,   420,   705,   198,    74,   273,   438,   199,
02103      584,   440,   707,   466,   585,  1027,  1029,  1030,  1031,   474,
02104      116,   475,   476,   224,    84,   227,    84,    74,   327,    74,
02105       74,   705,   448,    74,   215,    74,   853,    69,  -105,   855,
02106       74,   -73,  -433,   454,   460,   864,   215,  -517,    84,   215,
02107      827,    74,   473,    74,   783,   813,   783,   747,   814,   -96,
02108      816,   630,    74,   463,   468,  1054,   273,   496,  1039,   564,
02109      497,   357,   509,   764,   357,   812,   483,   487,   688,   215,
02110      760,   564,   490,   863,   493,   520,    84,  -433,  -518,  -433,
02111     -433,   274,   498,   196,  -517,  -517,   576,   578,   474,   750,
02112      475,   478,   839,   842,   621,   842,   582,   842,   515,    74,
02113       74,    74,    74,    74,    74,    74,    74,  -602,   327,   705,
02114      473,   726,   619,   622,    74,   628,    74,   632,   522,    74,
02115      705,   822,   824,   340,   341,  -518,  -518,   712,   830,   832,
02116       84,   679,   -88,    84,   854,    84,   637,   923,   414,  -284,
02117      274,   215,  -268,   681,   215,   215,   862,    74,   693,    74,
02118      579,   215,   215,    74,    74,   708,   474,   812,   475,   480,
02119      273,   348,   349,   350,   351,   352,  -602,   264,    74,   696,
02120      859,   697,   357,   591,   910,   327,   215,  -424,   714,   215,
02121       84,  -107,   812,   762,   783,   783,  -284,  -284,    84,   869,
02122      340,   341,   718,   473,   779,    74,    74,   580,   581,   919,
02123      473,   781,   -98,   876,   768,   784,   926,   927,   785,    74,
02124      929,  -602,   787,  -602,  -602,   789,   918,  -598,   790,   922,
02125      592,   593,   840,   792,   196,   345,   346,   347,   348,   349,
02126      350,   351,   352,    74,  -295,  -269,   821,   943,   944,   474,
02127      828,   475,   484,    74,   895,   868,   474,   870,   475,   491,
02128      914,   955,   875,   273,   722,   893,   932,   958,   849,    84,
02129      898,  1017,   897,    74,   783,   900,   210,   210,   794,   795,
02130      210,   796,   903,   215,   905,   858,   273,    44,    45,   981,
02131      907,  -295,  -295,   908,    84,   829,   909,   215,   934,   911,
02132     -270,    84,    84,   811,   916,    84,   244,   246,   920,   804,
02133      937,   210,   210,   939,   592,   593,   959,   842,  1018,  1019,
02134      942,  -104,   945,   957,   300,   301,   405,   947,   950,   407,
02135      408,   409,    84,    84,   770,   952,   645,   646,   647,   648,
02136      649,   973,   -95,  -271,   995,   991,    84,   956,  1001,  1020,
02137      650,  1021,   783,   996,  1004,  1006,  1016,  1022,   634,  1009,
02138     1015,  1011,  1026,  1028,   807,   327,  -598,  -599,  1049,   366,
02139      976,   651,   383,    74,    84,    74,   835,  1043,   653,   654,
02140      340,   341,   872,    74,   801,    84,  1036,   865,   924,   770,
02141      925,   645,   646,   647,   648,    74,   492,    74,    74,   887,
02142      933,   208,   655,   887,  1042,   935,   430,   401,   716,   842,
02143      287,   888,   395,   885,   891,   990,   961,   347,   348,   349,
02144      350,   351,   352,   963,   883,   597,   771,     0,    74,   705,
02145        0,     0,   772,     0,    84,    74,    84,   307,   308,   309,
02146      310,   311,    84,     0,    84,   770,   514,   645,   646,   647,
02147      648,   525,     0,   770,     0,   645,   646,   647,   648,     0,
02148      886,   210,     0,     0,   210,   210,   210,   300,     0,     0,
02149      983,   984,   215,   110,   969,   110,   645,   646,   647,   648,
02150        0,     0,   771,     0,   210,     0,   210,   210,   940,    74,
02151      771,     0,    74,     0,    74,     0,     0,     0,     0,     0,
02152       74,     0,     0,    74,    74,     0,     0,   564,     0,     0,
02153       74,    74,     0,     0,     0,     0,   811,     0,   887,     0,
02154      110,   811,     0,   811,   275,     0,     0,   965,     0,   968,
02155        0,     0,     0,  1023,     0,    74,   607,   609,    74,    74,
02156        0,     0,     0,     0,     0,   264,     0,    74,     0,     0,
02157      275,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02158        0,     0,   370,   380,   380,   380,  1044,     0,  1045,   997,
02159        0,   999,     0,   904,   906,     0,  1000,   807,     0,   964,
02160      609,   210,   807,   264,   807,     0,   524,   527,   528,   529,
02161      530,   531,   532,   533,   534,   535,   536,   537,   538,   539,
02162      540,   541,   542,   543,   544,   545,   546,   547,   548,   549,
02163      550,   551,   552,     0,   210,     0,     0,     0,    74,     0,
02164        0,     0,   811,     0,   811,     0,     0,   811,  1032,   811,
02165     1034,     0,    74,     0,     0,  1035,     0,   692,     0,     0,
02166        0,     0,     0,    74,     0,     0,    74,     0,     0,     0,
02167       74,    74,  1047,     0,    74,     0,     0,     0,     0,     0,
02168        0,     0,   602,   604,     0,     0,     0,   811,     0,     0,
02169      606,   210,   210,  1055,   110,     0,   210,     0,   602,   604,
02170      210,    74,    74,   807,     0,   807,     0,     0,   807,     0,
02171      807,     0,     0,     0,     0,    74,     0,     0,     0,   626,
02172        0,   525,     0,     0,   631,     0,     0,     0,   110,     0,
02173        0,     0,     0,     0,     0,   210,     0,     0,   210,   110,
02174        0,   110,     0,    74,     0,  1005,  1007,     0,   807,  1010,
02175      210,  1012,  1013,   753,    74,     0,     0,     0,     0,     0,
02176        0,     0,   275,     0,     0,     0,   609,   264,     0,     0,
02177        0,     0,     0,   111,     0,   111,   682,   683,     0,     0,
02178        0,     0,     0,     0,   799,     0,   645,   646,   647,   648,
02179      800,     0,   210,     0,   769,     0,     0,   110,     0,     0,
02180      650,     0,   110,    74,     0,    74,     0,     0,     0,     0,
02181        0,    74,     0,    74,   110,   275,  1048,  1050,  1051,  1052,
02182      111,   651,     0,     0,   276,     0,     0,   652,   653,   654,
02183      770,     0,   645,   646,   647,   648,   800,     0,   818,  1056,
02184        0,    74,     0,     0,     0,     0,   650,   110,     0,     0,
02185      276,     0,   655,     0,     0,   656,   210,     0,     0,   836,
02186      210,     0,   371,   381,   381,   381,     0,   651,     0,     0,
02187        0,     0,   210,   231,   653,   654,     0,     0,     0,   644,
02188        0,   645,   646,   647,   648,   649,     0,     0,   210,     0,
02189        0,     0,     0,     0,     0,   650,     0,     0,   655,     0,
02190        0,   210,   210,     0,     0,     0,     0,     0,     0,     0,
02191        0,     0,     0,   871,     0,     0,   651,     0,     0,     0,
02192        0,     0,   652,   653,   654,     0,     0,     0,     0,   210,
02193        0,   110,     0,     0,     0,     0,     0,     0,     0,     0,
02194        0,   110,     0,   113,     0,   113,     0,   655,     0,     0,
02195      656,     0,     0,     0,     0,     0,     0,     0,     0,   275,
02196        0,     0,   912,   657,   114,     0,   114,     0,     0,     0,
02197        0,     0,     0,   210,   111,     0,     0,   606,   820,     0,
02198      823,   825,     0,    81,     0,    81,     0,   831,   833,     0,
02199      113,     0,     0,     0,   210,   928,     0,     0,     0,     0,
02200      644,     0,   645,   646,   647,   648,   649,     0,   111,   275,
02201        0,   114,     0,   264,     0,   277,   650,     0,     0,   111,
02202        0,   111,     0,     0,     0,     0,     0,     0,     0,     0,
02203       81,   866,     0,     0,     0,   823,   825,   651,   831,   833,
02204        0,   277,   276,   652,   653,   654,     0,     0,   210,     0,
02205        0,     0,     0,   372,   382,   382,     0,     0,     0,     0,
02206        0,   110,     0,   110,     0,     0,     0,     0,   655,     0,
02207        0,   656,   367,     0,     0,     0,     0,   111,     0,     0,
02208        0,     0,   111,     0,   743,   110,     0,     0,     0,     0,
02209        0,     0,     0,     0,   111,   276,     0,   210,     0,     0,
02210        0,   913,     0,     0,     0,     0,     0,     0,     0,   915,
02211        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02212        0,     0,     0,   110,     0,     0,     0,   111,   275,     0,
02213      210,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02214        0,     0,     0,     0,   113,     0,     0,   915,   210,     0,
02215        0,     0,   327,   328,   329,   330,   331,   332,   333,   334,
02216      335,   336,   337,   338,   339,   114,     0,   340,   341,     0,
02217        0,     0,     0,     0,     0,     0,     0,   110,   113,     0,
02218      110,     0,   110,     0,    81,     0,     0,   275,     0,   113,
02219        0,   113,     0,     0,     0,     0,     0,     0,   342,   114,
02220      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
02221      114,   111,   114,     0,     0,     0,     0,     0,    81,     0,
02222        0,   111,     0,     0,     0,   231,     0,   110,     0,    81,
02223        0,    81,     0,   277,     0,   110,     0,     0,     0,   276,
02224        0,     0,     0,     0,     0,     0,     0,   113,     0,     0,
02225        0,   644,   113,   645,   646,   647,   648,   649,     0,     0,
02226        0,     0,     0,     0,   113,     0,     0,   650,   114,     0,
02227        0,     0,     0,   114,     0,     0,     0,     0,     0,     0,
02228        0,     0,     0,     0,     0,   114,   277,    81,   651,   276,
02229        0,   380,    81,     0,   652,   653,   654,   113,   210,     0,
02230        0,     0,     0,     0,    81,     0,   110,   523,     0,     0,
02231        0,     0,     0,     0,     0,     0,     0,     0,   114,   655,
02232      698,     0,   656,     0,     0,     0,     0,     0,     0,     0,
02233        0,   110,     0,     0,     0,     0,     0,    81,   110,   110,
02234        0,   111,   110,   111,   327,   328,   329,   330,   331,   332,
02235      333,   334,   335,   336,   337,   338,   339,     0,     0,   340,
02236      341,     0,     0,     0,     0,   111,     0,     0,     0,   110,
02237      110,     0,   799,     0,   645,   646,   647,   648,   800,     0,
02238        0,   113,     0,   110,   380,     0,     0,     0,   650,     0,
02239      342,   113,   343,   344,   345,   346,   347,   348,   349,   350,
02240      351,   352,   114,   111,     0,     0,     0,   977,   276,   651,
02241     -245,   110,   114,     0,     0,   652,   653,   654,     0,     0,
02242        0,    81,   110,     0,     0,     0,     0,     0,     0,     0,
02243      277,    81,     0,     0,     0,     0,     0,     0,     0,     0,
02244      655,     0,     0,   656,     0,     0,     0,     0,     0,     0,
02245        0,     0,     0,     0,     0,     0,     0,   111,     0,     0,
02246      111,     0,   111,     0,     0,     0,     0,   276,     0,     0,
02247        0,   110,     0,   110,   553,   554,     0,     0,   555,   110,
02248      277,   110,     0,     0,     0,     0,     0,     0,   162,   163,
02249      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
02250      172,     0,     0,   173,   174,   175,   176,   111,     0,     0,
02251        0,   113,     0,   113,     0,   111,     0,   177,   178,     0,
02252        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02253        0,     0,   114,     0,   114,   113,     0,     0,   179,   180,
02254      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
02255      190,    81,     0,    81,     0,     0,   114,   191,     0,     0,
02256        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02257        0,   381,     0,   113,     0,    81,     0,     0,     0,     0,
02258        0,     0,     0,     0,     0,     0,   111,     0,     0,     0,
02259        0,     0,     0,     0,   114,     0,     0,     0,     0,   277,
02260        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02261        0,   111,     0,    81,     0,     0,     0,     0,   111,   111,
02262        0,     0,   111,     0,     0,     0,     0,   113,     0,     0,
02263      113,     0,   113,     0,     0,     0,     0,     0,   798,     0,
02264        0,     0,     0,     0,     0,     0,     0,     0,   114,   111,
02265      111,   114,     0,   114,     0,     0,     0,     0,   277,     0,
02266        0,     0,     0,   111,   381,     0,     0,    81,     0,     0,
02267       81,     0,    81,     0,     0,     0,     0,   113,   523,     0,
02268        0,     0,     0,     0,     0,   113,     0,   978,     0,     0,
02269        0,   111,     0,     0,     0,     0,     0,     0,   114,     0,
02270        0,     0,   111,     0,     0,     0,   114,     0,     0,     0,
02271        0,     0,     0,     0,     0,     0,     0,    81,   327,  -621,
02272     -621,  -621,  -621,   332,   333,    81,     0,  -621,  -621,     0,
02273        0,     0,     0,   340,   341,     0,     0,     0,     0,     0,
02274        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02275        0,   111,     0,   111,     0,     0,   113,     0,     0,   111,
02276        0,   111,   382,     0,     0,     0,   343,   344,   345,   346,
02277      347,   348,   349,   350,   351,   352,     0,   114,     0,     0,
02278        0,   113,     0,     0,     0,     0,     0,     0,   113,   113,
02279        0,     0,   113,     0,     0,     0,    81,     0,     0,     0,
02280        0,     0,   114,     0,     0,     0,     0,     0,     0,   114,
02281      114,     0,     0,   114,     0,     0,     0,     0,     0,   113,
02282      113,    81,     0,     0,     0,     0,     0,     0,    81,    81,
02283        0,     0,    81,   113,     0,     0,     0,     0,     0,     0,
02284      114,   114,     0,     0,     0,     0,     0,     0,     0,     0,
02285        0,     0,     0,     0,   114,   382,     0,     0,     0,    81,
02286       81,   113,     0,     0,     0,     0,     0,     0,     0,     0,
02287        0,     0,   113,    81,     0,     0,     0,     0,   979,     0,
02288        0,     0,   114,     0,     0,     0,     0,     0,     0,     0,
02289        0,     0,     0,   114,     0,     0,     0,   975,     0,     0,
02290        0,    81,     0,     0,     0,     0,     0,     0,     0,     0,
02291        0,     0,    81,     0,     0,     0,     0,     0,     0,     0,
02292        0,   113,     0,   113,     0,     0,     0,     0,     0,   113,
02293        0,   113,     0,     0,     0,     0,     0,     0,     0,     0,
02294        0,     0,   114,     0,   114,     0,     0,     0,     0,     0,
02295      114,     0,   114,     0,     0,     0,     0,     0,     0,     0,
02296        0,    81,     0,    81,     0,     0,     0,     0,     0,    81,
02297        0,    81,  -620,     4,     0,     5,     6,     7,     8,     9,
02298        0,     0,     0,    10,    11,     0,     0,     0,    12,     0,
02299       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02300        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02301        0,    27,     0,     0,     0,     0,     0,    28,    29,    30,
02302       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02303        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02304        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02305        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02306        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02307       54,    55,    56,    57,    58,    59,    60,    61,    62,  -602,
02308        0,     0,     0,     0,     0,     0,     0,  -602,  -602,  -602,
02309        0,     0,  -602,  -602,  -602,     0,  -602,     0,    63,    64,
02310       65,     0,   751,     0,     0,  -602,  -602,  -602,  -602,     0,
02311        0,  -620,     0,  -620,     0,     0,  -602,  -602,     0,  -602,
02312     -602,  -602,  -602,  -602,     0,     0,   327,   328,   329,   330,
02313      331,   332,   333,   334,   335,   336,   337,   338,   339,     0,
02314        0,   340,   341,     0,     0,     0,     0,  -602,  -602,  -602,
02315     -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02316        0,     0,  -602,  -602,  -602,     0,   755,  -602,     0,     0,
02317        0,     0,   342,  -602,   343,   344,   345,   346,   347,   348,
02318      349,   350,   351,   352,     0,     0,     0,  -602,     0,     0,
02319     -602,     0,  -106,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02320     -602,  -602,  -602,  -602,  -602,     0,     0,     0,     0,  -602,
02321     -602,  -602,  -602,  -602,  -505,     0,  -602,  -602,  -602,     0,
02322     -602,     0,  -505,  -505,  -505,     0,     0,  -505,  -505,  -505,
02323        0,  -505,     0,     0,     0,     0,     0,   698,     0,  -505,
02324        0,  -505,  -505,  -505,     0,     0,     0,     0,     0,     0,
02325        0,  -505,  -505,     0,  -505,  -505,  -505,  -505,  -505,     0,
02326        0,   327,   328,   329,   330,   331,   332,   333,   334,   335,
02327      336,   337,   338,   339,     0,     0,   340,   341,     0,     0,
02328        0,     0,  -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,
02329     -505,  -505,  -505,  -505,  -505,     0,     0,  -505,  -505,  -505,
02330        0,  -505,  -505,     0,     0,     0,     0,   342,  -505,   343,
02331      344,   345,   346,   347,   348,   349,   350,   351,   352,     0,
02332        0,     0,  -505,     0,     0,  -505,     0,  -505,  -505,  -505,
02333     -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,  -505,
02334        0,     0,     0,     0,     0,  -505,  -505,  -505,  -505,  -508,
02335        0,  -505,  -505,  -505,     0,  -505,     0,  -508,  -508,  -508,
02336        0,     0,  -508,  -508,  -508,     0,  -508,     0,     0,     0,
02337        0,     0,     0,     0,  -508,     0,  -508,  -508,  -508,     0,
02338        0,     0,     0,     0,     0,     0,  -508,  -508,     0,  -508,
02339     -508,  -508,  -508,  -508,     0,     0,   327,   328,   329,   330,
02340      331,   332,   333,   334,   335,   336,   337,   338,   339,     0,
02341        0,   340,   341,     0,     0,     0,     0,  -508,  -508,  -508,
02342     -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
02343        0,     0,  -508,  -508,  -508,     0,  -508,  -508,     0,     0,
02344        0,     0,   342,  -508,   343,   344,   345,   346,   347,   348,
02345      349,   350,   351,   352,     0,     0,     0,  -508,     0,     0,
02346     -508,     0,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
02347     -508,  -508,  -508,  -508,  -508,     0,     0,     0,     0,     0,
02348     -508,  -508,  -508,  -508,  -603,     0,  -508,  -508,  -508,     0,
02349     -508,     0,  -603,  -603,  -603,     0,     0,  -603,  -603,  -603,
02350        0,  -603,     0,     0,     0,     0,     0,     0,     0,     0,
02351     -603,  -603,  -603,  -603,     0,     0,     0,     0,     0,     0,
02352        0,  -603,  -603,     0,  -603,  -603,  -603,  -603,  -603,     0,
02353        0,   327,   328,   329,   330,   331,   332,   333,   334,   335,
02354      336,   337,  -621,  -621,     0,     0,   340,   341,     0,     0,
02355        0,     0,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
02356     -603,  -603,  -603,  -603,  -603,     0,     0,  -603,  -603,  -603,
02357        0,     0,  -603,     0,     0,     0,     0,     0,  -603,   343,
02358      344,   345,   346,   347,   348,   349,   350,   351,   352,     0,
02359        0,     0,  -603,     0,     0,  -603,     0,     0,  -603,  -603,
02360     -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
02361        0,     0,     0,     0,  -603,  -603,  -603,  -603,  -603,  -604,
02362        0,  -603,  -603,  -603,     0,  -603,     0,  -604,  -604,  -604,
02363        0,     0,  -604,  -604,  -604,     0,  -604,     0,     0,     0,
02364        0,     0,     0,     0,     0,  -604,  -604,  -604,  -604,     0,
02365        0,     0,     0,     0,     0,     0,  -604,  -604,     0,  -604,
02366     -604,  -604,  -604,  -604,     0,     0,   327,   328,   329,   330,
02367      331,   332,   333,   334,     0,   336,   337,     0,     0,     0,
02368        0,   340,   341,     0,     0,     0,     0,  -604,  -604,  -604,
02369     -604,  -604,  -604,  -604,  -604,  -604,  -604,  -604,  -604,  -604,
02370        0,     0,  -604,  -604,  -604,     0,     0,  -604,     0,     0,
02371        0,     0,     0,  -604,   343,   344,   345,   346,   347,   348,
02372      349,   350,   351,   352,     0,     0,     0,  -604,     0,     0,
02373     -604,     0,     0,  -604,  -604,  -604,  -604,  -604,  -604,  -604,
02374     -604,  -604,  -604,  -604,  -604,     0,     0,     0,     0,  -604,
02375     -604,  -604,  -604,  -604,  -294,     0,  -604,  -604,  -604,     0,
02376     -604,     0,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02377        0,  -294,     0,     0,     0,     0,     0,     0,     0,     0,
02378        0,  -294,  -294,  -294,     0,     0,     0,     0,     0,     0,
02379        0,  -294,  -294,     0,  -294,  -294,  -294,  -294,  -294,     0,
02380        0,   327,   328,   329,   330,   331,   332,   333,     0,     0,
02381      336,   337,     0,     0,     0,     0,   340,   341,     0,     0,
02382        0,     0,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02383     -294,  -294,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02384        0,   756,  -294,     0,     0,     0,     0,     0,  -294,   343,
02385      344,   345,   346,   347,   348,   349,   350,   351,   352,     0,
02386        0,     0,  -294,     0,     0,  -294,     0,  -108,  -294,  -294,
02387     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02388        0,     0,     0,     0,     0,  -294,  -294,  -294,  -294,  -432,
02389        0,  -294,  -294,  -294,     0,  -294,     0,  -432,  -432,  -432,
02390        0,     0,  -432,  -432,  -432,     0,  -432,     0,     0,     0,
02391        0,     0,     0,     0,     0,  -432,  -432,  -432,     0,     0,
02392        0,     0,     0,     0,     0,     0,  -432,  -432,     0,  -432,
02393     -432,  -432,  -432,  -432,     0,     0,     0,     0,     0,     0,
02394        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02395        0,     0,     0,     0,     0,     0,     0,  -432,  -432,  -432,
02396     -432,  -432,  -432,  -432,  -432,  -432,  -432,  -432,  -432,  -432,
02397        0,     0,  -432,  -432,  -432,     0,     0,  -432,     0,     0,
02398        0,     0,     0,  -432,     0,     0,     0,     0,     0,     0,
02399        0,     0,     0,     0,     0,     0,     0,  -432,     0,     0,
02400        0,     0,     0,  -432,     0,  -432,  -432,  -432,  -432,  -432,
02401     -432,  -432,  -432,  -432,  -432,     0,     0,     0,     0,  -432,
02402     -432,  -432,  -432,  -432,  -285,   227,  -432,  -432,  -432,     0,
02403     -432,     0,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,
02404        0,  -285,     0,     0,     0,     0,     0,     0,     0,     0,
02405        0,  -285,  -285,  -285,     0,     0,     0,     0,     0,     0,
02406        0,  -285,  -285,     0,  -285,  -285,  -285,  -285,  -285,     0,
02407        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02408        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02409        0,     0,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02410     -285,  -285,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,
02411        0,     0,  -285,     0,     0,     0,     0,     0,  -285,     0,
02412        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02413        0,     0,  -285,     0,     0,  -285,     0,     0,  -285,  -285,
02414     -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02415        0,     0,     0,     0,     0,  -285,  -285,  -285,  -285,  -422,
02416        0,  -285,  -285,  -285,     0,  -285,     0,  -422,  -422,  -422,
02417        0,     0,  -422,  -422,  -422,     0,  -422,     0,     0,     0,
02418        0,     0,     0,     0,     0,  -422,  -422,  -422,     0,     0,
02419        0,     0,     0,     0,     0,     0,  -422,  -422,     0,  -422,
02420     -422,  -422,  -422,  -422,     0,     0,     0,     0,     0,     0,
02421        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02422        0,     0,     0,     0,     0,     0,     0,  -422,  -422,  -422,
02423     -422,  -422,  -422,  -422,  -422,  -422,  -422,  -422,  -422,  -422,
02424        0,     0,  -422,  -422,  -422,     0,     0,  -422,     0,     0,
02425        0,     0,     0,  -422,     0,     0,     0,     0,     0,     0,
02426        0,     0,     0,     0,     0,     0,     0,  -422,     0,     0,
02427        0,     0,     0,  -422,     0,  -422,  -422,  -422,  -422,  -422,
02428     -422,  -422,  -422,  -422,  -422,     0,     0,     0,     0,  -422,
02429     -422,  -422,  -422,  -422,  -301,  -422,  -422,  -422,  -422,     0,
02430     -422,     0,  -301,  -301,  -301,     0,     0,  -301,  -301,  -301,
02431        0,  -301,     0,     0,     0,     0,     0,     0,     0,     0,
02432        0,  -301,  -301,     0,     0,     0,     0,     0,     0,     0,
02433        0,  -301,  -301,     0,  -301,  -301,  -301,  -301,  -301,     0,
02434        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02435        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02436        0,     0,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02437     -301,  -301,  -301,  -301,  -301,     0,     0,  -301,  -301,  -301,
02438        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02439        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02440        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02441     -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02442        0,     0,     0,     0,     0,  -301,  -301,  -301,  -301,  -602,
02443      224,  -301,  -301,  -301,     0,  -301,     0,  -602,  -602,  -602,
02444        0,     0,     0,  -602,  -602,     0,  -602,     0,     0,     0,
02445        0,     0,     0,     0,     0,  -602,     0,     0,     0,     0,
02446        0,     0,     0,     0,     0,     0,  -602,  -602,     0,  -602,
02447     -602,  -602,  -602,  -602,     0,     0,     0,     0,     0,     0,
02448        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02449        0,     0,     0,     0,     0,     0,     0,  -602,  -602,  -602,
02450     -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02451        0,     0,  -602,  -602,  -602,     0,   700,     0,     0,     0,
02452        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02453        0,     0,     0,     0,     0,     0,     0,  -602,     0,     0,
02454        0,     0,  -106,  -602,     0,  -602,  -602,  -602,  -602,  -602,
02455     -602,  -602,  -602,  -602,  -602,     0,     0,     0,     0,  -602,
02456     -602,  -602,  -602,   -97,  -294,     0,  -602,     0,  -602,     0,
02457     -602,     0,  -294,  -294,  -294,     0,     0,     0,  -294,  -294,
02458        0,  -294,     0,  -620,     0,     0,     0,     0,     0,     0,
02459        0,  -620,  -620,  -620,     0,     0,  -620,  -620,  -620,     0,
02460     -620,  -294,  -294,     0,  -294,  -294,  -294,  -294,  -294,  -620,
02461     -620,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02462     -620,  -620,     0,  -620,  -620,  -620,  -620,  -620,     0,     0,
02463        0,     0,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02464     -294,  -294,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02465        0,   701,     0,     0,     0,     0,     0,     0,     0,     0,
02466        0,     0,     0,     0,     0,     0,     0,     0,  -620,     0,
02467        0,     0,  -294,     0,     0,     0,     0,  -108,  -294,     0,
02468     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02469        0,  -620,     0,     0,     0,  -294,  -294,  -294,   -99,     0,
02470        0,  -294,     0,  -294,     0,  -294,     0,     0,     0,     0,
02471        0,     0,     0,  -620,  -620,     0,  -620,     0,     0,   227,
02472     -620,     0,  -620,   248,  -620,     5,     6,     7,     8,     9,
02473     -620,  -620,  -620,    10,    11,     0,     0,  -620,    12,     0,
02474       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02475        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02476        0,    27,     0,     0,     0,     0,     0,    28,    29,   249,
02477       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02478        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02479        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02480        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02481        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02482       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02483        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02484        0,     0,     0,     0,     0,     0,     0,     0,    63,    64,
02485       65,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02486        0,  -620,   248,  -620,     5,     6,     7,     8,     9,     0,
02487        0,  -620,    10,    11,     0,  -620,  -620,    12,     0,    13,
02488       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02489        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02490       27,     0,     0,     0,     0,     0,    28,    29,   249,    31,
02491       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02492       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02493        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02494        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02495       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02496       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02497        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02498        0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
02499        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02500     -620,   248,  -620,     5,     6,     7,     8,     9,     0,     0,
02501     -620,    10,    11,     0,     0,  -620,    12,  -620,    13,    14,
02502       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02503       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02504        0,     0,     0,     0,     0,    28,    29,   249,    31,    32,
02505       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02506       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02507        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02508        0,     0,     0,     0,     0,     0,    48,     0,     0,    49,
02509       50,     0,    51,    52,     0,    53,     0,     0,    54,    55,
02510       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02511        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02512        0,     0,     0,     0,     0,     0,    63,    64,    65,     0,
02513        0,     0,     0,     0,     0,     0,     0,     0,     0,  -620,
02514      248,  -620,     5,     6,     7,     8,     9,     0,     0,  -620,
02515       10,    11,     0,     0,  -620,    12,     0,    13,    14,    15,
02516       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02517       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02518        0,     0,     0,     0,    28,    29,   249,    31,    32,    33,
02519       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02520        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02521        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02522        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02523        0,    51,    52,     0,    53,     0,     0,    54,    55,    56,
02524       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02525        0,     0,     0,   248,     0,     5,     6,     7,     8,     9,
02526        0,  -620,  -620,    10,    11,    63,    64,    65,    12,     0,
02527       13,    14,    15,    16,    17,    18,    19,     0,  -620,     0,
02528     -620,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02529        0,    27,     0,     0,     0,     0,     0,    28,    29,   249,
02530       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02531        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02532        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02533        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02534        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02535       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02536        0,     0,     0,     0,     0,     0,   248,     0,     5,     6,
02537        7,     8,     9,     0,     0,     0,    10,    11,    63,    64,
02538       65,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02539        0,  -620,     0,  -620,     0,    20,    21,    22,    23,    24,
02540       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02541       28,    29,   249,    31,    32,    33,    34,    35,    36,    37,
02542       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02543        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02544        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02545        0,    48,     0,     0,   250,    50,     0,    51,    52,     0,
02546       53,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02547       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02548        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02549        0,    63,    64,    65,     0,     0,     0,     0,     0,     0,
02550        0,     0,  -620,     0,  -620,   248,  -620,     5,     6,     7,
02551        8,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02552       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02553        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02554       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02555       29,   249,    31,    32,    33,    34,    35,    36,    37,    38,
02556       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02557       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02558        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02559       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02560        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02561       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02562        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02563       63,    64,    65,     0,     0,     0,     0,     0,     0,     0,
02564        0,  -620,     0,  -620,   248,  -620,     5,     6,     7,     8,
02565        9,     0,     0,     0,    10,    11,     0,     0,     0,    12,
02566        0,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02567        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02568        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02569      249,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02570       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02571       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02572        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02573        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02574        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02575        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02576        0,     0,     0,     0,     0,     0,     0,     0,     0,    63,
02577       64,    65,     0,     0,  -620,     4,     0,     5,     6,     7,
02578        8,     9,  -620,     0,  -620,    10,    11,     0,     0,     0,
02579       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02580        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02581       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02582       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
02583       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02584       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02585        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02586       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02587        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02588       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02589        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02590       63,    64,    65,     0,     0,  -620,     0,     0,     0,     0,
02591        0,     0,     0,  -620,   248,  -620,     5,     6,     7,     8,
02592        9,     0,     0,  -620,    10,    11,     0,     0,     0,    12,
02593        0,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02594        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02595        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02596      249,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02597       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02598       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02599        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02600        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02601        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02602        0,     0,     0,     0,     0,     0,     0,   248,     0,     5,
02603        6,     7,     8,     9,     0,     0,     0,    10,    11,    63,
02604       64,    65,    12,     0,    13,    14,    15,    16,    17,    18,
02605       19,     0,  -620,     0,  -620,     0,    20,    21,    22,    23,
02606       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02607        0,    28,    29,   249,    31,    32,    33,    34,    35,    36,
02608       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02609       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02610        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02611        0,     0,    48,     0,     0,    49,    50,     0,    51,    52,
02612        0,    53,     0,     0,    54,    55,    56,    57,    58,    59,
02613       60,    61,    62,     0,  -620,     0,     0,     0,     0,     0,
02614        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02615       10,    11,    63,    64,    65,    12,     0,    13,    14,    15,
02616       16,    17,    18,    19,     0,  -620,     0,  -620,     0,    20,
02617       21,    22,    23,    24,    25,    26,     0,     0,   200,     0,
02618        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02619       34,    35,    36,    37,    38,    39,    40,   201,    41,    42,
02620        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02621        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02622        0,     0,     0,     0,     0,   202,     0,     0,   203,    50,
02623        0,    51,    52,     0,   204,   205,   206,    54,    55,    56,
02624       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02625        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02626        0,     0,     0,    10,    11,    63,   207,    65,    12,     0,
02627       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02628      231,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02629        0,    27,     0,     0,     0,     0,     0,     0,    29,     0,
02630        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02631        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02632        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02633        0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
02634        0,   203,    50,     0,    51,    52,     0,     0,     0,     0,
02635       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02636        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02637        7,     0,     9,     0,     0,     0,    10,    11,    63,    64,
02638       65,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02639        0,   302,     0,   303,     0,    20,    21,    22,    23,    24,
02640       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02641        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02642       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02643        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02644        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02645        0,   202,     0,     0,   203,    50,     0,    51,    52,     0,
02646        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02647       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02648        0,     5,     6,     7,     8,     9,     0,     0,     0,    10,
02649       11,    63,    64,    65,    12,     0,    13,    14,    15,    16,
02650       17,    18,    19,     0,     0,     0,   231,     0,    20,    21,
02651       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02652        0,     0,     0,    28,    29,    30,    31,    32,    33,    34,
02653       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02654       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02655        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02656        0,     0,     0,     0,    48,     0,     0,    49,    50,     0,
02657       51,    52,     0,    53,     0,     0,    54,    55,    56,    57,
02658       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02659        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02660        0,     0,    10,    11,    63,    64,    65,    12,     0,    13,
02661       14,    15,    16,    17,    18,    19,     0,   498,     0,     0,
02662        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02663       27,     0,     0,     0,     0,     0,    28,    29,   249,    31,
02664       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02665       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02666        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02667        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02668       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02669       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02670        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02671        0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
02672        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02673      498,   118,   119,   120,   121,   122,   123,   124,   125,   126,
02674      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02675      137,   138,   139,   140,   141,     0,     0,     0,   142,   143,
02676      144,   384,   385,   386,   387,   149,   150,   151,     0,     0,
02677        0,     0,     0,   152,   153,   154,   155,   388,   389,   390,
02678      391,   160,    37,    38,   392,    40,     0,     0,     0,     0,
02679        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
02680      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
02681      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
02682        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
02683        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02684        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
02685      185,   186,   187,   188,     0,   189,   190,     0,     0,     0,
02686        0,     0,     0,   191,   393,   118,   119,   120,   121,   122,
02687      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02688      133,   134,   135,   136,   137,   138,   139,   140,   141,     0,
02689        0,     0,   142,   143,   144,   145,   146,   147,   148,   149,
02690      150,   151,     0,     0,     0,     0,     0,   152,   153,   154,
02691      155,   156,   157,   158,   159,   160,   280,   281,   161,   282,
02692        0,     0,     0,     0,     0,     0,     0,     0,   162,   163,
02693      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
02694      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
02695        0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
02696        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02697        0,     0,     0,     0,     0,     0,     0,     0,   179,   180,
02698      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
02699      190,     0,     0,     0,     0,     0,     0,   191,   118,   119,
02700      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
02701      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
02702      140,   141,     0,     0,     0,   142,   143,   144,   145,   146,
02703      147,   148,   149,   150,   151,     0,     0,     0,     0,     0,
02704      152,   153,   154,   155,   156,   157,   158,   159,   160,   233,
02705        0,   161,     0,     0,     0,     0,     0,     0,     0,     0,
02706        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
02707        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
02708        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02709      177,   178,     0,     0,    55,     0,     0,     0,     0,     0,
02710        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02711        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
02712      188,     0,   189,   190,     0,     0,     0,     0,     0,     0,
02713      191,   118,   119,   120,   121,   122,   123,   124,   125,   126,
02714      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02715      137,   138,   139,   140,   141,     0,     0,     0,   142,   143,
02716      144,   145,   146,   147,   148,   149,   150,   151,     0,     0,
02717        0,     0,     0,   152,   153,   154,   155,   156,   157,   158,
02718      159,   160,     0,     0,   161,     0,     0,     0,     0,     0,
02719        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
02720      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
02721      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
02722        0,     0,     0,   177,   178,     0,     0,    55,     0,     0,
02723        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02724        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
02725      185,   186,   187,   188,     0,   189,   190,     0,     0,     0,
02726        0,     0,     0,   191,   118,   119,   120,   121,   122,   123,
02727      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02728      134,   135,   136,   137,   138,   139,   140,   141,     0,     0,
02729        0,   142,   143,   144,   145,   146,   147,   148,   149,   150,
02730      151,     0,     0,     0,     0,     0,   152,   153,   154,   155,
02731      156,   157,   158,   159,   160,     0,     0,   161,     0,     0,
02732        0,     0,     0,     0,     0,     0,     0,   162,   163,   164,
02733      165,   166,   167,   168,   169,   170,     0,     0,   171,   172,
02734        0,     0,   173,   174,   175,   176,     0,     0,     0,     0,
02735        0,     0,     0,     0,     0,     0,   177,   178,     0,     0,
02736        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02737        0,     0,     0,     0,     0,     0,     0,   179,   180,   181,
02738      182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
02739        5,     6,     7,     0,     9,     0,   191,     0,    10,    11,
02740        0,     0,     0,    12,     0,    13,    14,    15,   238,   239,
02741       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
02742       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02743        0,     0,     0,   268,     0,     0,    32,    33,    34,    35,
02744       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02745       44,    45,     0,     0,     0,     0,     0,     0,     0,     0,
02746        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02747        0,     0,     0,   269,     0,     0,   203,    50,     0,    51,
02748       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
02749       59,    60,    61,    62,     0,     0,     0,     0,     0,     5,
02750        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02751        0,     0,    12,   270,    13,    14,    15,   238,   239,    18,
02752       19,   271,     0,     0,     0,     0,   240,   241,   242,    23,
02753       24,    25,    26,     0,     0,   200,     0,     0,     0,     0,
02754        0,     0,   268,     0,     0,    32,    33,    34,    35,    36,
02755       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02756       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02757        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02758        0,     0,   269,     0,     0,   203,    50,     0,    51,    52,
02759        0,     0,     0,     0,    54,    55,    56,    57,    58,    59,
02760       60,    61,    62,     0,     0,     0,     0,     0,     5,     6,
02761        7,     8,     9,     0,     0,     0,    10,    11,     0,     0,
02762        0,    12,   270,    13,    14,    15,    16,    17,    18,    19,
02763      518,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02764       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02765       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02766       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02767        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02768        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02769        0,    48,     0,     0,    49,    50,     0,    51,    52,     0,
02770       53,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02771       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02772        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02773       11,    63,    64,    65,    12,     0,    13,    14,    15,    16,
02774       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02775       22,    23,    24,    25,    26,     0,     0,   200,     0,     0,
02776        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02777       35,    36,    37,    38,    39,    40,   201,    41,    42,     0,
02778       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02779        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02780        0,     0,     0,     0,   202,     0,     0,   203,    50,     0,
02781       51,    52,     0,   204,   205,   206,    54,    55,    56,    57,
02782       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02783        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02784        0,     0,    10,    11,    63,   207,    65,    12,     0,    13,
02785       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02786        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02787       27,     0,     0,     0,     0,     0,    28,    29,     0,    31,
02788       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02789       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02790        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02791        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02792       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02793       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02794        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02795        0,     9,     0,     0,     0,    10,    11,    63,    64,    65,
02796       12,     0,    13,    14,    15,   238,   239,    18,    19,     0,
02797        0,     0,     0,     0,   240,   241,   242,    23,    24,    25,
02798       26,     0,     0,   200,     0,     0,     0,     0,     0,     0,
02799       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02800       39,    40,   201,    41,    42,     0,    43,    44,    45,     0,
02801       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02802        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02803      202,     0,     0,   203,    50,     0,    51,    52,     0,   608,
02804      205,   206,    54,    55,    56,    57,    58,    59,    60,    61,
02805       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02806        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02807       63,   207,    65,    12,     0,    13,    14,    15,   238,   239,
02808       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
02809       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02810        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02811       36,    37,    38,    39,    40,   201,    41,    42,     0,    43,
02812       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02813        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02814        0,     0,     0,   202,     0,     0,   203,    50,     0,    51,
02815       52,     0,   204,   205,     0,    54,    55,    56,    57,    58,
02816       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
02817        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02818        0,    10,    11,    63,   207,    65,    12,     0,    13,    14,
02819       15,   238,   239,    18,    19,     0,     0,     0,     0,     0,
02820      240,   241,   242,    23,    24,    25,    26,     0,     0,   200,
02821        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02822       33,    34,    35,    36,    37,    38,    39,    40,   201,    41,
02823       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02824        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02825        0,     0,     0,     0,     0,     0,   202,     0,     0,   203,
02826       50,     0,    51,    52,     0,     0,   205,   206,    54,    55,
02827       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02828        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02829        9,     0,     0,     0,    10,    11,    63,   207,    65,    12,
02830        0,    13,    14,    15,   238,   239,    18,    19,     0,     0,
02831        0,     0,     0,   240,   241,   242,    23,    24,    25,    26,
02832        0,     0,   200,     0,     0,     0,     0,     0,     0,    29,
02833        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02834       40,   201,    41,    42,     0,    43,    44,    45,     0,    46,
02835       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02836        0,     0,     0,     0,     0,     0,     0,     0,     0,   202,
02837        0,     0,   203,    50,     0,    51,    52,     0,   608,   205,
02838        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02839        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02840        6,     7,     0,     9,     0,     0,     0,    10,    11,    63,
02841      207,    65,    12,     0,    13,    14,    15,   238,   239,    18,
02842       19,     0,     0,     0,     0,     0,   240,   241,   242,    23,
02843       24,    25,    26,     0,     0,   200,     0,     0,     0,     0,
02844        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02845       37,    38,    39,    40,   201,    41,    42,     0,    43,    44,
02846       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02847        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02848        0,     0,   202,     0,     0,   203,    50,     0,    51,    52,
02849        0,     0,   205,     0,    54,    55,    56,    57,    58,    59,
02850       60,    61,    62,     0,     0,     0,     0,     0,     0,     0,
02851        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02852       10,    11,    63,   207,    65,    12,     0,    13,    14,    15,
02853       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02854       21,    22,    23,    24,    25,    26,     0,     0,   200,     0,
02855        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02856       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02857        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02858        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02859        0,     0,     0,     0,     0,   202,     0,     0,   203,    50,
02860        0,    51,    52,     0,   512,     0,     0,    54,    55,    56,
02861       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02862        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02863        0,     0,     0,    10,    11,    63,   207,    65,    12,     0,
02864       13,    14,    15,   238,   239,    18,    19,     0,     0,     0,
02865        0,     0,   240,   241,   242,    23,    24,    25,    26,     0,
02866        0,   200,     0,     0,     0,     0,     0,     0,    29,     0,
02867        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02868        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02869        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02870        0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
02871        0,   203,    50,     0,    51,    52,     0,   204,     0,     0,
02872       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02873        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02874        7,     0,     9,     0,     0,     0,    10,    11,    63,   207,
02875       65,    12,     0,    13,    14,    15,   238,   239,    18,    19,
02876        0,     0,     0,     0,     0,   240,   241,   242,    23,    24,
02877       25,    26,     0,     0,   200,     0,     0,     0,     0,     0,
02878        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02879       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02880        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02881        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02882        0,   202,     0,     0,   203,    50,     0,    51,    52,     0,
02883      817,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02884       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02885        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02886       11,    63,   207,    65,    12,     0,    13,    14,    15,   238,
02887      239,    18,    19,     0,     0,     0,     0,     0,   240,   241,
02888      242,    23,    24,    25,    26,     0,     0,   200,     0,     0,
02889        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02890       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02891       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02892        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02893        0,     0,     0,     0,   202,     0,     0,   203,    50,     0,
02894       51,    52,     0,   512,     0,     0,    54,    55,    56,    57,
02895       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02896        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02897        0,     0,    10,    11,    63,   207,    65,    12,     0,    13,
02898       14,    15,   238,   239,    18,    19,     0,     0,     0,     0,
02899        0,   240,   241,   242,    23,    24,    25,    26,     0,     0,
02900      200,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02901       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02902       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02903        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02904        0,     0,     0,     0,     0,     0,     0,   202,     0,     0,
02905      203,    50,     0,    51,    52,     0,   608,     0,     0,    54,
02906       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02907        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02908        0,     9,     0,     0,     0,    10,    11,    63,   207,    65,
02909       12,     0,    13,    14,    15,   238,   239,    18,    19,     0,
02910        0,     0,     0,     0,   240,   241,   242,    23,    24,    25,
02911       26,     0,     0,   200,     0,     0,     0,     0,     0,     0,
02912       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02913       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02914       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02915        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02916      202,     0,     0,   203,    50,     0,    51,    52,     0,     0,
02917        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02918       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02919        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02920       63,   207,    65,    12,     0,    13,    14,    15,    16,    17,
02921       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02922       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02923        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02924       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02925       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02926        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02927        0,     0,     0,   202,     0,     0,   203,    50,     0,    51,
02928       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
02929       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
02930        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02931        0,    10,    11,    63,   207,    65,    12,     0,    13,    14,
02932       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02933       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02934        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02935       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02936       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02937        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02938        0,     0,     0,     0,     0,     0,   202,     0,     0,   203,
02939       50,     0,    51,    52,     0,     0,     0,     0,    54,    55,
02940       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02941        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02942        9,     0,     0,     0,    10,    11,    63,    64,    65,    12,
02943        0,    13,    14,    15,   238,   239,    18,    19,     0,     0,
02944        0,     0,     0,   240,   241,   242,    23,    24,    25,    26,
02945        0,     0,   200,     0,     0,     0,     0,     0,     0,   268,
02946        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02947       40,     0,    41,    42,     0,    43,    44,    45,     0,     0,
02948        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02949        0,     0,     0,     0,     0,     0,     0,     0,     0,   269,
02950        0,     0,   323,    50,     0,    51,    52,     0,   324,     0,
02951        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02952        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02953        0,     0,     0,    10,    11,     0,     0,     0,    12,   270,
02954       13,    14,    15,   238,   239,    18,    19,     0,     0,     0,
02955        0,     0,   240,   241,   242,    23,    24,    25,    26,     0,
02956        0,   200,     0,     0,     0,     0,     0,     0,   268,     0,
02957        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02958        0,    41,    42,     0,    43,    44,    45,     0,     0,     0,
02959        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02960        0,     0,     0,     0,     0,     0,     0,     0,   365,     0,
02961        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02962       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02963        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02964        0,     0,    10,    11,     0,     0,     0,    12,   270,    13,
02965       14,    15,   238,   239,    18,    19,     0,     0,     0,     0,
02966        0,   240,   241,   242,    23,    24,    25,    26,     0,     0,
02967      200,     0,     0,     0,     0,     0,     0,   268,     0,     0,
02968       32,    33,    34,   373,    36,    37,    38,   374,    40,     0,
02969       41,    42,     0,    43,    44,    45,     0,     0,     0,     0,
02970        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02971        0,     0,     0,     0,   375,     0,     0,   376,     0,     0,
02972      203,    50,     0,    51,    52,     0,     0,     0,     0,    54,
02973       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02974        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02975        0,    10,    11,     0,     0,     0,    12,   270,    13,    14,
02976       15,   238,   239,    18,    19,     0,     0,     0,     0,     0,
02977      240,   241,   242,    23,    24,    25,    26,     0,     0,   200,
02978        0,     0,     0,     0,     0,     0,   268,     0,     0,    32,
02979       33,    34,   373,    36,    37,    38,   374,    40,     0,    41,
02980       42,     0,    43,    44,    45,     0,     0,     0,     0,     0,
02981        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02982        0,     0,     0,     0,     0,     0,   376,     0,     0,   203,
02983       50,     0,    51,    52,     0,     0,     0,     0,    54,    55,
02984       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02985        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02986       10,    11,     0,     0,     0,    12,   270,    13,    14,    15,
02987      238,   239,    18,    19,     0,     0,     0,     0,     0,   240,
02988      241,   242,    23,    24,    25,    26,     0,     0,   200,     0,
02989        0,     0,     0,     0,     0,   268,     0,     0,    32,    33,
02990       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02991        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02992        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02993        0,     0,     0,     0,     0,   269,     0,     0,   323,    50,
02994        0,    51,    52,     0,     0,     0,     0,    54,    55,    56,
02995       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02996        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02997       11,     0,     0,     0,    12,   270,    13,    14,    15,   238,
02998      239,    18,    19,     0,     0,     0,     0,     0,   240,   241,
02999      242,    23,    24,    25,    26,     0,     0,   200,     0,     0,
03000        0,     0,     0,     0,   268,     0,     0,    32,    33,    34,
03001       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
03002       43,    44,    45,     0,     0,     0,     0,     0,     0,     0,
03003        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03004        0,     0,     0,     0,   894,     0,     0,   203,    50,     0,
03005       51,    52,     0,     0,     0,     0,    54,    55,    56,    57,
03006       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
03007        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
03008        0,     0,     0,    12,   270,    13,    14,    15,   238,   239,
03009       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
03010       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
03011        0,     0,     0,   268,     0,     0,    32,    33,    34,    35,
03012       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
03013       44,    45,     0,     0,     0,     0,     0,     0,     0,     0,
03014        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03015        0,     0,     0,   974,     0,     0,   203,    50,     0,    51,
03016       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
03017       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
03018      561,   562,     0,     0,   563,     0,     0,     0,     0,     0,
03019        0,     0,     0,   270,   162,   163,   164,   165,   166,   167,
03020      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
03021      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
03022        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
03023        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03024        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
03025      185,   186,   187,   188,     0,   189,   190,   598,   562,     0,
03026        0,   599,     0,   191,     0,     0,     0,     0,     0,     0,
03027        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
03028        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
03029        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03030      177,   178,     0,     0,     0,     0,     0,     0,     0,     0,
03031        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03032        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
03033      188,     0,   189,   190,   612,   554,     0,     0,   613,     0,
03034      191,     0,     0,     0,     0,     0,     0,     0,   162,   163,
03035      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
03036      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
03037        0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
03038        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03039        0,     0,     0,     0,     0,     0,     0,     0,   179,   180,
03040      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
03041      190,   615,   562,     0,     0,   616,     0,   191,     0,     0,
03042        0,     0,     0,     0,     0,   162,   163,   164,   165,   166,
03043      167,   168,   169,   170,     0,     0,   171,   172,     0,     0,
03044      173,   174,   175,   176,     0,     0,     0,     0,     0,     0,
03045        0,     0,     0,     0,   177,   178,     0,     0,     0,     0,
03046        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03047        0,     0,     0,     0,     0,   179,   180,   181,   182,   183,
03048      184,   185,   186,   187,   188,     0,   189,   190,   639,   554,
03049        0,     0,   640,     0,   191,     0,     0,     0,     0,     0,
03050        0,     0,   162,   163,   164,   165,   166,   167,   168,   169,
03051      170,     0,     0,   171,   172,     0,     0,   173,   174,   175,
03052      176,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03053        0,   177,   178,     0,     0,     0,     0,     0,     0,     0,
03054        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03055        0,     0,   179,   180,   181,   182,   183,   184,   185,   186,
03056      187,   188,     0,   189,   190,   642,   562,     0,     0,   643,
03057        0,   191,     0,     0,     0,     0,     0,     0,     0,   162,
03058      163,   164,   165,   166,   167,   168,   169,   170,     0,     0,
03059      171,   172,     0,     0,   173,   174,   175,   176,     0,     0,
03060        0,     0,     0,     0,     0,     0,     0,     0,   177,   178,
03061        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03062        0,     0,     0,     0,     0,     0,     0,     0,     0,   179,
03063      180,   181,   182,   183,   184,   185,   186,   187,   188,     0,
03064      189,   190,   727,   554,     0,     0,   728,     0,   191,     0,
03065        0,     0,     0,     0,     0,     0,   162,   163,   164,   165,
03066      166,   167,   168,   169,   170,     0,     0,   171,   172,     0,
03067        0,   173,   174,   175,   176,     0,     0,     0,     0,     0,
03068        0,     0,     0,     0,     0,   177,   178,     0,     0,     0,
03069        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03070        0,     0,     0,     0,     0,     0,   179,   180,   181,   182,
03071      183,   184,   185,   186,   187,   188,     0,   189,   190,   730,
03072      562,     0,     0,   731,     0,   191,     0,     0,     0,     0,
03073        0,     0,     0,   162,   163,   164,   165,   166,   167,   168,
03074      169,   170,     0,     0,   171,   172,     0,     0,   173,   174,
03075      175,   176,     0,     0,     0,     0,     0,     0,     0,     0,
03076        0,     0,   177,   178,     0,     0,     0,     0,     0,     0,
03077        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03078        0,     0,     0,   179,   180,   181,   182,   183,   184,   185,
03079      186,   187,   188,     0,   189,   190,   737,   554,     0,     0,
03080      738,     0,   191,     0,     0,     0,     0,     0,     0,     0,
03081      162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
03082        0,   171,   172,     0,     0,   173,   174,   175,   176,     0,
03083        0,     0,     0,     0,     0,     0,     0,     0,     0,   177,
03084      178,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03085        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03086      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
03087        0,   189,   190,  1002,   554,     0,     0,  1003,     0,   191,
03088        0,     0,     0,     0,     0,     0,     0,   162,   163,   164,
03089      165,   166,   167,   168,   169,   170,     0,     0,   171,   172,
03090        0,     0,   173,   174,   175,   176,     0,     0,     0,     0,
03091        0,     0,     0,     0,     0,     0,   177,   178,     0,     0,
03092        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03093        0,     0,     0,     0,     0,     0,     0,   179,   180,   181,
03094      182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
03095     1037,   554,     0,     0,  1038,     0,   191,     0,     0,     0,
03096        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
03097      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
03098      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
03099        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
03100        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03101        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
03102      185,   186,   187,   188,     0,   189,   190,  1040,   562,     0,
03103        0,  1041,     0,   191,     0,     0,     0,     0,     0,     0,
03104        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
03105        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
03106        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03107      177,   178,     0,     0,     0,     0,     0,     0,     0,     0,
03108        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03109        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
03110      188,     0,   189,   190,     0,     0,     0,     0,     0,     0,
03111      191
03112 };
03113 
03114 #define yypact_value_is_default(yystate) \
03115   ((yystate) == (-808))
03116 
03117 #define yytable_value_is_error(yytable_value) \
03118   ((yytable_value) == (-621))
03119 
03120 static const yytype_int16 yycheck[] =
03121 {
03122        2,    87,    55,    96,    90,   353,    79,   355,   472,    16,
03123       17,    22,   359,    20,   354,   326,   614,     2,     8,     4,
03124       16,    17,     8,    28,    20,   326,   412,    27,    49,    29,
03125       74,     4,   220,    53,   420,    86,    87,   420,    28,    90,
03126      575,    94,    28,   641,   594,    49,   668,   685,   574,    51,
03127       52,   399,   468,    67,   262,    51,   779,   472,   266,    79,
03128       53,   376,   508,    74,    90,   511,     2,   415,     4,   417,
03129      715,    91,    92,    93,   719,   458,   416,   440,    25,   787,
03130       16,    17,    25,    13,    20,    16,    17,    13,    67,    20,
03131      875,    26,    25,    27,   873,   443,   903,   250,    37,    38,
03132       58,    29,   518,    16,    17,    64,     8,    20,    68,    87,
03133       68,    90,   777,    49,   139,   113,   141,    53,    85,    61,
03134       51,    52,    13,   471,   907,    25,    28,    76,    64,    61,
03135      470,   729,   596,   651,     0,   113,   134,   802,    96,    97,
03136       85,   779,   740,    79,   286,    15,   288,    17,   290,   787,
03137       86,    87,   294,    55,    90,    91,    92,    93,   141,    13,
03138      939,    25,   120,   123,   124,   125,   133,    26,   110,   118,
03139      323,    13,    25,    25,    25,   898,    59,    60,   110,   230,
03140       25,   232,   203,   111,   806,   807,   736,   134,   133,    13,
03141      130,   134,    94,   657,   744,   130,    56,  1004,   271,   243,
03142        1,   134,   141,   136,   134,   139,   991,   141,   259,   139,
03143      136,   141,   214,   139,   993,   141,   237,   224,   220,   226,
03144      227,   307,   308,   309,   310,   227,   252,   950,   224,   250,
03145      226,  1014,    25,   581,   134,   621,   622,   945,   252,   622,
03146      580,   429,   657,   140,   690,   593,   250,  1026,   139,    25,
03147      141,   271,   592,   771,   772,   140,   307,   308,   309,   310,
03148      898,   312,   313,   248,   886,   903,   140,   203,   268,   632,
03149      134,   130,   136,   252,   360,   361,   591,   136,   230,   743,
03150      696,   134,   134,   134,   929,   139,  1009,   141,   224,   134,
03151      226,   227,    87,   224,   230,   226,   232,   139,   670,   141,
03152      672,   237,   323,   255,   324,    61,   258,   945,    85,   360,
03153      361,   224,   248,   226,   250,   139,   117,   141,   113,   323,
03154      113,   306,   134,   259,   375,   321,   311,   853,   743,   141,
03155      326,   324,    85,   306,    85,   271,   362,   113,   139,   134,
03156      141,   134,   964,   485,   137,    61,   140,   354,   141,    65,
03157      492,   107,   354,   109,    26,   873,   133,   875,   134,    37,
03158       38,   137,   321,    85,    85,   141,  1004,   326,    85,    97,
03159      306,   307,   308,   309,   310,   311,   312,   313,   725,   132,
03160      133,   931,   133,   362,   140,   321,    85,   323,   324,    85,
03161      326,   107,   120,   109,   929,   468,   697,    59,    60,   378,
03162       28,    85,    52,   714,    54,    55,    56,    57,    61,   416,
03163      132,   133,   133,    85,   416,     2,   133,     4,   354,    26,
03164      356,   939,   940,   611,   360,   361,   428,   429,   636,    16,
03165       17,    87,   437,    20,   133,   703,   132,   133,   440,   375,
03166      990,  1039,   710,   402,   403,   518,    85,   437,   468,   133,
03167       87,   437,   134,   355,   107,   440,   109,   113,   130,   141,
03168      132,   133,    49,   470,   136,   113,   402,   403,   470,    85,
03169      422,   134,   936,   991,   426,   993,   113,    64,    85,   431,
03170      416,   412,   868,    68,   134,   868,    52,   140,    54,    55,
03171       56,    57,   113,   132,   133,   447,    87,   399,   518,    86,
03172       87,    87,    85,    90,   440,   507,   508,    87,  1026,   511,
03173      100,   883,   884,   557,   450,   417,   888,   133,   890,   891,
03174       87,   565,   113,   130,   455,   132,   133,   113,    87,   136,
03175      134,    87,   468,   113,   470,   437,   121,   122,   123,   124,
03176      125,   443,   542,   134,   595,    87,   113,   558,    58,   570,
03177      133,   572,    54,    87,    85,   566,   600,   113,    68,    85,
03178      560,    63,    64,   136,   637,   517,   568,   134,   134,   471,
03179      917,   113,   760,   580,   625,    56,   923,   134,   580,   113,
03180      576,   113,   518,    61,   141,   592,    96,    97,    88,   600,
03181      592,   136,   134,    26,   573,   574,   141,   134,   600,   137,
03182      605,   132,   133,   141,    87,   136,   132,   133,   587,   611,
03183      120,    14,    15,   134,   614,   605,   203,   637,   136,   605,
03184       52,   130,    87,   696,    56,   997,   998,   999,  1000,   107,
03185      632,   109,   110,   136,   570,   136,   572,   224,    68,   226,
03186      227,   641,   137,   230,   580,   232,   732,   632,   113,   735,
03187      237,   113,    85,   138,   131,   748,   592,    85,   594,   595,
03188      704,   248,    61,   250,   666,   686,   668,   711,   689,   134,
03189      691,  1019,   259,    56,   134,  1047,   696,    68,  1018,   581,
03190       68,   732,    94,   635,   735,   685,   110,   110,   690,   625,
03191      621,   593,   110,   746,   110,   134,   632,   130,    85,   132,
03192      133,   637,   139,   605,   132,   133,    17,    56,   107,   711,
03193      109,   110,   714,   715,   134,   717,    25,   719,   714,   306,
03194      307,   308,   309,   310,   311,   312,   313,    26,    68,   729,
03195       61,   577,   137,   134,   321,   131,   323,   130,   697,   326,
03196      740,   700,   701,    83,    84,   132,   133,    10,   707,   708,
03197      686,   140,   134,   689,   733,   691,   134,   843,   760,    85,
03198      696,   697,   134,   140,   700,   701,   745,   354,   134,   356,
03199       85,   707,   708,   360,   361,    87,   107,   777,   109,   110,
03200      800,   121,   122,   123,   124,   125,    85,    52,   375,   134,
03201      742,   113,   843,    85,   815,    68,   732,   136,     8,   735,
03202      736,   113,   802,   131,   806,   807,   132,   133,   744,   761,
03203       83,    84,    13,    61,   134,   402,   403,   132,   133,   840,
03204       61,   134,   134,   775,   113,    52,   847,   848,   134,   416,
03205      851,   130,   134,   132,   133,    52,   838,   136,   134,   841,
03206      132,   133,    15,    52,   746,   118,   119,   120,   121,   122,
03207      123,   124,   125,   440,    85,   134,   115,   878,   879,   107,
03208      138,   109,   110,   450,   800,   134,   107,   131,   109,   110,
03209      829,   892,   134,   893,   853,   113,   855,    85,   724,   815,
03210      134,    85,   118,   470,   886,   134,    16,    17,    54,    55,
03211       20,    57,   134,   829,   134,   741,   916,    63,    64,   920,
03212      139,   132,   133,    10,   840,    87,   131,   843,   860,    10,
03213      134,   847,   848,   685,    88,   851,    46,    47,     9,   685,
03214      872,    51,    52,   134,   132,   133,   118,   929,   132,   133,
03215      137,   113,   134,    56,    64,    65,   201,   134,   134,   204,
03216      205,   206,   878,   879,    52,   134,    54,    55,    56,    57,
03217       58,   131,   134,   134,    10,   134,   892,   893,   108,   980,
03218       68,   982,   964,   131,   134,   134,    56,   988,   450,   134,
03219      970,   134,   134,   134,   685,    68,   136,   136,   134,    91,
03220      916,    89,    93,   570,   920,   572,   711,  1021,    96,    97,
03221       83,    84,   771,   580,   685,   931,  1014,   749,   844,    52,
03222      846,    54,    55,    56,    57,   592,   294,   594,   595,   781,
03223      856,  1018,   120,   785,  1020,   861,  1018,    99,  1020,  1021,
03224       57,   787,    94,   781,   790,   936,   898,   120,   121,   122,
03225      123,   124,   125,   900,   779,   396,    89,    -1,   625,  1039,
03226       -1,    -1,    95,    -1,   980,   632,   982,    40,    41,    42,
03227       43,    44,   988,    -1,   990,    52,   321,    54,    55,    56,
03228       57,   326,    -1,    52,    -1,    54,    55,    56,    57,    -1,
03229      781,   201,    -1,    -1,   204,   205,   206,   207,    -1,    -1,
03230      926,   927,  1018,     2,    52,     4,    54,    55,    56,    57,
03231       -1,    -1,    89,    -1,   224,    -1,   226,   227,    95,   686,
03232       89,    -1,   689,    -1,   691,    -1,    -1,    -1,    -1,    -1,
03233      697,    -1,    -1,   700,   701,    -1,    -1,  1019,    -1,    -1,
03234      707,   708,    -1,    -1,    -1,    -1,   898,    -1,   900,    -1,
03235       49,   903,    -1,   905,    53,    -1,    -1,   903,    -1,   905,
03236       -1,    -1,    -1,   989,    -1,   732,   411,   412,   735,   736,
03237       -1,    -1,    -1,    -1,    -1,   420,    -1,   744,    -1,    -1,
03238       79,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03239       -1,    -1,    91,    92,    93,    94,  1022,    -1,  1024,   945,
03240       -1,   947,    -1,   809,   810,    -1,   952,   898,    -1,   900,
03241      455,   321,   903,   458,   905,    -1,   326,   327,   328,   329,
03242      330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
03243      340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
03244      350,   351,   352,    -1,   354,    -1,    -1,    -1,   815,    -1,
03245       -1,    -1,  1004,    -1,  1006,    -1,    -1,  1009,  1004,  1011,
03246     1006,    -1,   829,    -1,    -1,  1011,    -1,   512,    -1,    -1,
03247       -1,    -1,    -1,   840,    -1,    -1,   843,    -1,    -1,    -1,
03248      847,   848,  1028,    -1,   851,    -1,    -1,    -1,    -1,    -1,
03249       -1,    -1,   402,   403,    -1,    -1,    -1,  1049,    -1,    -1,
03250      410,   411,   412,  1049,   203,    -1,   416,    -1,   418,   419,
03251      420,   878,   879,  1004,    -1,  1006,    -1,    -1,  1009,    -1,
03252     1011,    -1,    -1,    -1,    -1,   892,    -1,    -1,    -1,   439,
03253       -1,   576,    -1,    -1,   444,    -1,    -1,    -1,   237,    -1,
03254       -1,    -1,    -1,    -1,    -1,   455,    -1,    -1,   458,   248,
03255       -1,   250,    -1,   920,    -1,   961,   962,    -1,  1049,   965,
03256      470,   967,   968,   608,   931,    -1,    -1,    -1,    -1,    -1,
03257       -1,    -1,   271,    -1,    -1,    -1,   621,   622,    -1,    -1,
03258       -1,    -1,    -1,     2,    -1,     4,   496,   497,    -1,    -1,
03259       -1,    -1,    -1,    -1,    52,    -1,    54,    55,    56,    57,
03260       58,    -1,   512,    -1,   649,    -1,    -1,   306,    -1,    -1,
03261       68,    -1,   311,   980,    -1,   982,    -1,    -1,    -1,    -1,
03262       -1,   988,    -1,   990,   323,   324,  1032,  1033,  1034,  1035,
03263       49,    89,    -1,    -1,    53,    -1,    -1,    95,    96,    97,
03264       52,    -1,    54,    55,    56,    57,    58,    -1,   693,  1055,
03265       -1,  1018,    -1,    -1,    -1,    -1,    68,   356,    -1,    -1,
03266       79,    -1,   120,    -1,    -1,   123,   576,    -1,    -1,   714,
03267      580,    -1,    91,    92,    93,    94,    -1,    89,    -1,    -1,
03268       -1,    -1,   592,   141,    96,    97,    -1,    -1,    -1,    52,
03269       -1,    54,    55,    56,    57,    58,    -1,    -1,   608,    -1,
03270       -1,    -1,    -1,    -1,    -1,    68,    -1,    -1,   120,    -1,
03271       -1,   621,   622,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03272       -1,    -1,    -1,   768,    -1,    -1,    89,    -1,    -1,    -1,
03273       -1,    -1,    95,    96,    97,    -1,    -1,    -1,    -1,   649,
03274       -1,   440,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03275       -1,   450,    -1,     2,    -1,     4,    -1,   120,    -1,    -1,
03276      123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   468,
03277       -1,    -1,   817,   136,     2,    -1,     4,    -1,    -1,    -1,
03278       -1,    -1,    -1,   693,   203,    -1,    -1,   697,   698,    -1,
03279      700,   701,    -1,     2,    -1,     4,    -1,   707,   708,    -1,
03280       49,    -1,    -1,    -1,   714,   850,    -1,    -1,    -1,    -1,
03281       52,    -1,    54,    55,    56,    57,    58,    -1,   237,   518,
03282       -1,    49,    -1,   868,    -1,    53,    68,    -1,    -1,   248,
03283       -1,   250,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03284       49,   751,    -1,    -1,    -1,   755,   756,    89,   758,   759,
03285       -1,    79,   271,    95,    96,    97,    -1,    -1,   768,    -1,
03286       -1,    -1,    -1,    91,    92,    93,    -1,    -1,    -1,    -1,
03287       -1,   570,    -1,   572,    -1,    -1,    -1,    -1,   120,    -1,
03288       -1,   123,    91,    -1,    -1,    -1,    -1,   306,    -1,    -1,
03289       -1,    -1,   311,    -1,   136,   594,    -1,    -1,    -1,    -1,
03290       -1,    -1,    -1,    -1,   323,   324,    -1,   817,    -1,    -1,
03291       -1,   821,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   829,
03292       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03293       -1,    -1,    -1,   632,    -1,    -1,    -1,   356,   637,    -1,
03294      850,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03295       -1,    -1,    -1,    -1,   203,    -1,    -1,   867,   868,    -1,
03296       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03297       76,    77,    78,    79,    80,   203,    -1,    83,    84,    -1,
03298       -1,    -1,    -1,    -1,    -1,    -1,    -1,   686,   237,    -1,
03299      689,    -1,   691,    -1,   203,    -1,    -1,   696,    -1,   248,
03300       -1,   250,    -1,    -1,    -1,    -1,    -1,    -1,   114,   237,
03301      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03302      248,   440,   250,    -1,    -1,    -1,    -1,    -1,   237,    -1,
03303       -1,   450,    -1,    -1,    -1,   141,    -1,   736,    -1,   248,
03304       -1,   250,    -1,   271,    -1,   744,    -1,    -1,    -1,   468,
03305       -1,    -1,    -1,    -1,    -1,    -1,    -1,   306,    -1,    -1,
03306       -1,    52,   311,    54,    55,    56,    57,    58,    -1,    -1,
03307       -1,    -1,    -1,    -1,   323,    -1,    -1,    68,   306,    -1,
03308       -1,    -1,    -1,   311,    -1,    -1,    -1,    -1,    -1,    -1,
03309       -1,    -1,    -1,    -1,    -1,   323,   324,   306,    89,   518,
03310       -1,   800,   311,    -1,    95,    96,    97,   356,  1018,    -1,
03311       -1,    -1,    -1,    -1,   323,    -1,   815,   326,    -1,    -1,
03312       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   356,   120,
03313       44,    -1,   123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03314       -1,   840,    -1,    -1,    -1,    -1,    -1,   356,   847,   848,
03315       -1,   570,   851,   572,    68,    69,    70,    71,    72,    73,
03316       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03317       84,    -1,    -1,    -1,    -1,   594,    -1,    -1,    -1,   878,
03318      879,    -1,    52,    -1,    54,    55,    56,    57,    58,    -1,
03319       -1,   440,    -1,   892,   893,    -1,    -1,    -1,    68,    -1,
03320      114,   450,   116,   117,   118,   119,   120,   121,   122,   123,
03321      124,   125,   440,   632,    -1,    -1,    -1,   916,   637,    89,
03322      134,   920,   450,    -1,    -1,    95,    96,    97,    -1,    -1,
03323       -1,   440,   931,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03324      468,   450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03325      120,    -1,    -1,   123,    -1,    -1,    -1,    -1,    -1,    -1,
03326       -1,    -1,    -1,    -1,    -1,    -1,    -1,   686,    -1,    -1,
03327      689,    -1,   691,    -1,    -1,    -1,    -1,   696,    -1,    -1,
03328       -1,   980,    -1,   982,    52,    53,    -1,    -1,    56,   988,
03329      518,   990,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03330       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03331       78,    -1,    -1,    81,    82,    83,    84,   736,    -1,    -1,
03332       -1,   570,    -1,   572,    -1,   744,    -1,    95,    96,    -1,
03333       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03334       -1,    -1,   570,    -1,   572,   594,    -1,    -1,   116,   117,
03335      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
03336      128,   570,    -1,   572,    -1,    -1,   594,   135,    -1,    -1,
03337       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03338       -1,   800,    -1,   632,    -1,   594,    -1,    -1,    -1,    -1,
03339       -1,    -1,    -1,    -1,    -1,    -1,   815,    -1,    -1,    -1,
03340       -1,    -1,    -1,    -1,   632,    -1,    -1,    -1,    -1,   637,
03341       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03342       -1,   840,    -1,   632,    -1,    -1,    -1,    -1,   847,   848,
03343       -1,    -1,   851,    -1,    -1,    -1,    -1,   686,    -1,    -1,
03344      689,    -1,   691,    -1,    -1,    -1,    -1,    -1,   676,    -1,
03345       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   686,   878,
03346      879,   689,    -1,   691,    -1,    -1,    -1,    -1,   696,    -1,
03347       -1,    -1,    -1,   892,   893,    -1,    -1,   686,    -1,    -1,
03348      689,    -1,   691,    -1,    -1,    -1,    -1,   736,   697,    -1,
03349       -1,    -1,    -1,    -1,    -1,   744,    -1,   916,    -1,    -1,
03350       -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,   736,    -1,
03351       -1,    -1,   931,    -1,    -1,    -1,   744,    -1,    -1,    -1,
03352       -1,    -1,    -1,    -1,    -1,    -1,    -1,   736,    68,    69,
03353       70,    71,    72,    73,    74,   744,    -1,    77,    78,    -1,
03354       -1,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,
03355       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03356       -1,   980,    -1,   982,    -1,    -1,   815,    -1,    -1,   988,
03357       -1,   990,   800,    -1,    -1,    -1,   116,   117,   118,   119,
03358      120,   121,   122,   123,   124,   125,    -1,   815,    -1,    -1,
03359       -1,   840,    -1,    -1,    -1,    -1,    -1,    -1,   847,   848,
03360       -1,    -1,   851,    -1,    -1,    -1,   815,    -1,    -1,    -1,
03361       -1,    -1,   840,    -1,    -1,    -1,    -1,    -1,    -1,   847,
03362      848,    -1,    -1,   851,    -1,    -1,    -1,    -1,    -1,   878,
03363      879,   840,    -1,    -1,    -1,    -1,    -1,    -1,   847,   848,
03364       -1,    -1,   851,   892,    -1,    -1,    -1,    -1,    -1,    -1,
03365      878,   879,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03366       -1,    -1,    -1,    -1,   892,   893,    -1,    -1,    -1,   878,
03367      879,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03368       -1,    -1,   931,   892,    -1,    -1,    -1,    -1,   916,    -1,
03369       -1,    -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03370       -1,    -1,    -1,   931,    -1,    -1,    -1,   916,    -1,    -1,
03371       -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03372       -1,    -1,   931,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03373       -1,   980,    -1,   982,    -1,    -1,    -1,    -1,    -1,   988,
03374       -1,   990,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03375       -1,    -1,   980,    -1,   982,    -1,    -1,    -1,    -1,    -1,
03376      988,    -1,   990,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03377       -1,   980,    -1,   982,    -1,    -1,    -1,    -1,    -1,   988,
03378       -1,   990,     0,     1,    -1,     3,     4,     5,     6,     7,
03379       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,
03380       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03381       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03382       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03383       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03384       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03385       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03386       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03387       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03388       98,    99,   100,   101,   102,   103,   104,   105,   106,     0,
03389       -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,     9,    10,
03390       -1,    -1,    13,    14,    15,    -1,    17,    -1,   126,   127,
03391      128,    -1,    44,    -1,    -1,    26,    27,    28,    29,    -1,
03392       -1,   139,    -1,   141,    -1,    -1,    37,    38,    -1,    40,
03393       41,    42,    43,    44,    -1,    -1,    68,    69,    70,    71,
03394       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03395       -1,    83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,
03396       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03397       -1,    -1,    83,    84,    85,    -1,    87,    88,    -1,    -1,
03398       -1,    -1,   114,    94,   116,   117,   118,   119,   120,   121,
03399      122,   123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,
03400      111,    -1,   113,   114,   115,   116,   117,   118,   119,   120,
03401      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03402      131,   132,   133,   134,     0,    -1,   137,   138,   139,    -1,
03403      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03404       -1,    17,    -1,    -1,    -1,    -1,    -1,    44,    -1,    25,
03405       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03406       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03407       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03408       77,    78,    79,    80,    -1,    -1,    83,    84,    -1,    -1,
03409       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03410       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03411       -1,    87,    88,    -1,    -1,    -1,    -1,   114,    94,   116,
03412      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03413       -1,    -1,   108,    -1,    -1,   111,    -1,   113,   114,   115,
03414      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03415       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03416       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03417       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03418       -1,    -1,    -1,    -1,    25,    -1,    27,    28,    29,    -1,
03419       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03420       41,    42,    43,    44,    -1,    -1,    68,    69,    70,    71,
03421       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03422       -1,    83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,
03423       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03424       -1,    -1,    83,    84,    85,    -1,    87,    88,    -1,    -1,
03425       -1,    -1,   114,    94,   116,   117,   118,   119,   120,   121,
03426      122,   123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,
03427      111,    -1,   113,   114,   115,   116,   117,   118,   119,   120,
03428      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,    -1,
03429      131,   132,   133,   134,     0,    -1,   137,   138,   139,    -1,
03430      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03431       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03432       26,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03433       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03434       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03435       77,    78,    79,    80,    -1,    -1,    83,    84,    -1,    -1,
03436       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03437       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03438       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,   116,
03439      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03440       -1,    -1,   108,    -1,    -1,   111,    -1,    -1,   114,   115,
03441      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03442       -1,    -1,    -1,    -1,   130,   131,   132,   133,   134,     0,
03443       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03444       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03445       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,    -1,
03446       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03447       41,    42,    43,    44,    -1,    -1,    68,    69,    70,    71,
03448       72,    73,    74,    75,    -1,    77,    78,    -1,    -1,    -1,
03449       -1,    83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,
03450       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03451       -1,    -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,
03452       -1,    -1,    -1,    94,   116,   117,   118,   119,   120,   121,
03453      122,   123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,
03454      111,    -1,    -1,   114,   115,   116,   117,   118,   119,   120,
03455      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03456      131,   132,   133,   134,     0,    -1,   137,   138,   139,    -1,
03457      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03458       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03459       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03460       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03461       -1,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
03462       77,    78,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
03463       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03464       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03465       -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    94,   116,
03466      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03467       -1,    -1,   108,    -1,    -1,   111,    -1,   113,   114,   115,
03468      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03469       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03470       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03471       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03472       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    -1,    -1,
03473       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03474       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03475       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03476       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
03477       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03478       -1,    -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,
03479       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
03480       -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
03481       -1,    -1,    -1,   114,    -1,   116,   117,   118,   119,   120,
03482      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03483      131,   132,   133,   134,     0,   136,   137,   138,   139,    -1,
03484      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03485       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03486       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03487       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03488       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03489       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03490       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03491       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03492       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,
03493       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03494       -1,    -1,   108,    -1,    -1,   111,    -1,    -1,   114,   115,
03495      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03496       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03497       -1,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03498       -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,
03499       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    -1,    -1,
03500       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03501       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03502       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03503       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
03504       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03505       -1,    -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,
03506       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
03507       -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
03508       -1,    -1,    -1,   114,    -1,   116,   117,   118,   119,   120,
03509      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03510      131,   132,   133,   134,     0,   136,   137,   138,   139,    -1,
03511      141,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03512       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03513       -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03514       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03515       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03516       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03517       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03518       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03519       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,
03520       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03521       -1,    -1,   108,    -1,    -1,    -1,    -1,    -1,   114,    -1,
03522      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03523       -1,    -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,
03524      136,   137,   138,   139,    -1,   141,    -1,     8,     9,    10,
03525       -1,    -1,    -1,    14,    15,    -1,    17,    -1,    -1,    -1,
03526       -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,
03527       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03528       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03529       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03530       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
03531       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03532       -1,    -1,    83,    84,    85,    -1,    87,    -1,    -1,    -1,
03533       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03534       -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
03535       -1,    -1,   113,   114,    -1,   116,   117,   118,   119,   120,
03536      121,   122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,
03537      131,   132,   133,   134,     0,    -1,   137,    -1,   139,    -1,
03538      141,    -1,     8,     9,    10,    -1,    -1,    -1,    14,    15,
03539       -1,    17,    -1,     0,    -1,    -1,    -1,    -1,    -1,    -1,
03540       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03541       17,    37,    38,    -1,    40,    41,    42,    43,    44,    26,
03542       27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03543       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03544       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03545       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03546       -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03547       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    85,    -1,
03548       -1,    -1,   108,    -1,    -1,    -1,    -1,   113,   114,    -1,
03549      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03550       -1,   108,    -1,    -1,    -1,   131,   132,   133,   134,    -1,
03551       -1,   137,    -1,   139,    -1,   141,    -1,    -1,    -1,    -1,
03552       -1,    -1,    -1,   130,   131,    -1,   133,    -1,    -1,   136,
03553      137,    -1,   139,     1,   141,     3,     4,     5,     6,     7,
03554        8,     9,    10,    11,    12,    -1,    -1,    15,    16,    -1,
03555       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03556       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03557       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03558       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03559       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03560       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03561       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03562       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03563       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03564       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03565       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,
03566      128,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03567       -1,   139,     1,   141,     3,     4,     5,     6,     7,    -1,
03568       -1,    10,    11,    12,    -1,    14,    15,    16,    -1,    18,
03569       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03570       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03571       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03572       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03573       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03574       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03575       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03576       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03577       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03578       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03579       -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,
03580       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03581      139,     1,   141,     3,     4,     5,     6,     7,    -1,    -1,
03582       10,    11,    12,    -1,    -1,    15,    16,    17,    18,    19,
03583       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03584       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03585       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03586       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03587       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03588       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03589       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03590       90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,
03591      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
03592       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03593       -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,    -1,
03594       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   139,
03595        1,   141,     3,     4,     5,     6,     7,    -1,    -1,    10,
03596       11,    12,    -1,    -1,    15,    16,    -1,    18,    19,    20,
03597       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03598       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03599       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
03600       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03601       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03602       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03603       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03604       -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,   100,
03605      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03606       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03607       -1,     9,    10,    11,    12,   126,   127,   128,    16,    -1,
03608       18,    19,    20,    21,    22,    23,    24,    -1,   139,    -1,
03609      141,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03610       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03611       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03612       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03613       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03614       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03615       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03616       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03617       -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,
03618        5,     6,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03619      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03620       -1,   139,    -1,   141,    -1,    30,    31,    32,    33,    34,
03621       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03622       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03623       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03624       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03625       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03626       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03627       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03628      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03629       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03630       -1,   126,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
03631       -1,    -1,   137,    -1,   139,     1,   141,     3,     4,     5,
03632        6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03633       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03634       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03635       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03636       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03637       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03638       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03639       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03640       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03641       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03642      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03643       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03644      126,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03645       -1,   137,    -1,   139,     1,   141,     3,     4,     5,     6,
03646        7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,
03647       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03648       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03649       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03650       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03651       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03652       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03653       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03654       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03655       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03656       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03657       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,
03658      127,   128,    -1,    -1,   131,     1,    -1,     3,     4,     5,
03659        6,     7,   139,    -1,   141,    11,    12,    -1,    -1,    -1,
03660       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03661       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03662       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03663       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03664       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03665       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03666       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03667       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03668       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03669      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03670       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03671      126,   127,   128,    -1,    -1,   131,    -1,    -1,    -1,    -1,
03672       -1,    -1,    -1,   139,     1,   141,     3,     4,     5,     6,
03673        7,    -1,    -1,    10,    11,    12,    -1,    -1,    -1,    16,
03674       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03675       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03676       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03677       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03678       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03679       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03680       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03681       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03682       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03683       -1,    -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,
03684        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   126,
03685      127,   128,    16,    -1,    18,    19,    20,    21,    22,    23,
03686       24,    -1,   139,    -1,   141,    -1,    30,    31,    32,    33,
03687       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03688       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03689       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03690       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03691       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03692       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03693       -1,    95,    -1,    -1,    98,    99,   100,   101,   102,   103,
03694      104,   105,   106,    -1,   108,    -1,    -1,    -1,    -1,    -1,
03695       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03696       11,    12,   126,   127,   128,    16,    -1,    18,    19,    20,
03697       21,    22,    23,    24,    -1,   139,    -1,   141,    -1,    30,
03698       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03699       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03700       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03701       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03702       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03703       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03704       -1,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
03705      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03706       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03707       -1,    -1,    -1,    11,    12,   126,   127,   128,    16,    -1,
03708       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03709      141,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03710       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03711       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03712       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03713       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03714       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03715       -1,    89,    90,    -1,    92,    93,    -1,    -1,    -1,    -1,
03716       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03717       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03718        5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03719      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03720       -1,   139,    -1,   141,    -1,    30,    31,    32,    33,    34,
03721       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03722       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03723       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03724       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03725       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03726       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03727       -1,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03728      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03729       -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,    11,
03730       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03731       22,    23,    24,    -1,    -1,    -1,   141,    -1,    30,    31,
03732       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03733       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03734       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03735       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03736       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03737       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03738       92,    93,    -1,    95,    -1,    -1,    98,    99,   100,   101,
03739      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03740       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03741       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03742       19,    20,    21,    22,    23,    24,    -1,   139,    -1,    -1,
03743       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03744       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03745       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03746       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03747       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03748       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03749       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03750       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03751       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03752       -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,
03753       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03754      139,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03755       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03756       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03757       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03758       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03759       52,    53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,
03760       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03761       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03762       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03763       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
03764       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03765       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
03766      122,   123,   124,   125,    -1,   127,   128,    -1,    -1,    -1,
03767       -1,    -1,    -1,   135,   136,     3,     4,     5,     6,     7,
03768        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03769       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
03770       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
03771       38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03772       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03773       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03774       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03775       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03776       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,
03777       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03778       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,
03779      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
03780      128,    -1,    -1,    -1,    -1,    -1,    -1,   135,     3,     4,
03781        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03782       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03783       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03784       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03785       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03786       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03787       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03788       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03789       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03790       95,    96,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,
03791       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03792       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
03793      125,    -1,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
03794      135,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03795       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03796       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03797       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03798       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03799       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
03800       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03801       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03802       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03803       -1,    -1,    -1,    95,    96,    -1,    -1,    99,    -1,    -1,
03804       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03805       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
03806      122,   123,   124,   125,    -1,   127,   128,    -1,    -1,    -1,
03807       -1,    -1,    -1,   135,     3,     4,     5,     6,     7,     8,
03808        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03809       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03810       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03811       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03812       49,    50,    51,    52,    53,    -1,    -1,    56,    -1,    -1,
03813       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,
03814       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03815       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03816       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
03817       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03818       -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,
03819      119,   120,   121,   122,   123,   124,   125,    -1,   127,   128,
03820        3,     4,     5,    -1,     7,    -1,   135,    -1,    11,    12,
03821       -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,    22,
03822       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03823       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03824       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03825       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03826       63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03827       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03828       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03829       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
03830      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,     3,
03831        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03832       -1,    -1,    16,   126,    18,    19,    20,    21,    22,    23,
03833       24,   134,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03834       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03835       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03836       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03837       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03838       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03839       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03840       -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,   103,
03841      104,   105,   106,    -1,    -1,    -1,    -1,    -1,     3,     4,
03842        5,     6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,
03843       -1,    16,   126,    18,    19,    20,    21,    22,    23,    24,
03844      134,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03845       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03846       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03847       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03848       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03850       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03851       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03852      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03853       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03854       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03855       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03856       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03857       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03858       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03859       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03860       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03861       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03862       92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
03863      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03864       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03865       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03866       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03867       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03868       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,    48,
03869       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03870       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03871       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03872       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03873       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03874       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03875       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03876       -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,   128,
03877       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03878       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03879       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03880       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03881       56,    57,    58,    59,    60,    -1,    62,    63,    64,    -1,
03882       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03883       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03884       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03885       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03886      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03887        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03888      126,   127,   128,    16,    -1,    18,    19,    20,    21,    22,
03889       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03890       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03891       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03892       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03893       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03894       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03895       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03896       93,    -1,    95,    96,    -1,    98,    99,   100,   101,   102,
03897      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
03898       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03899       -1,    11,    12,   126,   127,   128,    16,    -1,    18,    19,
03900       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03901       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03902       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03903       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03904       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03905       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03906       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03907       90,    -1,    92,    93,    -1,    -1,    96,    97,    98,    99,
03908      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
03909       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03910        7,    -1,    -1,    -1,    11,    12,   126,   127,   128,    16,
03911       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03912       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03913       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03914       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03915       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03916       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03917       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03918       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    96,
03919       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03920       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03921        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,
03922      127,   128,    16,    -1,    18,    19,    20,    21,    22,    23,
03923       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03924       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03925       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03926       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03927       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03928       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03929       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03930       -1,    -1,    96,    -1,    98,    99,   100,   101,   102,   103,
03931      104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03932       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03933       11,    12,   126,   127,   128,    16,    -1,    18,    19,    20,
03934       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03935       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03936       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03937       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03938       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03939       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03940       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03941       -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,   100,
03942      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03943       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03944       -1,    -1,    -1,    11,    12,   126,   127,   128,    16,    -1,
03945       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03946       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03947       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03948       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03949       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03950       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03951       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03952       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03953       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03954       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03955        5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03956      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03957       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03958       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03959       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03960       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03961       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03962       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03963       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03964       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03965      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03966       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03967       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03968       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03969       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03970       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03971       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03972       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03973       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03974       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03975       92,    93,    -1,    95,    -1,    -1,    98,    99,   100,   101,
03976      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03977       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03978       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03979       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03980       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03981       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03982       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03983       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03984       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03985       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03986       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03987       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03988       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03989       -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,   128,
03990       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03991       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03992       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03993       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03994       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03995       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03996       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03997       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03998       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03999      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04000        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04001      126,   127,   128,    16,    -1,    18,    19,    20,    21,    22,
04002       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04003       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04004       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04005       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
04006       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
04007       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04008       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04009       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
04010      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04011       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04012       -1,    11,    12,   126,   127,   128,    16,    -1,    18,    19,
04013       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04014       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04015       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04016       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04017       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
04018       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04019       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04020       90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,
04021      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04022       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
04023        7,    -1,    -1,    -1,    11,    12,   126,   127,   128,    16,
04024       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
04025       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
04026       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
04027       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
04028       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    -1,
04029       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04030       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
04031       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
04032       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
04033       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
04034       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,   126,
04035       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
04036       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
04037       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
04038       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
04039       -1,    59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,
04040       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04041       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
04042       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
04043       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
04044       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04045       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   126,    18,
04046       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04047       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04048       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04049       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04050       59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,
04051       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04052       -1,    -1,    -1,    -1,    83,    -1,    -1,    86,    -1,    -1,
04053       89,    90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,
04054       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
04055       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04056       -1,    11,    12,    -1,    -1,    -1,    16,   126,    18,    19,
04057       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04058       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04059       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04060       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04061       60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,
04062       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04063       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04064       90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,
04065      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04066       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
04067       11,    12,    -1,    -1,    -1,    16,   126,    18,    19,    20,
04068       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
04069       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
04070       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
04071       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
04072       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
04073       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04074       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
04075       -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,   100,
04076      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
04077       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
04078       12,    -1,    -1,    -1,    16,   126,    18,    19,    20,    21,
04079       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
04080       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
04081       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
04082       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
04083       62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04084       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04085       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
04086       92,    93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,
04087      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
04088        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04089       -1,    -1,    -1,    16,   126,    18,    19,    20,    21,    22,
04090       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04091       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04092       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04093       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
04094       63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04095       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04096       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04097       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
04098      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04099       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
04100       -1,    -1,    -1,   126,    66,    67,    68,    69,    70,    71,
04101       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04102       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04103       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
04104       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04105       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
04106      122,   123,   124,   125,    -1,   127,   128,    52,    53,    -1,
04107       -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,
04108       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04109       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04110       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04111       95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04112       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04113       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
04114      125,    -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,
04115      135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
04116       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
04117       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
04118       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,
04119       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04120       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,
04121      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
04122      128,    52,    53,    -1,    -1,    56,    -1,   135,    -1,    -1,
04123       -1,    -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,
04124       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
04125       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
04126       -1,    -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,
04127       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04128       -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,
04129      121,   122,   123,   124,   125,    -1,   127,   128,    52,    53,
04130       -1,    -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,
04131       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
04132       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
04133       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04134       -1,    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04135       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04136       -1,    -1,   116,   117,   118,   119,   120,   121,   122,   123,
04137      124,   125,    -1,   127,   128,    52,    53,    -1,    -1,    56,
04138       -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,
04139       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
04140       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
04141       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,
04142       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04143       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,
04144      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
04145      127,   128,    52,    53,    -1,    -1,    56,    -1,   135,    -1,
04146       -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,    69,
04147       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
04148       -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,
04149       -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,    -1,
04150       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04151       -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,
04152      120,   121,   122,   123,   124,   125,    -1,   127,   128,    52,
04153       53,    -1,    -1,    56,    -1,   135,    -1,    -1,    -1,    -1,
04154       -1,    -1,    -1,    66,    67,    68,    69,    70,    71,    72,
04155       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
04156       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04157       -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,
04158       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04159       -1,    -1,    -1,   116,   117,   118,   119,   120,   121,   122,
04160      123,   124,   125,    -1,   127,   128,    52,    53,    -1,    -1,
04161       56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04162       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
04163       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
04164       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
04165       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04166       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04167      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
04168       -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,   135,
04169       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,
04170       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
04171       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
04172       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
04173       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04174       -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,
04175      119,   120,   121,   122,   123,   124,   125,    -1,   127,   128,
04176       52,    53,    -1,    -1,    56,    -1,   135,    -1,    -1,    -1,
04177       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
04178       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04179       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04180       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
04181       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04182       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
04183      122,   123,   124,   125,    -1,   127,   128,    52,    53,    -1,
04184       -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,
04185       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04186       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04187       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04188       95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04189       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04190       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
04191      125,    -1,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
04192      135
04193 };
04194 
04195 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04196    symbol of state STATE-NUM.  */
04197 static const yytype_uint16 yystos[] =
04198 {
04199        0,   143,   144,     0,     1,     3,     4,     5,     6,     7,
04200       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04201       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04202       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04203       57,    59,    60,    62,    63,    64,    66,    67,    86,    89,
04204       90,    92,    93,    95,    98,    99,   100,   101,   102,   103,
04205      104,   105,   106,   126,   127,   128,   145,   146,   147,   154,
04206      156,   157,   159,   160,   163,   164,   165,   167,   168,   169,
04207      171,   172,   182,   196,   215,   216,   217,   218,   219,   220,
04208      221,   222,   223,   224,   225,   251,   252,   266,   267,   268,
04209      269,   270,   271,   272,   275,   277,   278,   290,   292,   293,
04210      294,   295,   296,   297,   298,   329,   340,   147,     3,     4,
04211        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
04212       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
04213       25,    26,    30,    31,    32,    33,    34,    35,    36,    37,
04214       38,    39,    45,    46,    47,    48,    49,    50,    51,    52,
04215       53,    56,    66,    67,    68,    69,    70,    71,    72,    73,
04216       74,    77,    78,    81,    82,    83,    84,    95,    96,   116,
04217      117,   118,   119,   120,   121,   122,   123,   124,   125,   127,
04218      128,   135,   175,   176,   177,   178,   180,   181,   290,   292,
04219       39,    58,    86,    89,    95,    96,    97,   127,   164,   172,
04220      182,   184,   189,   192,   194,   215,   294,   295,   297,   298,
04221      327,   328,   189,   189,   136,   190,   191,   136,   186,   190,
04222      136,   141,   334,    54,   177,   334,   148,   130,    21,    22,
04223       30,    31,    32,   163,   182,   215,   182,    56,     1,    47,
04224       89,   150,   151,   152,   154,   166,   167,   340,   198,   199,
04225      185,   194,   327,   340,   184,   326,   327,   340,    46,    86,
04226      126,   134,   171,   196,   215,   294,   295,   298,   243,   244,
04227       54,    55,    57,   175,   282,   291,   281,   282,   283,   140,
04228      273,   140,   279,   140,   276,   140,   280,    59,    60,   159,
04229      182,   182,   139,   141,   333,   338,   339,    40,    41,    42,
04230       43,    44,    37,    38,    26,   130,   186,   190,   257,    28,
04231      249,   113,   134,    89,    95,   168,   113,    68,    69,    70,
04232       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
04233       83,    84,   114,   116,   117,   118,   119,   120,   121,   122,
04234      123,   124,   125,    85,   132,   133,   197,   157,   158,   158,
04235      202,   204,   158,   333,   339,    86,   165,   172,   215,   231,
04236      294,   295,   298,    52,    56,    83,    86,   173,   174,   215,
04237      294,   295,   298,   174,    33,    34,    35,    36,    49,    50,
04238       51,    52,    56,   136,   175,   296,   324,    85,   133,   332,
04239      257,   269,    87,    87,   134,   184,    56,   184,   184,   184,
04240      113,    88,   134,   193,   340,    85,   132,   133,    87,    87,
04241      134,   193,   189,   334,   335,   189,   188,   189,   194,   327,
04242      340,   157,   335,   157,    54,    63,    64,   155,   136,   183,
04243      130,   150,    85,   133,    87,   154,   153,   166,   137,   333,
04244      339,   335,   335,   157,   138,   134,   141,   337,   134,   337,
04245      131,   337,   334,    56,    59,    60,   168,   170,   134,    85,
04246      132,   133,   245,    61,   107,   109,   110,   284,   110,   284,
04247      110,    65,   284,   110,   110,   274,   284,   110,    61,   110,
04248      110,   110,   274,   110,    61,   110,    68,    68,   139,   147,
04249      158,   158,   158,   158,   154,   157,   157,   259,   258,    94,
04250      161,   250,    95,   159,   184,   194,   195,   166,   134,   171,
04251      134,   156,   159,   172,   182,   184,   195,   182,   182,   182,
04252      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
04253      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
04254      182,   182,   182,    52,    53,    56,   180,   256,   330,   331,
04255      188,    52,    53,    56,   180,   255,   330,   149,   150,    13,
04256      227,   338,   227,   158,   158,   333,    17,   260,    56,    85,
04257      132,   133,    25,   157,    52,    56,   173,     1,   117,   299,
04258      338,    85,   132,   133,   211,   325,   212,   332,    52,    56,
04259      330,   159,   182,   159,   182,   179,   182,   184,    95,   184,
04260      192,   327,    52,    56,   188,    52,    56,   328,   335,   137,
04261      335,   134,   134,   335,   177,   201,   182,   145,   131,   330,
04262      330,   182,   130,   335,   152,   200,   327,   134,   170,    52,
04263       56,   188,    52,    56,    52,    54,    55,    56,    57,    58,
04264       68,    89,    95,    96,    97,   120,   123,   136,   247,   302,
04265      304,   305,   306,   307,   308,   309,   312,   313,   314,   315,
04266      318,   319,   320,   321,   322,   286,   285,   140,   284,   140,
04267      140,   140,   182,   182,    76,   118,   238,   239,   340,   238,
04268      162,   238,   184,   134,   335,   170,   134,   113,    44,   334,
04269       87,    87,   186,   190,   254,   334,   336,    87,    87,   186,
04270      190,   253,    10,   226,     8,   262,   340,   150,    13,   150,
04271       27,   228,   338,   228,   260,   194,   226,    52,    56,   188,
04272       52,    56,   206,   209,   338,   300,   208,    52,    56,   173,
04273      188,   149,   157,   136,   301,   304,   213,   186,   187,   190,
04274      340,    44,   177,   184,   193,    87,    87,   336,    87,    87,
04275      327,   157,   131,   145,   335,   337,   168,   336,   113,   184,
04276       52,    89,    95,   232,   233,   234,   306,   304,   246,   134,
04277      303,   134,   323,   340,    52,   134,   323,   134,   303,    52,
04278      134,   303,    52,   287,    54,    55,    57,   289,   298,    52,
04279       58,   235,   237,   240,   308,   310,   311,   314,   316,   317,
04280      320,   322,   334,   150,   150,   238,   150,    95,   184,   170,
04281      182,   115,   159,   182,   159,   182,   161,   186,   138,    87,
04282      159,   182,   159,   182,   161,   187,   184,   195,   263,   340,
04283       15,   230,   340,    14,   229,   230,   230,   203,   205,   226,
04284      134,   227,   336,   158,   338,   158,   149,   336,   226,   335,
04285      304,   149,   338,   175,   257,   249,   182,    87,   134,   335,
04286      131,   184,   234,   134,   306,   134,   335,   240,    29,   111,
04287      248,   302,   307,   318,   320,   309,   314,   322,   308,   315,
04288      320,   308,   288,   113,    86,   215,   240,   118,   134,   236,
04289      134,   323,   323,   134,   236,   134,   236,   139,    10,   131,
04290      150,    10,   184,   182,   159,   182,    88,   264,   340,   150,
04291        9,   265,   340,   158,   226,   226,   150,   150,   184,   150,
04292      228,   210,   338,   226,   335,   226,   214,   335,   233,   134,
04293       95,   232,   137,   150,   150,   134,   303,   134,   303,   323,
04294      134,   303,   134,   303,   303,   150,   215,    56,    85,   118,
04295      235,   317,   320,   310,   314,   308,   316,   320,   308,    52,
04296      241,   242,   305,   131,    86,   172,   215,   294,   295,   298,
04297      227,   150,   227,   226,   226,   230,   260,   261,   207,   149,
04298      301,   134,   233,   134,   306,    10,   131,   308,   320,   308,
04299      308,   108,    52,    56,   134,   236,   134,   236,   323,   134,
04300      236,   134,   236,   236,   134,   334,    56,    85,   132,   133,
04301      150,   150,   150,   226,   149,   233,   134,   303,   134,   303,
04302      303,   303,   308,   320,   308,   308,   242,    52,    56,   188,
04303       52,    56,   262,   229,   226,   226,   233,   308,   236,   134,
04304      236,   236,   236,   336,   303,   308,   236
04305 };
04306 
04307 #define yyerrok         (yyerrstatus = 0)
04308 #define yyclearin       (yychar = YYEMPTY)
04309 #define YYEMPTY         (-2)
04310 #define YYEOF           0
04311 
04312 #define YYACCEPT        goto yyacceptlab
04313 #define YYABORT         goto yyabortlab
04314 #define YYERROR         goto yyerrorlab
04315 
04316 
04317 /* Like YYERROR except do call yyerror.  This remains here temporarily
04318    to ease the transition to the new meaning of YYERROR, for GCC.
04319    Once GCC version 2 has supplanted version 1, this can go.  However,
04320    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04321    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04322    discussed.  */
04323 
04324 #define YYFAIL          goto yyerrlab
04325 #if defined YYFAIL
04326   /* This is here to suppress warnings from the GCC cpp's
04327      -Wunused-macros.  Normally we don't worry about that warning, but
04328      some users do, and we want to make it easy for users to remove
04329      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04330 #endif
04331 
04332 #define YYRECOVERING()  (!!yyerrstatus)
04333 
04334 #define YYBACKUP(Token, Value)                                  \
04335 do                                                              \
04336   if (yychar == YYEMPTY && yylen == 1)                          \
04337     {                                                           \
04338       yychar = (Token);                                         \
04339       yylval = (Value);                                         \
04340       YYPOPSTACK (1);                                           \
04341       goto yybackup;                                            \
04342     }                                                           \
04343   else                                                          \
04344     {                                                           \
04345       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04346       YYERROR;                                                  \
04347     }                                                           \
04348 while (YYID (0))
04349 
04350 
04351 #define YYTERROR        1
04352 #define YYERRCODE       256
04353 
04354 
04355 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04356    If N is 0, then set CURRENT to the empty location which ends
04357    the previous symbol: RHS[0] (always defined).  */
04358 
04359 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04360 #ifndef YYLLOC_DEFAULT
04361 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04362     do                                                                  \
04363       if (YYID (N))                                                    \
04364         {                                                               \
04365           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04366           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04367           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04368           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04369         }                                                               \
04370       else                                                              \
04371         {                                                               \
04372           (Current).first_line   = (Current).last_line   =              \
04373             YYRHSLOC (Rhs, 0).last_line;                                \
04374           (Current).first_column = (Current).last_column =              \
04375             YYRHSLOC (Rhs, 0).last_column;                              \
04376         }                                                               \
04377     while (YYID (0))
04378 #endif
04379 
04380 
04381 /* This macro is provided for backward compatibility. */
04382 
04383 #ifndef YY_LOCATION_PRINT
04384 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04385 #endif
04386 
04387 
04388 /* YYLEX -- calling `yylex' with the right arguments.  */
04389 
04390 #ifdef YYLEX_PARAM
04391 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04392 #else
04393 # define YYLEX yylex (&yylval, parser)
04394 #endif
04395 
04396 /* Enable debugging if requested.  */
04397 #if YYDEBUG
04398 
04399 # ifndef YYFPRINTF
04400 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04401 #  define YYFPRINTF fprintf
04402 # endif
04403 
04404 # define YYDPRINTF(Args)                        \
04405 do {                                            \
04406   if (yydebug)                                  \
04407     YYFPRINTF Args;                             \
04408 } while (YYID (0))
04409 
04410 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04411 do {                                                                      \
04412   if (yydebug)                                                            \
04413     {                                                                     \
04414       YYFPRINTF (stderr, "%s ", Title);                                   \
04415       yy_symbol_print (stderr,                                            \
04416                   Type, Value, parser); \
04417       YYFPRINTF (stderr, "\n");                                           \
04418     }                                                                     \
04419 } while (YYID (0))
04420 
04421 
04422 /*--------------------------------.
04423 | Print this symbol on YYOUTPUT.  |
04424 `--------------------------------*/
04425 
04426 /*ARGSUSED*/
04427 #if (defined __STDC__ || defined __C99__FUNC__ \
04428      || defined __cplusplus || defined _MSC_VER)
04429 static void
04430 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04431 #else
04432 static void
04433 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04434     FILE *yyoutput;
04435     int yytype;
04436     YYSTYPE const * const yyvaluep;
04437     struct parser_params *parser;
04438 #endif
04439 {
04440   if (!yyvaluep)
04441     return;
04442   YYUSE (parser);
04443 # ifdef YYPRINT
04444   if (yytype < YYNTOKENS)
04445     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04446 # else
04447   YYUSE (yyoutput);
04448 # endif
04449   switch (yytype)
04450     {
04451       default:
04452         break;
04453     }
04454 }
04455 
04456 
04457 /*--------------------------------.
04458 | Print this symbol on YYOUTPUT.  |
04459 `--------------------------------*/
04460 
04461 #if (defined __STDC__ || defined __C99__FUNC__ \
04462      || defined __cplusplus || defined _MSC_VER)
04463 static void
04464 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04465 #else
04466 static void
04467 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04468     FILE *yyoutput;
04469     int yytype;
04470     YYSTYPE const * const yyvaluep;
04471     struct parser_params *parser;
04472 #endif
04473 {
04474   if (yytype < YYNTOKENS)
04475     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04476   else
04477     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04478 
04479   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04480   YYFPRINTF (yyoutput, ")");
04481 }
04482 
04483 /*------------------------------------------------------------------.
04484 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04485 | TOP (included).                                                   |
04486 `------------------------------------------------------------------*/
04487 
04488 #if (defined __STDC__ || defined __C99__FUNC__ \
04489      || defined __cplusplus || defined _MSC_VER)
04490 static void
04491 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04492 #else
04493 static void
04494 yy_stack_print (yybottom, yytop)
04495     yytype_int16 *yybottom;
04496     yytype_int16 *yytop;
04497 #endif
04498 {
04499   YYFPRINTF (stderr, "Stack now");
04500   for (; yybottom <= yytop; yybottom++)
04501     {
04502       int yybot = *yybottom;
04503       YYFPRINTF (stderr, " %d", yybot);
04504     }
04505   YYFPRINTF (stderr, "\n");
04506 }
04507 
04508 # define YY_STACK_PRINT(Bottom, Top)                            \
04509 do {                                                            \
04510   if (yydebug)                                                  \
04511     yy_stack_print ((Bottom), (Top));                           \
04512 } while (YYID (0))
04513 
04514 
04515 /*------------------------------------------------.
04516 | Report that the YYRULE is going to be reduced.  |
04517 `------------------------------------------------*/
04518 
04519 #if (defined __STDC__ || defined __C99__FUNC__ \
04520      || defined __cplusplus || defined _MSC_VER)
04521 static void
04522 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04523 #else
04524 static void
04525 yy_reduce_print (yyvsp, yyrule, parser)
04526     YYSTYPE *yyvsp;
04527     int yyrule;
04528     struct parser_params *parser;
04529 #endif
04530 {
04531   int yynrhs = yyr2[yyrule];
04532   int yyi;
04533   unsigned long int yylno = yyrline[yyrule];
04534   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04535              yyrule - 1, yylno);
04536   /* The symbols being reduced.  */
04537   for (yyi = 0; yyi < yynrhs; yyi++)
04538     {
04539       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04540       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04541                        &(yyvsp[(yyi + 1) - (yynrhs)])
04542                                        , parser);
04543       YYFPRINTF (stderr, "\n");
04544     }
04545 }
04546 
04547 # define YY_REDUCE_PRINT(Rule)          \
04548 do {                                    \
04549   if (yydebug)                          \
04550     yy_reduce_print (yyvsp, Rule, parser); \
04551 } while (YYID (0))
04552 
04553 /* Nonzero means print parse trace.  It is left uninitialized so that
04554    multiple parsers can coexist.  */
04555 #ifndef yydebug
04556 int yydebug;
04557 #endif
04558 #else /* !YYDEBUG */
04559 # define YYDPRINTF(Args)
04560 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04561 # define YY_STACK_PRINT(Bottom, Top)
04562 # define YY_REDUCE_PRINT(Rule)
04563 #endif /* !YYDEBUG */
04564 
04565 
04566 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04567 #ifndef YYINITDEPTH
04568 # define YYINITDEPTH 200
04569 #endif
04570 
04571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04572    if the built-in stack extension method is used).
04573 
04574    Do not make this value too large; the results are undefined if
04575    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04576    evaluated with infinite-precision integer arithmetic.  */
04577 
04578 #ifndef YYMAXDEPTH
04579 # define YYMAXDEPTH 10000
04580 #endif
04581 
04582 
04583 #if YYERROR_VERBOSE
04584 
04585 # ifndef yystrlen
04586 #  if defined __GLIBC__ && defined _STRING_H
04587 #   define yystrlen strlen
04588 #  else
04589 /* Return the length of YYSTR.  */
04590 #if (defined __STDC__ || defined __C99__FUNC__ \
04591      || defined __cplusplus || defined _MSC_VER)
04592 static YYSIZE_T
04593 yystrlen (const char *yystr)
04594 #else
04595 static YYSIZE_T
04596 yystrlen (yystr)
04597     const char *yystr;
04598 #endif
04599 {
04600   YYSIZE_T yylen;
04601   for (yylen = 0; yystr[yylen]; yylen++)
04602     continue;
04603   return yylen;
04604 }
04605 #  endif
04606 # endif
04607 
04608 # ifndef yystpcpy
04609 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04610 #   define yystpcpy stpcpy
04611 #  else
04612 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04613    YYDEST.  */
04614 #if (defined __STDC__ || defined __C99__FUNC__ \
04615      || defined __cplusplus || defined _MSC_VER)
04616 static char *
04617 yystpcpy (char *yydest, const char *yysrc)
04618 #else
04619 static char *
04620 yystpcpy (yydest, yysrc)
04621     char *yydest;
04622     const char *yysrc;
04623 #endif
04624 {
04625   char *yyd = yydest;
04626   const char *yys = yysrc;
04627 
04628   while ((*yyd++ = *yys++) != '\0')
04629     continue;
04630 
04631   return yyd - 1;
04632 }
04633 #  endif
04634 # endif
04635 
04636 # ifndef yytnamerr
04637 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04638    quotes and backslashes, so that it's suitable for yyerror.  The
04639    heuristic is that double-quoting is unnecessary unless the string
04640    contains an apostrophe, a comma, or backslash (other than
04641    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04642    null, do not copy; instead, return the length of what the result
04643    would have been.  */
04644 static YYSIZE_T
04645 yytnamerr (char *yyres, const char *yystr)
04646 {
04647   if (*yystr == '"')
04648     {
04649       YYSIZE_T yyn = 0;
04650       char const *yyp = yystr;
04651 
04652       for (;;)
04653         switch (*++yyp)
04654           {
04655           case '\'':
04656           case ',':
04657             goto do_not_strip_quotes;
04658 
04659           case '\\':
04660             if (*++yyp != '\\')
04661               goto do_not_strip_quotes;
04662             /* Fall through.  */
04663           default:
04664             if (yyres)
04665               yyres[yyn] = *yyp;
04666             yyn++;
04667             break;
04668 
04669           case '"':
04670             if (yyres)
04671               yyres[yyn] = '\0';
04672             return yyn;
04673           }
04674     do_not_strip_quotes: ;
04675     }
04676 
04677   if (! yyres)
04678     return yystrlen (yystr);
04679 
04680   return yystpcpy (yyres, yystr) - yyres;
04681 }
04682 # endif
04683 
04684 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
04685    about the unexpected token YYTOKEN for the state stack whose top is
04686    YYSSP.
04687 
04688    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
04689    not large enough to hold the message.  In that case, also set
04690    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
04691    required number of bytes is too large to store.  */
04692 static int
04693 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
04694                 yytype_int16 *yyssp, int yytoken)
04695 {
04696   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
04697   YYSIZE_T yysize = yysize0;
04698   YYSIZE_T yysize1;
04699   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04700   /* Internationalized format string. */
04701   const char *yyformat = 0;
04702   /* Arguments of yyformat. */
04703   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04704   /* Number of reported tokens (one for the "unexpected", one per
04705      "expected"). */
04706   int yycount = 0;
04707 
04708   /* There are many possibilities here to consider:
04709      - Assume YYFAIL is not used.  It's too flawed to consider.  See
04710        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
04711        for details.  YYERROR is fine as it does not invoke this
04712        function.
04713      - If this state is a consistent state with a default action, then
04714        the only way this function was invoked is if the default action
04715        is an error action.  In that case, don't check for expected
04716        tokens because there are none.
04717      - The only way there can be no lookahead present (in yychar) is if
04718        this state is a consistent state with a default action.  Thus,
04719        detecting the absence of a lookahead is sufficient to determine
04720        that there is no unexpected or expected token to report.  In that
04721        case, just report a simple "syntax error".
04722      - Don't assume there isn't a lookahead just because this state is a
04723        consistent state with a default action.  There might have been a
04724        previous inconsistent state, consistent state with a non-default
04725        action, or user semantic action that manipulated yychar.
04726      - Of course, the expected token list depends on states to have
04727        correct lookahead information, and it depends on the parser not
04728        to perform extra reductions after fetching a lookahead from the
04729        scanner and before detecting a syntax error.  Thus, state merging
04730        (from LALR or IELR) and default reductions corrupt the expected
04731        token list.  However, the list is correct for canonical LR with
04732        one exception: it will still contain any token that will not be
04733        accepted due to an error action in a later state.
04734   */
04735   if (yytoken != YYEMPTY)
04736     {
04737       int yyn = yypact[*yyssp];
04738       yyarg[yycount++] = yytname[yytoken];
04739       if (!yypact_value_is_default (yyn))
04740         {
04741           /* Start YYX at -YYN if negative to avoid negative indexes in
04742              YYCHECK.  In other words, skip the first -YYN actions for
04743              this state because they are default actions.  */
04744           int yyxbegin = yyn < 0 ? -yyn : 0;
04745           /* Stay within bounds of both yycheck and yytname.  */
04746           int yychecklim = YYLAST - yyn + 1;
04747           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04748           int yyx;
04749 
04750           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04751             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
04752                 && !yytable_value_is_error (yytable[yyx + yyn]))
04753               {
04754                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04755                   {
04756                     yycount = 1;
04757                     yysize = yysize0;
04758                     break;
04759                   }
04760                 yyarg[yycount++] = yytname[yyx];
04761                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04762                 if (! (yysize <= yysize1
04763                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04764                   return 2;
04765                 yysize = yysize1;
04766               }
04767         }
04768     }
04769 
04770   switch (yycount)
04771     {
04772 # define YYCASE_(N, S)                      \
04773       case N:                               \
04774         yyformat = S;                       \
04775       break
04776       YYCASE_(0, YY_("syntax error"));
04777       YYCASE_(1, YY_("syntax error, unexpected %s"));
04778       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
04779       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
04780       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
04781       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
04782 # undef YYCASE_
04783     }
04784 
04785   yysize1 = yysize + yystrlen (yyformat);
04786   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04787     return 2;
04788   yysize = yysize1;
04789 
04790   if (*yymsg_alloc < yysize)
04791     {
04792       *yymsg_alloc = 2 * yysize;
04793       if (! (yysize <= *yymsg_alloc
04794              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
04795         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
04796       return 1;
04797     }
04798 
04799   /* Avoid sprintf, as that infringes on the user's name space.
04800      Don't have undefined behavior even if the translation
04801      produced a string with the wrong number of "%s"s.  */
04802   {
04803     char *yyp = *yymsg;
04804     int yyi = 0;
04805     while ((*yyp = *yyformat) != '\0')
04806       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
04807         {
04808           yyp += yytnamerr (yyp, yyarg[yyi++]);
04809           yyformat += 2;
04810         }
04811       else
04812         {
04813           yyp++;
04814           yyformat++;
04815         }
04816   }
04817   return 0;
04818 }
04819 #endif /* YYERROR_VERBOSE */
04820 
04821 /*-----------------------------------------------.
04822 | Release the memory associated to this symbol.  |
04823 `-----------------------------------------------*/
04824 
04825 /*ARGSUSED*/
04826 #if (defined __STDC__ || defined __C99__FUNC__ \
04827      || defined __cplusplus || defined _MSC_VER)
04828 static void
04829 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04830 #else
04831 static void
04832 yydestruct (yymsg, yytype, yyvaluep, parser)
04833     const char *yymsg;
04834     int yytype;
04835     YYSTYPE *yyvaluep;
04836     struct parser_params *parser;
04837 #endif
04838 {
04839   YYUSE (yyvaluep);
04840   YYUSE (parser);
04841 
04842   if (!yymsg)
04843     yymsg = "Deleting";
04844   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04845 
04846   switch (yytype)
04847     {
04848 
04849       default:
04850         break;
04851     }
04852 }
04853 
04854 
04855 /* Prevent warnings from -Wmissing-prototypes.  */
04856 #ifdef YYPARSE_PARAM
04857 #if defined __STDC__ || defined __cplusplus
04858 int yyparse (void *YYPARSE_PARAM);
04859 #else
04860 int yyparse ();
04861 #endif
04862 #else /* ! YYPARSE_PARAM */
04863 #if defined __STDC__ || defined __cplusplus
04864 int yyparse (struct parser_params *parser);
04865 #else
04866 int yyparse ();
04867 #endif
04868 #endif /* ! YYPARSE_PARAM */
04869 
04870 
04871 /*----------.
04872 | yyparse.  |
04873 `----------*/
04874 
04875 #ifdef YYPARSE_PARAM
04876 #if (defined __STDC__ || defined __C99__FUNC__ \
04877      || defined __cplusplus || defined _MSC_VER)
04878 int
04879 yyparse (void *YYPARSE_PARAM)
04880 #else
04881 int
04882 yyparse (YYPARSE_PARAM)
04883     void *YYPARSE_PARAM;
04884 #endif
04885 #else /* ! YYPARSE_PARAM */
04886 #if (defined __STDC__ || defined __C99__FUNC__ \
04887      || defined __cplusplus || defined _MSC_VER)
04888 int
04889 yyparse (struct parser_params *parser)
04890 #else
04891 int
04892 yyparse (parser)
04893     struct parser_params *parser;
04894 #endif
04895 #endif
04896 {
04897 /* The lookahead symbol.  */
04898 int yychar;
04899 
04900 /* The semantic value of the lookahead symbol.  */
04901 YYSTYPE yylval;
04902 
04903     /* Number of syntax errors so far.  */
04904     int yynerrs;
04905 
04906     int yystate;
04907     /* Number of tokens to shift before error messages enabled.  */
04908     int yyerrstatus;
04909 
04910     /* The stacks and their tools:
04911        `yyss': related to states.
04912        `yyvs': related to semantic values.
04913 
04914        Refer to the stacks thru separate pointers, to allow yyoverflow
04915        to reallocate them elsewhere.  */
04916 
04917     /* The state stack.  */
04918     yytype_int16 yyssa[YYINITDEPTH];
04919     yytype_int16 *yyss;
04920     yytype_int16 *yyssp;
04921 
04922     /* The semantic value stack.  */
04923     YYSTYPE yyvsa[YYINITDEPTH];
04924     YYSTYPE *yyvs;
04925     YYSTYPE *yyvsp;
04926 
04927     YYSIZE_T yystacksize;
04928 
04929   int yyn;
04930   int yyresult;
04931   /* Lookahead token as an internal (translated) token number.  */
04932   int yytoken;
04933   /* The variables used to return semantic value and location from the
04934      action routines.  */
04935   YYSTYPE yyval;
04936 
04937 #if YYERROR_VERBOSE
04938   /* Buffer for error messages, and its allocated size.  */
04939   char yymsgbuf[128];
04940   char *yymsg = yymsgbuf;
04941   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
04942 #endif
04943 
04944 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
04945 
04946   /* The number of symbols on the RHS of the reduced rule.
04947      Keep to zero when no symbol should be popped.  */
04948   int yylen = 0;
04949 
04950   yytoken = 0;
04951   yyss = yyssa;
04952   yyvs = yyvsa;
04953   yystacksize = YYINITDEPTH;
04954 
04955   YYDPRINTF ((stderr, "Starting parse\n"));
04956 
04957   yystate = 0;
04958   yyerrstatus = 0;
04959   yynerrs = 0;
04960   yychar = YYEMPTY; /* Cause a token to be read.  */
04961 
04962   /* Initialize stack pointers.
04963      Waste one element of value and location stack
04964      so that they stay on the same level as the state stack.
04965      The wasted elements are never initialized.  */
04966   yyssp = yyss;
04967   yyvsp = yyvs;
04968 
04969   goto yysetstate;
04970 
04971 /*------------------------------------------------------------.
04972 | yynewstate -- Push a new state, which is found in yystate.  |
04973 `------------------------------------------------------------*/
04974  yynewstate:
04975   /* In all cases, when you get here, the value and location stacks
04976      have just been pushed.  So pushing a state here evens the stacks.  */
04977   yyssp++;
04978 
04979  yysetstate:
04980   *yyssp = yystate;
04981 
04982   if (yyss + yystacksize - 1 <= yyssp)
04983     {
04984       /* Get the current used size of the three stacks, in elements.  */
04985       YYSIZE_T yysize = yyssp - yyss + 1;
04986 
04987 #ifdef yyoverflow
04988       {
04989         /* Give user a chance to reallocate the stack.  Use copies of
04990            these so that the &'s don't force the real ones into
04991            memory.  */
04992         YYSTYPE *yyvs1 = yyvs;
04993         yytype_int16 *yyss1 = yyss;
04994 
04995         /* Each stack pointer address is followed by the size of the
04996            data in use in that stack, in bytes.  This used to be a
04997            conditional around just the two extra args, but that might
04998            be undefined if yyoverflow is a macro.  */
04999         yyoverflow (YY_("memory exhausted"),
05000                     &yyss1, yysize * sizeof (*yyssp),
05001                     &yyvs1, yysize * sizeof (*yyvsp),
05002                     &yystacksize);
05003 
05004         yyss = yyss1;
05005         yyvs = yyvs1;
05006       }
05007 #else /* no yyoverflow */
05008 # ifndef YYSTACK_RELOCATE
05009       goto yyexhaustedlab;
05010 # else
05011       /* Extend the stack our own way.  */
05012       if (YYMAXDEPTH <= yystacksize)
05013         goto yyexhaustedlab;
05014       yystacksize *= 2;
05015       if (YYMAXDEPTH < yystacksize)
05016         yystacksize = YYMAXDEPTH;
05017 
05018       {
05019         yytype_int16 *yyss1 = yyss;
05020         union yyalloc *yyptr =
05021           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
05022         if (! yyptr)
05023           goto yyexhaustedlab;
05024         YYSTACK_RELOCATE (yyss_alloc, yyss);
05025         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
05026 #  undef YYSTACK_RELOCATE
05027         if (yyss1 != yyssa)
05028           YYSTACK_FREE (yyss1);
05029       }
05030 # endif
05031 #endif /* no yyoverflow */
05032 
05033       yyssp = yyss + yysize - 1;
05034       yyvsp = yyvs + yysize - 1;
05035 
05036       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
05037                   (unsigned long int) yystacksize));
05038 
05039       if (yyss + yystacksize - 1 <= yyssp)
05040         YYABORT;
05041     }
05042 
05043   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
05044 
05045   if (yystate == YYFINAL)
05046     YYACCEPT;
05047 
05048   goto yybackup;
05049 
05050 /*-----------.
05051 | yybackup.  |
05052 `-----------*/
05053 yybackup:
05054 
05055   /* Do appropriate processing given the current state.  Read a
05056      lookahead token if we need one and don't already have one.  */
05057 
05058   /* First try to decide what to do without reference to lookahead token.  */
05059   yyn = yypact[yystate];
05060   if (yypact_value_is_default (yyn))
05061     goto yydefault;
05062 
05063   /* Not known => get a lookahead token if don't already have one.  */
05064 
05065   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
05066   if (yychar == YYEMPTY)
05067     {
05068       YYDPRINTF ((stderr, "Reading a token: "));
05069       yychar = YYLEX;
05070     }
05071 
05072   if (yychar <= YYEOF)
05073     {
05074       yychar = yytoken = YYEOF;
05075       YYDPRINTF ((stderr, "Now at end of input.\n"));
05076     }
05077   else
05078     {
05079       yytoken = YYTRANSLATE (yychar);
05080       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
05081     }
05082 
05083   /* If the proper action on seeing token YYTOKEN is to reduce or to
05084      detect an error, take that action.  */
05085   yyn += yytoken;
05086   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
05087     goto yydefault;
05088   yyn = yytable[yyn];
05089   if (yyn <= 0)
05090     {
05091       if (yytable_value_is_error (yyn))
05092         goto yyerrlab;
05093       yyn = -yyn;
05094       goto yyreduce;
05095     }
05096 
05097   /* Count tokens shifted since error; after three, turn off error
05098      status.  */
05099   if (yyerrstatus)
05100     yyerrstatus--;
05101 
05102   /* Shift the lookahead token.  */
05103   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
05104 
05105   /* Discard the shifted token.  */
05106   yychar = YYEMPTY;
05107 
05108   yystate = yyn;
05109   *++yyvsp = yylval;
05110 
05111   goto yynewstate;
05112 
05113 
05114 /*-----------------------------------------------------------.
05115 | yydefault -- do the default action for the current state.  |
05116 `-----------------------------------------------------------*/
05117 yydefault:
05118   yyn = yydefact[yystate];
05119   if (yyn == 0)
05120     goto yyerrlab;
05121   goto yyreduce;
05122 
05123 
05124 /*-----------------------------.
05125 | yyreduce -- Do a reduction.  |
05126 `-----------------------------*/
05127 yyreduce:
05128   /* yyn is the number of a rule to reduce with.  */
05129   yylen = yyr2[yyn];
05130 
05131   /* If YYLEN is nonzero, implement the default value of the action:
05132      `$$ = $1'.
05133 
05134      Otherwise, the following line sets YYVAL to garbage.
05135      This behavior is undocumented and Bison
05136      users should not rely upon it.  Assigning to YYVAL
05137      unconditionally makes the parser a bit smaller, and it avoids a
05138      GCC warning that YYVAL may be used uninitialized.  */
05139   yyval = yyvsp[1-yylen];
05140 
05141 
05142   YY_REDUCE_PRINT (yyn);
05143   switch (yyn)
05144     {
05145         case 2:
05146 
05147 /* Line 1806 of yacc.c  */
05148 #line 855 "ripper.y"
05149     {
05150                         lex_state = EXPR_BEG;
05151 #if 0
05152                         local_push(compile_for_eval || rb_parse_in_main());
05153 #endif
05154                         local_push(0);
05155 
05156                     }
05157     break;
05158 
05159   case 3:
05160 
05161 /* Line 1806 of yacc.c  */
05162 #line 864 "ripper.y"
05163     {
05164 #if 0
05165                         if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
05166                             /* last expression should not be void */
05167                             if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
05168                             else {
05169                                 NODE *node = (yyvsp[(2) - (2)].val);
05170                                 while (node->nd_next) {
05171                                     node = node->nd_next;
05172                                 }
05173                                 void_expr(node->nd_head);
05174                             }
05175                         }
05176                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
05177 #endif
05178                         (yyval.val) = (yyvsp[(2) - (2)].val);
05179                         parser->result = dispatch1(program, (yyval.val));
05180 
05181                         local_pop();
05182                     }
05183     break;
05184 
05185   case 4:
05186 
05187 /* Line 1806 of yacc.c  */
05188 #line 887 "ripper.y"
05189     {
05190 #if 0
05191                         void_stmts((yyvsp[(1) - (2)].val));
05192                         fixup_nodes(&deferred_nodes);
05193 #endif
05194 
05195                         (yyval.val) = (yyvsp[(1) - (2)].val);
05196                     }
05197     break;
05198 
05199   case 5:
05200 
05201 /* Line 1806 of yacc.c  */
05202 #line 898 "ripper.y"
05203     {
05204 #if 0
05205                         (yyval.val) = NEW_BEGIN(0);
05206 #endif
05207                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05208                                                   dispatch0(void_stmt));
05209 
05210                     }
05211     break;
05212 
05213   case 6:
05214 
05215 /* Line 1806 of yacc.c  */
05216 #line 907 "ripper.y"
05217     {
05218 #if 0
05219                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05220 #endif
05221                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05222 
05223                     }
05224     break;
05225 
05226   case 7:
05227 
05228 /* Line 1806 of yacc.c  */
05229 #line 915 "ripper.y"
05230     {
05231 #if 0
05232                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05233 #endif
05234                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05235 
05236                     }
05237     break;
05238 
05239   case 8:
05240 
05241 /* Line 1806 of yacc.c  */
05242 #line 923 "ripper.y"
05243     {
05244                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05245                     }
05246     break;
05247 
05248   case 10:
05249 
05250 /* Line 1806 of yacc.c  */
05251 #line 930 "ripper.y"
05252     {
05253 #if 0
05254                         /* local_push(0); */
05255 #endif
05256 
05257                     }
05258     break;
05259 
05260   case 11:
05261 
05262 /* Line 1806 of yacc.c  */
05263 #line 937 "ripper.y"
05264     {
05265 #if 0
05266                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05267                                                             (yyvsp[(4) - (5)].val));
05268                         /* NEW_PREEXE($4)); */
05269                         /* local_pop(); */
05270                         (yyval.val) = NEW_BEGIN(0);
05271 #endif
05272                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05273 
05274                     }
05275     break;
05276 
05277   case 12:
05278 
05279 /* Line 1806 of yacc.c  */
05280 #line 954 "ripper.y"
05281     {
05282 #if 0
05283                         (yyval.val) = (yyvsp[(1) - (4)].val);
05284                         if ((yyvsp[(2) - (4)].val)) {
05285                             (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05286                         }
05287                         else if ((yyvsp[(3) - (4)].val)) {
05288                             rb_warn0("else without rescue is useless");
05289                             (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
05290                         }
05291                         if ((yyvsp[(4) - (4)].val)) {
05292                             if ((yyval.val)) {
05293                                 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
05294                             }
05295                             else {
05296                                 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
05297                             }
05298                         }
05299                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05300 #endif
05301                         (yyval.val) = dispatch4(bodystmt,
05302                                        escape_Qundef((yyvsp[(1) - (4)].val)),
05303                                        escape_Qundef((yyvsp[(2) - (4)].val)),
05304                                        escape_Qundef((yyvsp[(3) - (4)].val)),
05305                                        escape_Qundef((yyvsp[(4) - (4)].val)));
05306 
05307                     }
05308     break;
05309 
05310   case 13:
05311 
05312 /* Line 1806 of yacc.c  */
05313 #line 984 "ripper.y"
05314     {
05315 #if 0
05316                         void_stmts((yyvsp[(1) - (2)].val));
05317                         fixup_nodes(&deferred_nodes);
05318 #endif
05319 
05320                         (yyval.val) = (yyvsp[(1) - (2)].val);
05321                     }
05322     break;
05323 
05324   case 14:
05325 
05326 /* Line 1806 of yacc.c  */
05327 #line 995 "ripper.y"
05328     {
05329 #if 0
05330                         (yyval.val) = NEW_BEGIN(0);
05331 #endif
05332                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05333                                                   dispatch0(void_stmt));
05334 
05335                     }
05336     break;
05337 
05338   case 15:
05339 
05340 /* Line 1806 of yacc.c  */
05341 #line 1004 "ripper.y"
05342     {
05343 #if 0
05344                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05345 #endif
05346                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05347 
05348                     }
05349     break;
05350 
05351   case 16:
05352 
05353 /* Line 1806 of yacc.c  */
05354 #line 1012 "ripper.y"
05355     {
05356 #if 0
05357                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05358 #endif
05359                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05360 
05361                     }
05362     break;
05363 
05364   case 17:
05365 
05366 /* Line 1806 of yacc.c  */
05367 #line 1020 "ripper.y"
05368     {
05369                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05370                     }
05371     break;
05372 
05373   case 18:
05374 
05375 /* Line 1806 of yacc.c  */
05376 #line 1026 "ripper.y"
05377     {
05378                         (yyval.val) = (yyvsp[(1) - (1)].val);
05379                     }
05380     break;
05381 
05382   case 19:
05383 
05384 /* Line 1806 of yacc.c  */
05385 #line 1030 "ripper.y"
05386     {
05387                         yyerror("BEGIN is permitted only at toplevel");
05388 #if 0
05389                         /* local_push(0); */
05390 #endif
05391 
05392                     }
05393     break;
05394 
05395   case 20:
05396 
05397 /* Line 1806 of yacc.c  */
05398 #line 1038 "ripper.y"
05399     {
05400 #if 0
05401                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05402                                                             (yyvsp[(4) - (5)].val));
05403                         /* NEW_PREEXE($4)); */
05404                         /* local_pop(); */
05405                         (yyval.val) = NEW_BEGIN(0);
05406 #endif
05407                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05408 
05409                     }
05410     break;
05411 
05412   case 21:
05413 
05414 /* Line 1806 of yacc.c  */
05415 #line 1050 "ripper.y"
05416     {lex_state = EXPR_FNAME;}
05417     break;
05418 
05419   case 22:
05420 
05421 /* Line 1806 of yacc.c  */
05422 #line 1051 "ripper.y"
05423     {
05424 #if 0
05425                         (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05426 #endif
05427                         (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05428 
05429                     }
05430     break;
05431 
05432   case 23:
05433 
05434 /* Line 1806 of yacc.c  */
05435 #line 1059 "ripper.y"
05436     {
05437 #if 0
05438                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05439 #endif
05440                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05441 
05442                     }
05443     break;
05444 
05445   case 24:
05446 
05447 /* Line 1806 of yacc.c  */
05448 #line 1067 "ripper.y"
05449     {
05450 #if 0
05451                         char buf[2];
05452                         buf[0] = '$';
05453                         buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
05454                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
05455 #endif
05456                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05457 
05458                     }
05459     break;
05460 
05461   case 25:
05462 
05463 /* Line 1806 of yacc.c  */
05464 #line 1078 "ripper.y"
05465     {
05466 #if 0
05467                         yyerror("can't make alias for the number variables");
05468                         (yyval.val) = NEW_BEGIN(0);
05469 #endif
05470                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05471                         (yyval.val) = dispatch1(alias_error, (yyval.val));
05472 
05473                     }
05474     break;
05475 
05476   case 26:
05477 
05478 /* Line 1806 of yacc.c  */
05479 #line 1088 "ripper.y"
05480     {
05481 #if 0
05482                         (yyval.val) = (yyvsp[(2) - (2)].val);
05483 #endif
05484                         (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
05485 
05486                     }
05487     break;
05488 
05489   case 27:
05490 
05491 /* Line 1806 of yacc.c  */
05492 #line 1096 "ripper.y"
05493     {
05494 #if 0
05495                         (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05496                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05497 #endif
05498                         (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05499 
05500                     }
05501     break;
05502 
05503   case 28:
05504 
05505 /* Line 1806 of yacc.c  */
05506 #line 1105 "ripper.y"
05507     {
05508 #if 0
05509                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05510                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05511 #endif
05512                         (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05513 
05514                     }
05515     break;
05516 
05517   case 29:
05518 
05519 /* Line 1806 of yacc.c  */
05520 #line 1114 "ripper.y"
05521     {
05522 #if 0
05523                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05524                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05525                         }
05526                         else {
05527                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05528                         }
05529 #endif
05530                         (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05531 
05532                     }
05533     break;
05534 
05535   case 30:
05536 
05537 /* Line 1806 of yacc.c  */
05538 #line 1127 "ripper.y"
05539     {
05540 #if 0
05541                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05542                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05543                         }
05544                         else {
05545                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05546                         }
05547 #endif
05548                         (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05549 
05550                     }
05551     break;
05552 
05553   case 31:
05554 
05555 /* Line 1806 of yacc.c  */
05556 #line 1140 "ripper.y"
05557     {
05558 #if 0
05559                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
05560                         (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
05561 #endif
05562                         (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05563 
05564                     }
05565     break;
05566 
05567   case 32:
05568 
05569 /* Line 1806 of yacc.c  */
05570 #line 1149 "ripper.y"
05571     {
05572                         if (in_def || in_single) {
05573                             rb_warn0("END in method; use at_exit");
05574                         }
05575 #if 0
05576                         (yyval.val) = NEW_POSTEXE(NEW_NODE(
05577                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
05578 #endif
05579                         (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
05580 
05581                     }
05582     break;
05583 
05584   case 34:
05585 
05586 /* Line 1806 of yacc.c  */
05587 #line 1162 "ripper.y"
05588     {
05589 #if 0
05590                         value_expr((yyvsp[(3) - (3)].val));
05591                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05592                         (yyval.val) = (yyvsp[(1) - (3)].val);
05593 #endif
05594                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05595 
05596                     }
05597     break;
05598 
05599   case 35:
05600 
05601 /* Line 1806 of yacc.c  */
05602 #line 1172 "ripper.y"
05603     {
05604                         value_expr((yyvsp[(3) - (3)].val));
05605                         (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05606                     }
05607     break;
05608 
05609   case 36:
05610 
05611 /* Line 1806 of yacc.c  */
05612 #line 1177 "ripper.y"
05613     {
05614 #if 0
05615                         NODE *args;
05616 
05617                         value_expr((yyvsp[(6) - (6)].val));
05618                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
05619                         args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
05620                         if ((yyvsp[(5) - (6)].val) == tOROP) {
05621                             (yyvsp[(5) - (6)].val) = 0;
05622                         }
05623                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
05624                             (yyvsp[(5) - (6)].val) = 1;
05625                         }
05626                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
05627                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
05628 #endif
05629                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
05630                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
05631 
05632                     }
05633     break;
05634 
05635   case 37:
05636 
05637 /* Line 1806 of yacc.c  */
05638 #line 1198 "ripper.y"
05639     {
05640                         value_expr((yyvsp[(5) - (5)].val));
05641                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05642                     }
05643     break;
05644 
05645   case 38:
05646 
05647 /* Line 1806 of yacc.c  */
05648 #line 1203 "ripper.y"
05649     {
05650                         value_expr((yyvsp[(5) - (5)].val));
05651                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05652                     }
05653     break;
05654 
05655   case 39:
05656 
05657 /* Line 1806 of yacc.c  */
05658 #line 1208 "ripper.y"
05659     {
05660 #if 0
05661                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05662                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05663 #endif
05664                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05665                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05666 
05667                     }
05668     break;
05669 
05670   case 40:
05671 
05672 /* Line 1806 of yacc.c  */
05673 #line 1218 "ripper.y"
05674     {
05675                         value_expr((yyvsp[(5) - (5)].val));
05676                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05677                     }
05678     break;
05679 
05680   case 41:
05681 
05682 /* Line 1806 of yacc.c  */
05683 #line 1223 "ripper.y"
05684     {
05685 #if 0
05686                         rb_backref_error((yyvsp[(1) - (3)].val));
05687                         (yyval.val) = NEW_BEGIN(0);
05688 #endif
05689                         (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
05690                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05691 
05692                     }
05693     break;
05694 
05695   case 42:
05696 
05697 /* Line 1806 of yacc.c  */
05698 #line 1233 "ripper.y"
05699     {
05700 #if 0
05701                         value_expr((yyvsp[(3) - (3)].val));
05702                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05703 #endif
05704                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05705 
05706                     }
05707     break;
05708 
05709   case 43:
05710 
05711 /* Line 1806 of yacc.c  */
05712 #line 1242 "ripper.y"
05713     {
05714 #if 0
05715                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05716                         (yyval.val) = (yyvsp[(1) - (3)].val);
05717 #endif
05718                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05719 
05720                     }
05721     break;
05722 
05723   case 44:
05724 
05725 /* Line 1806 of yacc.c  */
05726 #line 1251 "ripper.y"
05727     {
05728 #if 0
05729                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05730                         (yyval.val) = (yyvsp[(1) - (3)].val);
05731 #endif
05732                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05733 
05734                     }
05735     break;
05736 
05737   case 46:
05738 
05739 /* Line 1806 of yacc.c  */
05740 #line 1263 "ripper.y"
05741     {
05742 #if 0
05743                         value_expr((yyvsp[(3) - (3)].val));
05744                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05745 #endif
05746                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05747 
05748                     }
05749     break;
05750 
05751   case 47:
05752 
05753 /* Line 1806 of yacc.c  */
05754 #line 1272 "ripper.y"
05755     {
05756 #if 0
05757                         value_expr((yyvsp[(3) - (3)].val));
05758                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05759 #endif
05760                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05761 
05762                     }
05763     break;
05764 
05765   case 49:
05766 
05767 /* Line 1806 of yacc.c  */
05768 #line 1285 "ripper.y"
05769     {
05770 #if 0
05771                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05772 #endif
05773                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
05774 
05775                     }
05776     break;
05777 
05778   case 50:
05779 
05780 /* Line 1806 of yacc.c  */
05781 #line 1293 "ripper.y"
05782     {
05783 #if 0
05784                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05785 #endif
05786                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
05787 
05788                     }
05789     break;
05790 
05791   case 51:
05792 
05793 /* Line 1806 of yacc.c  */
05794 #line 1301 "ripper.y"
05795     {
05796 #if 0
05797                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
05798 #endif
05799                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
05800 
05801                     }
05802     break;
05803 
05804   case 52:
05805 
05806 /* Line 1806 of yacc.c  */
05807 #line 1309 "ripper.y"
05808     {
05809 #if 0
05810                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
05811 #endif
05812                         (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
05813 
05814                     }
05815     break;
05816 
05817   case 54:
05818 
05819 /* Line 1806 of yacc.c  */
05820 #line 1320 "ripper.y"
05821     {
05822 #if 0
05823                         value_expr((yyvsp[(1) - (1)].val));
05824                         (yyval.val) = (yyvsp[(1) - (1)].val);
05825                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
05826 #endif
05827                         (yyval.val) = (yyvsp[(1) - (1)].val);
05828 
05829                     }
05830     break;
05831 
05832   case 58:
05833 
05834 /* Line 1806 of yacc.c  */
05835 #line 1337 "ripper.y"
05836     {
05837 #if 0
05838                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05839 #endif
05840                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05841                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05842 
05843                     }
05844     break;
05845 
05846   case 59:
05847 
05848 /* Line 1806 of yacc.c  */
05849 #line 1348 "ripper.y"
05850     {
05851                         (yyvsp[(1) - (1)].vars) = dyna_push();
05852 #if 0
05853                         (yyval.num) = ruby_sourceline;
05854 #endif
05855 
05856                     }
05857     break;
05858 
05859   case 60:
05860 
05861 /* Line 1806 of yacc.c  */
05862 #line 1358 "ripper.y"
05863     {
05864 #if 0
05865                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
05866                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
05867 #endif
05868                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
05869 
05870                         dyna_pop((yyvsp[(1) - (5)].vars));
05871                     }
05872     break;
05873 
05874   case 61:
05875 
05876 /* Line 1806 of yacc.c  */
05877 #line 1370 "ripper.y"
05878     {
05879 #if 0
05880                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
05881                         nd_set_line((yyval.val), tokline);
05882 #endif
05883 
05884                     }
05885     break;
05886 
05887   case 62:
05888 
05889 /* Line 1806 of yacc.c  */
05890 #line 1380 "ripper.y"
05891     {
05892 #if 0
05893                         (yyval.val) = (yyvsp[(1) - (2)].val);
05894                         (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
05895 #endif
05896                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05897 
05898                     }
05899     break;
05900 
05901   case 63:
05902 
05903 /* Line 1806 of yacc.c  */
05904 #line 1389 "ripper.y"
05905     {
05906 #if 0
05907                         block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
05908                         (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
05909                         (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
05910                         (yyval.val) = (yyvsp[(3) - (3)].val);
05911                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
05912 #endif
05913                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05914                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
05915 
05916                     }
05917     break;
05918 
05919   case 64:
05920 
05921 /* Line 1806 of yacc.c  */
05922 #line 1402 "ripper.y"
05923     {
05924 #if 0
05925                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05926                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05927 #endif
05928                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05929 
05930                     }
05931     break;
05932 
05933   case 65:
05934 
05935 /* Line 1806 of yacc.c  */
05936 #line 1411 "ripper.y"
05937     {
05938 #if 0
05939                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05940                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05941                         (yyval.val) = (yyvsp[(5) - (5)].val);
05942                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05943 #endif
05944                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05945                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05946 
05947                    }
05948     break;
05949 
05950   case 66:
05951 
05952 /* Line 1806 of yacc.c  */
05953 #line 1423 "ripper.y"
05954     {
05955 #if 0
05956                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05957                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05958 #endif
05959                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05960 
05961                     }
05962     break;
05963 
05964   case 67:
05965 
05966 /* Line 1806 of yacc.c  */
05967 #line 1432 "ripper.y"
05968     {
05969 #if 0
05970                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05971                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05972                         (yyval.val) = (yyvsp[(5) - (5)].val);
05973                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05974 #endif
05975                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05976                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05977 
05978                    }
05979     break;
05980 
05981   case 68:
05982 
05983 /* Line 1806 of yacc.c  */
05984 #line 1444 "ripper.y"
05985     {
05986 #if 0
05987                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
05988                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05989 #endif
05990                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
05991 
05992                     }
05993     break;
05994 
05995   case 69:
05996 
05997 /* Line 1806 of yacc.c  */
05998 #line 1453 "ripper.y"
05999     {
06000 #if 0
06001                         (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
06002                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
06003 #endif
06004                         (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
06005 
06006                     }
06007     break;
06008 
06009   case 70:
06010 
06011 /* Line 1806 of yacc.c  */
06012 #line 1462 "ripper.y"
06013     {
06014 #if 0
06015                         (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
06016 #endif
06017                         (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
06018 
06019                     }
06020     break;
06021 
06022   case 71:
06023 
06024 /* Line 1806 of yacc.c  */
06025 #line 1470 "ripper.y"
06026     {
06027 #if 0
06028                         (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
06029 #endif
06030                         (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
06031 
06032                     }
06033     break;
06034 
06035   case 72:
06036 
06037 /* Line 1806 of yacc.c  */
06038 #line 1478 "ripper.y"
06039     {
06040 #if 0
06041                         (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
06042 #endif
06043                         (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
06044 
06045                     }
06046     break;
06047 
06048   case 74:
06049 
06050 /* Line 1806 of yacc.c  */
06051 #line 1489 "ripper.y"
06052     {
06053 #if 0
06054                         (yyval.val) = (yyvsp[(2) - (3)].val);
06055 #endif
06056                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06057 
06058                     }
06059     break;
06060 
06061   case 76:
06062 
06063 /* Line 1806 of yacc.c  */
06064 #line 1500 "ripper.y"
06065     {
06066 #if 0
06067                         (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
06068 #endif
06069                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06070 
06071                     }
06072     break;
06073 
06074   case 77:
06075 
06076 /* Line 1806 of yacc.c  */
06077 #line 1510 "ripper.y"
06078     {
06079 #if 0
06080                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
06081 #endif
06082                         (yyval.val) = (yyvsp[(1) - (1)].val);
06083 
06084                     }
06085     break;
06086 
06087   case 78:
06088 
06089 /* Line 1806 of yacc.c  */
06090 #line 1518 "ripper.y"
06091     {
06092 #if 0
06093                         (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
06094 #endif
06095                         (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
06096 
06097                     }
06098     break;
06099 
06100   case 79:
06101 
06102 /* Line 1806 of yacc.c  */
06103 #line 1526 "ripper.y"
06104     {
06105 #if 0
06106                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06107 #endif
06108                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06109 
06110                     }
06111     break;
06112 
06113   case 80:
06114 
06115 /* Line 1806 of yacc.c  */
06116 #line 1534 "ripper.y"
06117     {
06118 #if 0
06119                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
06120 #endif
06121                         (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06122                         (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
06123 
06124                     }
06125     break;
06126 
06127   case 81:
06128 
06129 /* Line 1806 of yacc.c  */
06130 #line 1543 "ripper.y"
06131     {
06132 #if 0
06133                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
06134 #endif
06135                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
06136 
06137                     }
06138     break;
06139 
06140   case 82:
06141 
06142 /* Line 1806 of yacc.c  */
06143 #line 1551 "ripper.y"
06144     {
06145 #if 0
06146                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
06147 #endif
06148                         (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
06149                         (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06150 
06151                     }
06152     break;
06153 
06154   case 83:
06155 
06156 /* Line 1806 of yacc.c  */
06157 #line 1560 "ripper.y"
06158     {
06159 #if 0
06160                         (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
06161 #endif
06162                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
06163 
06164                     }
06165     break;
06166 
06167   case 84:
06168 
06169 /* Line 1806 of yacc.c  */
06170 #line 1568 "ripper.y"
06171     {
06172 #if 0
06173                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
06174 #endif
06175                         (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
06176                         (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
06177 
06178                     }
06179     break;
06180 
06181   case 85:
06182 
06183 /* Line 1806 of yacc.c  */
06184 #line 1577 "ripper.y"
06185     {
06186 #if 0
06187                         (yyval.val) = NEW_MASGN(0, -1);
06188 #endif
06189                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06190 
06191                     }
06192     break;
06193 
06194   case 86:
06195 
06196 /* Line 1806 of yacc.c  */
06197 #line 1585 "ripper.y"
06198     {
06199 #if 0
06200                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
06201 #endif
06202                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06203                         (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
06204 
06205                     }
06206     break;
06207 
06208   case 88:
06209 
06210 /* Line 1806 of yacc.c  */
06211 #line 1597 "ripper.y"
06212     {
06213 #if 0
06214                         (yyval.val) = (yyvsp[(2) - (3)].val);
06215 #endif
06216                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06217 
06218                     }
06219     break;
06220 
06221   case 89:
06222 
06223 /* Line 1806 of yacc.c  */
06224 #line 1607 "ripper.y"
06225     {
06226 #if 0
06227                         (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
06228 #endif
06229                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
06230 
06231                     }
06232     break;
06233 
06234   case 90:
06235 
06236 /* Line 1806 of yacc.c  */
06237 #line 1615 "ripper.y"
06238     {
06239 #if 0
06240                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06241 #endif
06242                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06243 
06244                     }
06245     break;
06246 
06247   case 91:
06248 
06249 /* Line 1806 of yacc.c  */
06250 #line 1625 "ripper.y"
06251     {
06252 #if 0
06253                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
06254 #endif
06255                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
06256 
06257                     }
06258     break;
06259 
06260   case 92:
06261 
06262 /* Line 1806 of yacc.c  */
06263 #line 1633 "ripper.y"
06264     {
06265 #if 0
06266                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06267 #endif
06268                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06269 
06270                     }
06271     break;
06272 
06273   case 93:
06274 
06275 /* Line 1806 of yacc.c  */
06276 #line 1643 "ripper.y"
06277     {
06278                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06279                     }
06280     break;
06281 
06282   case 94:
06283 
06284 /* Line 1806 of yacc.c  */
06285 #line 1647 "ripper.y"
06286     {
06287                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06288                     }
06289     break;
06290 
06291   case 95:
06292 
06293 /* Line 1806 of yacc.c  */
06294 #line 1651 "ripper.y"
06295     {
06296 #if 0
06297                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06298 #endif
06299                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06300 
06301                     }
06302     break;
06303 
06304   case 96:
06305 
06306 /* Line 1806 of yacc.c  */
06307 #line 1659 "ripper.y"
06308     {
06309 #if 0
06310                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06311 #endif
06312                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06313 
06314                     }
06315     break;
06316 
06317   case 97:
06318 
06319 /* Line 1806 of yacc.c  */
06320 #line 1667 "ripper.y"
06321     {
06322 #if 0
06323                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06324 #endif
06325                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06326 
06327                     }
06328     break;
06329 
06330   case 98:
06331 
06332 /* Line 1806 of yacc.c  */
06333 #line 1675 "ripper.y"
06334     {
06335 #if 0
06336                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06337 #endif
06338                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06339 
06340                     }
06341     break;
06342 
06343   case 99:
06344 
06345 /* Line 1806 of yacc.c  */
06346 #line 1683 "ripper.y"
06347     {
06348 #if 0
06349                         if (in_def || in_single)
06350                             yyerror("dynamic constant assignment");
06351                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06352 #endif
06353                         if (in_def || in_single)
06354                             yyerror("dynamic constant assignment");
06355                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06356 
06357                     }
06358     break;
06359 
06360   case 100:
06361 
06362 /* Line 1806 of yacc.c  */
06363 #line 1695 "ripper.y"
06364     {
06365 #if 0
06366                         if (in_def || in_single)
06367                             yyerror("dynamic constant assignment");
06368                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06369 #endif
06370                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06371 
06372                     }
06373     break;
06374 
06375   case 101:
06376 
06377 /* Line 1806 of yacc.c  */
06378 #line 1705 "ripper.y"
06379     {
06380 #if 0
06381                         rb_backref_error((yyvsp[(1) - (1)].val));
06382                         (yyval.val) = NEW_BEGIN(0);
06383 #endif
06384                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
06385                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06386 
06387                     }
06388     break;
06389 
06390   case 102:
06391 
06392 /* Line 1806 of yacc.c  */
06393 #line 1717 "ripper.y"
06394     {
06395                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06396 #if 0
06397                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06398 #endif
06399                         (yyval.val) = dispatch1(var_field, (yyval.val));
06400 
06401                     }
06402     break;
06403 
06404   case 103:
06405 
06406 /* Line 1806 of yacc.c  */
06407 #line 1726 "ripper.y"
06408     {
06409                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06410 #if 0
06411                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06412 #endif
06413                         (yyval.val) = dispatch1(var_field, (yyval.val));
06414 
06415                     }
06416     break;
06417 
06418   case 104:
06419 
06420 /* Line 1806 of yacc.c  */
06421 #line 1735 "ripper.y"
06422     {
06423 #if 0
06424                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06425 #endif
06426                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06427 
06428                     }
06429     break;
06430 
06431   case 105:
06432 
06433 /* Line 1806 of yacc.c  */
06434 #line 1743 "ripper.y"
06435     {
06436 #if 0
06437                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06438 #endif
06439                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06440 
06441                     }
06442     break;
06443 
06444   case 106:
06445 
06446 /* Line 1806 of yacc.c  */
06447 #line 1751 "ripper.y"
06448     {
06449 #if 0
06450                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06451 #endif
06452                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
06453 
06454                     }
06455     break;
06456 
06457   case 107:
06458 
06459 /* Line 1806 of yacc.c  */
06460 #line 1759 "ripper.y"
06461     {
06462 #if 0
06463                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06464 #endif
06465                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06466 
06467                     }
06468     break;
06469 
06470   case 108:
06471 
06472 /* Line 1806 of yacc.c  */
06473 #line 1767 "ripper.y"
06474     {
06475 #if 0
06476                         if (in_def || in_single)
06477                             yyerror("dynamic constant assignment");
06478                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06479 #endif
06480                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06481                         if (in_def || in_single) {
06482                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06483                         }
06484 
06485                     }
06486     break;
06487 
06488   case 109:
06489 
06490 /* Line 1806 of yacc.c  */
06491 #line 1780 "ripper.y"
06492     {
06493 #if 0
06494                         if (in_def || in_single)
06495                             yyerror("dynamic constant assignment");
06496                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06497 #endif
06498                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06499                         if (in_def || in_single) {
06500                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06501                         }
06502 
06503                     }
06504     break;
06505 
06506   case 110:
06507 
06508 /* Line 1806 of yacc.c  */
06509 #line 1793 "ripper.y"
06510     {
06511 #if 0
06512                         rb_backref_error((yyvsp[(1) - (1)].val));
06513                         (yyval.val) = NEW_BEGIN(0);
06514 #endif
06515                         (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
06516 
06517                     }
06518     break;
06519 
06520   case 111:
06521 
06522 /* Line 1806 of yacc.c  */
06523 #line 1804 "ripper.y"
06524     {
06525 #if 0
06526                         yyerror("class/module name must be CONSTANT");
06527 #endif
06528                         (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
06529 
06530                     }
06531     break;
06532 
06533   case 113:
06534 
06535 /* Line 1806 of yacc.c  */
06536 #line 1815 "ripper.y"
06537     {
06538 #if 0
06539                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
06540 #endif
06541                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
06542 
06543                     }
06544     break;
06545 
06546   case 114:
06547 
06548 /* Line 1806 of yacc.c  */
06549 #line 1823 "ripper.y"
06550     {
06551 #if 0
06552                         (yyval.val) = NEW_COLON2(0, (yyval.val));
06553 #endif
06554                         (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
06555 
06556                     }
06557     break;
06558 
06559   case 115:
06560 
06561 /* Line 1806 of yacc.c  */
06562 #line 1831 "ripper.y"
06563     {
06564 #if 0
06565                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06566 #endif
06567                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06568 
06569                     }
06570     break;
06571 
06572   case 119:
06573 
06574 /* Line 1806 of yacc.c  */
06575 #line 1844 "ripper.y"
06576     {
06577                         lex_state = EXPR_ENDFN;
06578                         (yyval.val) = (yyvsp[(1) - (1)].val);
06579                     }
06580     break;
06581 
06582   case 120:
06583 
06584 /* Line 1806 of yacc.c  */
06585 #line 1849 "ripper.y"
06586     {
06587                         lex_state = EXPR_ENDFN;
06588 #if 0
06589                         (yyval.val) = (yyvsp[(1) - (1)].id);
06590 #endif
06591                         (yyval.val) = (yyvsp[(1) - (1)].val);
06592 
06593                     }
06594     break;
06595 
06596   case 123:
06597 
06598 /* Line 1806 of yacc.c  */
06599 #line 1864 "ripper.y"
06600     {
06601 #if 0
06602                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
06603 #endif
06604                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
06605 
06606                     }
06607     break;
06608 
06609   case 125:
06610 
06611 /* Line 1806 of yacc.c  */
06612 #line 1875 "ripper.y"
06613     {
06614 #if 0
06615                         (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
06616 #endif
06617                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
06618 
06619                     }
06620     break;
06621 
06622   case 126:
06623 
06624 /* Line 1806 of yacc.c  */
06625 #line 1882 "ripper.y"
06626     {lex_state = EXPR_FNAME;}
06627     break;
06628 
06629   case 127:
06630 
06631 /* Line 1806 of yacc.c  */
06632 #line 1883 "ripper.y"
06633     {
06634 #if 0
06635                         (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
06636 #endif
06637                         rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06638 
06639                     }
06640     break;
06641 
06642   case 128:
06643 
06644 /* Line 1806 of yacc.c  */
06645 #line 1892 "ripper.y"
06646     { ifndef_ripper((yyval.val) = '|'); }
06647     break;
06648 
06649   case 129:
06650 
06651 /* Line 1806 of yacc.c  */
06652 #line 1893 "ripper.y"
06653     { ifndef_ripper((yyval.val) = '^'); }
06654     break;
06655 
06656   case 130:
06657 
06658 /* Line 1806 of yacc.c  */
06659 #line 1894 "ripper.y"
06660     { ifndef_ripper((yyval.val) = '&'); }
06661     break;
06662 
06663   case 131:
06664 
06665 /* Line 1806 of yacc.c  */
06666 #line 1895 "ripper.y"
06667     { ifndef_ripper((yyval.val) = tCMP); }
06668     break;
06669 
06670   case 132:
06671 
06672 /* Line 1806 of yacc.c  */
06673 #line 1896 "ripper.y"
06674     { ifndef_ripper((yyval.val) = tEQ); }
06675     break;
06676 
06677   case 133:
06678 
06679 /* Line 1806 of yacc.c  */
06680 #line 1897 "ripper.y"
06681     { ifndef_ripper((yyval.val) = tEQQ); }
06682     break;
06683 
06684   case 134:
06685 
06686 /* Line 1806 of yacc.c  */
06687 #line 1898 "ripper.y"
06688     { ifndef_ripper((yyval.val) = tMATCH); }
06689     break;
06690 
06691   case 135:
06692 
06693 /* Line 1806 of yacc.c  */
06694 #line 1899 "ripper.y"
06695     { ifndef_ripper((yyval.val) = tNMATCH); }
06696     break;
06697 
06698   case 136:
06699 
06700 /* Line 1806 of yacc.c  */
06701 #line 1900 "ripper.y"
06702     { ifndef_ripper((yyval.val) = '>'); }
06703     break;
06704 
06705   case 137:
06706 
06707 /* Line 1806 of yacc.c  */
06708 #line 1901 "ripper.y"
06709     { ifndef_ripper((yyval.val) = tGEQ); }
06710     break;
06711 
06712   case 138:
06713 
06714 /* Line 1806 of yacc.c  */
06715 #line 1902 "ripper.y"
06716     { ifndef_ripper((yyval.val) = '<'); }
06717     break;
06718 
06719   case 139:
06720 
06721 /* Line 1806 of yacc.c  */
06722 #line 1903 "ripper.y"
06723     { ifndef_ripper((yyval.val) = tLEQ); }
06724     break;
06725 
06726   case 140:
06727 
06728 /* Line 1806 of yacc.c  */
06729 #line 1904 "ripper.y"
06730     { ifndef_ripper((yyval.val) = tNEQ); }
06731     break;
06732 
06733   case 141:
06734 
06735 /* Line 1806 of yacc.c  */
06736 #line 1905 "ripper.y"
06737     { ifndef_ripper((yyval.val) = tLSHFT); }
06738     break;
06739 
06740   case 142:
06741 
06742 /* Line 1806 of yacc.c  */
06743 #line 1906 "ripper.y"
06744     { ifndef_ripper((yyval.val) = tRSHFT); }
06745     break;
06746 
06747   case 143:
06748 
06749 /* Line 1806 of yacc.c  */
06750 #line 1907 "ripper.y"
06751     { ifndef_ripper((yyval.val) = '+'); }
06752     break;
06753 
06754   case 144:
06755 
06756 /* Line 1806 of yacc.c  */
06757 #line 1908 "ripper.y"
06758     { ifndef_ripper((yyval.val) = '-'); }
06759     break;
06760 
06761   case 145:
06762 
06763 /* Line 1806 of yacc.c  */
06764 #line 1909 "ripper.y"
06765     { ifndef_ripper((yyval.val) = '*'); }
06766     break;
06767 
06768   case 146:
06769 
06770 /* Line 1806 of yacc.c  */
06771 #line 1910 "ripper.y"
06772     { ifndef_ripper((yyval.val) = '*'); }
06773     break;
06774 
06775   case 147:
06776 
06777 /* Line 1806 of yacc.c  */
06778 #line 1911 "ripper.y"
06779     { ifndef_ripper((yyval.val) = '/'); }
06780     break;
06781 
06782   case 148:
06783 
06784 /* Line 1806 of yacc.c  */
06785 #line 1912 "ripper.y"
06786     { ifndef_ripper((yyval.val) = '%'); }
06787     break;
06788 
06789   case 149:
06790 
06791 /* Line 1806 of yacc.c  */
06792 #line 1913 "ripper.y"
06793     { ifndef_ripper((yyval.val) = tPOW); }
06794     break;
06795 
06796   case 150:
06797 
06798 /* Line 1806 of yacc.c  */
06799 #line 1914 "ripper.y"
06800     { ifndef_ripper((yyval.val) = tDSTAR); }
06801     break;
06802 
06803   case 151:
06804 
06805 /* Line 1806 of yacc.c  */
06806 #line 1915 "ripper.y"
06807     { ifndef_ripper((yyval.val) = '!'); }
06808     break;
06809 
06810   case 152:
06811 
06812 /* Line 1806 of yacc.c  */
06813 #line 1916 "ripper.y"
06814     { ifndef_ripper((yyval.val) = '~'); }
06815     break;
06816 
06817   case 153:
06818 
06819 /* Line 1806 of yacc.c  */
06820 #line 1917 "ripper.y"
06821     { ifndef_ripper((yyval.val) = tUPLUS); }
06822     break;
06823 
06824   case 154:
06825 
06826 /* Line 1806 of yacc.c  */
06827 #line 1918 "ripper.y"
06828     { ifndef_ripper((yyval.val) = tUMINUS); }
06829     break;
06830 
06831   case 155:
06832 
06833 /* Line 1806 of yacc.c  */
06834 #line 1919 "ripper.y"
06835     { ifndef_ripper((yyval.val) = tAREF); }
06836     break;
06837 
06838   case 156:
06839 
06840 /* Line 1806 of yacc.c  */
06841 #line 1920 "ripper.y"
06842     { ifndef_ripper((yyval.val) = tASET); }
06843     break;
06844 
06845   case 157:
06846 
06847 /* Line 1806 of yacc.c  */
06848 #line 1921 "ripper.y"
06849     { ifndef_ripper((yyval.val) = '`'); }
06850     break;
06851 
06852   case 199:
06853 
06854 /* Line 1806 of yacc.c  */
06855 #line 1939 "ripper.y"
06856     {
06857 #if 0
06858                         value_expr((yyvsp[(3) - (3)].val));
06859                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06860 #endif
06861                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06862 
06863                     }
06864     break;
06865 
06866   case 200:
06867 
06868 /* Line 1806 of yacc.c  */
06869 #line 1948 "ripper.y"
06870     {
06871 #if 0
06872                         value_expr((yyvsp[(3) - (5)].val));
06873                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06874                         (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06875 #endif
06876                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
06877 
06878                     }
06879     break;
06880 
06881   case 201:
06882 
06883 /* Line 1806 of yacc.c  */
06884 #line 1958 "ripper.y"
06885     {
06886                         value_expr((yyvsp[(3) - (3)].val));
06887                         (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06888                     }
06889     break;
06890 
06891   case 202:
06892 
06893 /* Line 1806 of yacc.c  */
06894 #line 1963 "ripper.y"
06895     {
06896 #if 0
06897                         value_expr((yyvsp[(3) - (5)].val));
06898                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06899 #endif
06900                         (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
06901 
06902                         (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
06903                     }
06904     break;
06905 
06906   case 203:
06907 
06908 /* Line 1806 of yacc.c  */
06909 #line 1973 "ripper.y"
06910     {
06911 #if 0
06912                         NODE *args;
06913 
06914                         value_expr((yyvsp[(6) - (6)].val));
06915                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
06916                         if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
06917                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06918                         }
06919                         else {
06920                             args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06921                         }
06922                         if ((yyvsp[(5) - (6)].val) == tOROP) {
06923                             (yyvsp[(5) - (6)].val) = 0;
06924                         }
06925                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
06926                             (yyvsp[(5) - (6)].val) = 1;
06927                         }
06928                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
06929                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
06930 #endif
06931                         (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
06932                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
06933 
06934                     }
06935     break;
06936 
06937   case 204:
06938 
06939 /* Line 1806 of yacc.c  */
06940 #line 1999 "ripper.y"
06941     {
06942                         value_expr((yyvsp[(5) - (5)].val));
06943                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06944                     }
06945     break;
06946 
06947   case 205:
06948 
06949 /* Line 1806 of yacc.c  */
06950 #line 2004 "ripper.y"
06951     {
06952                         value_expr((yyvsp[(5) - (5)].val));
06953                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06954                     }
06955     break;
06956 
06957   case 206:
06958 
06959 /* Line 1806 of yacc.c  */
06960 #line 2009 "ripper.y"
06961     {
06962                         value_expr((yyvsp[(5) - (5)].val));
06963                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06964                     }
06965     break;
06966 
06967   case 207:
06968 
06969 /* Line 1806 of yacc.c  */
06970 #line 2014 "ripper.y"
06971     {
06972 #if 0
06973                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06974                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06975 #endif
06976                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06977                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06978 
06979                     }
06980     break;
06981 
06982   case 208:
06983 
06984 /* Line 1806 of yacc.c  */
06985 #line 2024 "ripper.y"
06986     {
06987 #if 0
06988                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
06989                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06990 #endif
06991                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
06992                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06993 
06994                     }
06995     break;
06996 
06997   case 209:
06998 
06999 /* Line 1806 of yacc.c  */
07000 #line 2034 "ripper.y"
07001     {
07002 #if 0
07003                         rb_backref_error((yyvsp[(1) - (3)].val));
07004                         (yyval.val) = NEW_BEGIN(0);
07005 #endif
07006                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
07007                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
07008                         (yyval.val) = dispatch1(assign_error, (yyval.val));
07009 
07010                     }
07011     break;
07012 
07013   case 210:
07014 
07015 /* Line 1806 of yacc.c  */
07016 #line 2045 "ripper.y"
07017     {
07018 #if 0
07019                         value_expr((yyvsp[(1) - (3)].val));
07020                         value_expr((yyvsp[(3) - (3)].val));
07021                         (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07022                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
07023                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
07024                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
07025                         }
07026 #endif
07027                         (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07028 
07029                     }
07030     break;
07031 
07032   case 211:
07033 
07034 /* Line 1806 of yacc.c  */
07035 #line 2059 "ripper.y"
07036     {
07037 #if 0
07038                         value_expr((yyvsp[(1) - (3)].val));
07039                         value_expr((yyvsp[(3) - (3)].val));
07040                         (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07041                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
07042                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
07043                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
07044                         }
07045 #endif
07046                         (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07047 
07048                     }
07049     break;
07050 
07051   case 212:
07052 
07053 /* Line 1806 of yacc.c  */
07054 #line 2073 "ripper.y"
07055     {
07056 #if 0
07057                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
07058 #endif
07059                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
07060 
07061                     }
07062     break;
07063 
07064   case 213:
07065 
07066 /* Line 1806 of yacc.c  */
07067 #line 2081 "ripper.y"
07068     {
07069 #if 0
07070                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
07071 #endif
07072                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
07073 
07074                     }
07075     break;
07076 
07077   case 214:
07078 
07079 /* Line 1806 of yacc.c  */
07080 #line 2089 "ripper.y"
07081     {
07082 #if 0
07083                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
07084 #endif
07085                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
07086 
07087                     }
07088     break;
07089 
07090   case 215:
07091 
07092 /* Line 1806 of yacc.c  */
07093 #line 2097 "ripper.y"
07094     {
07095 #if 0
07096                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
07097 #endif
07098                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
07099 
07100                     }
07101     break;
07102 
07103   case 216:
07104 
07105 /* Line 1806 of yacc.c  */
07106 #line 2105 "ripper.y"
07107     {
07108 #if 0
07109                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
07110 #endif
07111                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
07112 
07113                     }
07114     break;
07115 
07116   case 217:
07117 
07118 /* Line 1806 of yacc.c  */
07119 #line 2113 "ripper.y"
07120     {
07121 #if 0
07122                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
07123 #endif
07124                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
07125 
07126                     }
07127     break;
07128 
07129   case 218:
07130 
07131 /* Line 1806 of yacc.c  */
07132 #line 2121 "ripper.y"
07133     {
07134 #if 0
07135                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
07136 #endif
07137                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
07138                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
07139 
07140                     }
07141     break;
07142 
07143   case 219:
07144 
07145 /* Line 1806 of yacc.c  */
07146 #line 2130 "ripper.y"
07147     {
07148 #if 0
07149                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
07150 #endif
07151                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
07152                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
07153 
07154                     }
07155     break;
07156 
07157   case 220:
07158 
07159 /* Line 1806 of yacc.c  */
07160 #line 2139 "ripper.y"
07161     {
07162 #if 0
07163                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
07164 #endif
07165                         (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
07166 
07167                     }
07168     break;
07169 
07170   case 221:
07171 
07172 /* Line 1806 of yacc.c  */
07173 #line 2147 "ripper.y"
07174     {
07175 #if 0
07176                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
07177 #endif
07178                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
07179 
07180                     }
07181     break;
07182 
07183   case 222:
07184 
07185 /* Line 1806 of yacc.c  */
07186 #line 2155 "ripper.y"
07187     {
07188 #if 0
07189                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
07190 #endif
07191                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
07192 
07193                     }
07194     break;
07195 
07196   case 223:
07197 
07198 /* Line 1806 of yacc.c  */
07199 #line 2163 "ripper.y"
07200     {
07201 #if 0
07202                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
07203 #endif
07204                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
07205 
07206                     }
07207     break;
07208 
07209   case 224:
07210 
07211 /* Line 1806 of yacc.c  */
07212 #line 2171 "ripper.y"
07213     {
07214 #if 0
07215                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
07216 #endif
07217                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
07218 
07219                     }
07220     break;
07221 
07222   case 225:
07223 
07224 /* Line 1806 of yacc.c  */
07225 #line 2179 "ripper.y"
07226     {
07227 #if 0
07228                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
07229 #endif
07230                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
07231 
07232                     }
07233     break;
07234 
07235   case 226:
07236 
07237 /* Line 1806 of yacc.c  */
07238 #line 2187 "ripper.y"
07239     {
07240 #if 0
07241                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
07242 #endif
07243                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
07244 
07245                     }
07246     break;
07247 
07248   case 227:
07249 
07250 /* Line 1806 of yacc.c  */
07251 #line 2195 "ripper.y"
07252     {
07253 #if 0
07254                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
07255 #endif
07256                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
07257 
07258                     }
07259     break;
07260 
07261   case 228:
07262 
07263 /* Line 1806 of yacc.c  */
07264 #line 2203 "ripper.y"
07265     {
07266 #if 0
07267                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
07268 #endif
07269                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
07270 
07271                     }
07272     break;
07273 
07274   case 229:
07275 
07276 /* Line 1806 of yacc.c  */
07277 #line 2211 "ripper.y"
07278     {
07279 #if 0
07280                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
07281 #endif
07282                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
07283 
07284                     }
07285     break;
07286 
07287   case 230:
07288 
07289 /* Line 1806 of yacc.c  */
07290 #line 2219 "ripper.y"
07291     {
07292 #if 0
07293                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
07294 #endif
07295                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
07296 
07297                     }
07298     break;
07299 
07300   case 231:
07301 
07302 /* Line 1806 of yacc.c  */
07303 #line 2227 "ripper.y"
07304     {
07305 #if 0
07306                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
07307 #endif
07308                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
07309 
07310                     }
07311     break;
07312 
07313   case 232:
07314 
07315 /* Line 1806 of yacc.c  */
07316 #line 2235 "ripper.y"
07317     {
07318 #if 0
07319                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
07320 #endif
07321                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
07322 
07323                     }
07324     break;
07325 
07326   case 233:
07327 
07328 /* Line 1806 of yacc.c  */
07329 #line 2243 "ripper.y"
07330     {
07331 #if 0
07332                         (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07333                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
07334                             (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
07335                         }
07336 #endif
07337                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
07338 
07339                     }
07340     break;
07341 
07342   case 234:
07343 
07344 /* Line 1806 of yacc.c  */
07345 #line 2254 "ripper.y"
07346     {
07347 #if 0
07348                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
07349 #endif
07350                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
07351 
07352                     }
07353     break;
07354 
07355   case 235:
07356 
07357 /* Line 1806 of yacc.c  */
07358 #line 2262 "ripper.y"
07359     {
07360 #if 0
07361                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
07362 #endif
07363                         (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
07364 
07365                     }
07366     break;
07367 
07368   case 236:
07369 
07370 /* Line 1806 of yacc.c  */
07371 #line 2270 "ripper.y"
07372     {
07373 #if 0
07374                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
07375 #endif
07376                         (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
07377 
07378                     }
07379     break;
07380 
07381   case 237:
07382 
07383 /* Line 1806 of yacc.c  */
07384 #line 2278 "ripper.y"
07385     {
07386 #if 0
07387                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
07388 #endif
07389                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
07390 
07391                     }
07392     break;
07393 
07394   case 238:
07395 
07396 /* Line 1806 of yacc.c  */
07397 #line 2286 "ripper.y"
07398     {
07399 #if 0
07400                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
07401 #endif
07402                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
07403 
07404                     }
07405     break;
07406 
07407   case 239:
07408 
07409 /* Line 1806 of yacc.c  */
07410 #line 2294 "ripper.y"
07411     {
07412 #if 0
07413                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07414 #endif
07415                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
07416 
07417                     }
07418     break;
07419 
07420   case 240:
07421 
07422 /* Line 1806 of yacc.c  */
07423 #line 2302 "ripper.y"
07424     {
07425 #if 0
07426                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07427 #endif
07428                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
07429 
07430                     }
07431     break;
07432 
07433   case 241:
07434 
07435 /* Line 1806 of yacc.c  */
07436 #line 2309 "ripper.y"
07437     {in_defined = 1;}
07438     break;
07439 
07440   case 242:
07441 
07442 /* Line 1806 of yacc.c  */
07443 #line 2310 "ripper.y"
07444     {
07445 #if 0
07446                         in_defined = 0;
07447                         (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
07448 #endif
07449                         in_defined = 0;
07450                         (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
07451 
07452                     }
07453     break;
07454 
07455   case 243:
07456 
07457 /* Line 1806 of yacc.c  */
07458 #line 2320 "ripper.y"
07459     {
07460 #if 0
07461                         value_expr((yyvsp[(1) - (6)].val));
07462                         (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07463                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07464 #endif
07465                         (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07466 
07467                     }
07468     break;
07469 
07470   case 244:
07471 
07472 /* Line 1806 of yacc.c  */
07473 #line 2330 "ripper.y"
07474     {
07475                         (yyval.val) = (yyvsp[(1) - (1)].val);
07476                     }
07477     break;
07478 
07479   case 245:
07480 
07481 /* Line 1806 of yacc.c  */
07482 #line 2336 "ripper.y"
07483     {
07484 #if 0
07485                         value_expr((yyvsp[(1) - (1)].val));
07486                         (yyval.val) = (yyvsp[(1) - (1)].val);
07487                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
07488 #endif
07489                         (yyval.val) = (yyvsp[(1) - (1)].val);
07490 
07491                     }
07492     break;
07493 
07494   case 247:
07495 
07496 /* Line 1806 of yacc.c  */
07497 #line 2349 "ripper.y"
07498     {
07499                         (yyval.val) = (yyvsp[(1) - (2)].val);
07500                     }
07501     break;
07502 
07503   case 248:
07504 
07505 /* Line 1806 of yacc.c  */
07506 #line 2353 "ripper.y"
07507     {
07508 #if 0
07509                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07510 #endif
07511                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07512 
07513                     }
07514     break;
07515 
07516   case 249:
07517 
07518 /* Line 1806 of yacc.c  */
07519 #line 2361 "ripper.y"
07520     {
07521 #if 0
07522                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07523 #endif
07524                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07525 
07526                     }
07527     break;
07528 
07529   case 250:
07530 
07531 /* Line 1806 of yacc.c  */
07532 #line 2371 "ripper.y"
07533     {
07534 #if 0
07535                         (yyval.val) = (yyvsp[(2) - (3)].val);
07536 #endif
07537                         (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
07538 
07539                     }
07540     break;
07541 
07542   case 255:
07543 
07544 /* Line 1806 of yacc.c  */
07545 #line 2387 "ripper.y"
07546     {
07547                       (yyval.val) = (yyvsp[(1) - (2)].val);
07548                     }
07549     break;
07550 
07551   case 256:
07552 
07553 /* Line 1806 of yacc.c  */
07554 #line 2391 "ripper.y"
07555     {
07556 #if 0
07557                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07558 #endif
07559                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07560 
07561                     }
07562     break;
07563 
07564   case 257:
07565 
07566 /* Line 1806 of yacc.c  */
07567 #line 2399 "ripper.y"
07568     {
07569 #if 0
07570                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07571 #endif
07572                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07573 
07574                     }
07575     break;
07576 
07577   case 258:
07578 
07579 /* Line 1806 of yacc.c  */
07580 #line 2409 "ripper.y"
07581     {
07582 #if 0
07583                         value_expr((yyvsp[(1) - (1)].val));
07584                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07585 #endif
07586                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07587 
07588                     }
07589     break;
07590 
07591   case 259:
07592 
07593 /* Line 1806 of yacc.c  */
07594 #line 2418 "ripper.y"
07595     {
07596 #if 0
07597                         (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07598 #endif
07599                         (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07600 
07601                     }
07602     break;
07603 
07604   case 260:
07605 
07606 /* Line 1806 of yacc.c  */
07607 #line 2426 "ripper.y"
07608     {
07609 #if 0
07610                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07611                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
07612 #endif
07613                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07614                         (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
07615 
07616                     }
07617     break;
07618 
07619   case 261:
07620 
07621 /* Line 1806 of yacc.c  */
07622 #line 2436 "ripper.y"
07623     {
07624 #if 0
07625                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07626                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
07627 #endif
07628                         (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
07629 
07630                     }
07631     break;
07632 
07633   case 262:
07634 
07635 /* Line 1806 of yacc.c  */
07636 #line 2447 "ripper.y"
07637     {
07638                         (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
07639                     }
07640     break;
07641 
07642   case 263:
07643 
07644 /* Line 1806 of yacc.c  */
07645 #line 2453 "ripper.y"
07646     {
07647                         (yyval.val) = cmdarg_stack;
07648                         CMDARG_PUSH(1);
07649                     }
07650     break;
07651 
07652   case 264:
07653 
07654 /* Line 1806 of yacc.c  */
07655 #line 2458 "ripper.y"
07656     {
07657                         /* CMDARG_POP() */
07658                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07659                         (yyval.val) = (yyvsp[(2) - (2)].val);
07660                     }
07661     break;
07662 
07663   case 265:
07664 
07665 /* Line 1806 of yacc.c  */
07666 #line 2466 "ripper.y"
07667     {
07668 #if 0
07669                         (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
07670 #endif
07671                         (yyval.val) = (yyvsp[(2) - (2)].val);
07672 
07673                     }
07674     break;
07675 
07676   case 266:
07677 
07678 /* Line 1806 of yacc.c  */
07679 #line 2476 "ripper.y"
07680     {
07681                         (yyval.val) = (yyvsp[(2) - (2)].val);
07682                     }
07683     break;
07684 
07685   case 267:
07686 
07687 /* Line 1806 of yacc.c  */
07688 #line 2480 "ripper.y"
07689     {
07690                         (yyval.val) = 0;
07691                     }
07692     break;
07693 
07694   case 268:
07695 
07696 /* Line 1806 of yacc.c  */
07697 #line 2486 "ripper.y"
07698     {
07699 #if 0
07700                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07701 #endif
07702                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07703 
07704                     }
07705     break;
07706 
07707   case 269:
07708 
07709 /* Line 1806 of yacc.c  */
07710 #line 2494 "ripper.y"
07711     {
07712 #if 0
07713                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07714 #endif
07715                         (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
07716 
07717                     }
07718     break;
07719 
07720   case 270:
07721 
07722 /* Line 1806 of yacc.c  */
07723 #line 2502 "ripper.y"
07724     {
07725 #if 0
07726                         NODE *n1;
07727                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07728                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07729                         }
07730                         else {
07731                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07732                         }
07733 #endif
07734                         (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07735 
07736                     }
07737     break;
07738 
07739   case 271:
07740 
07741 /* Line 1806 of yacc.c  */
07742 #line 2516 "ripper.y"
07743     {
07744 #if 0
07745                         NODE *n1;
07746                         if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07747                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07748                         }
07749                         else {
07750                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07751                         }
07752 #endif
07753                         (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07754 
07755                     }
07756     break;
07757 
07758   case 272:
07759 
07760 /* Line 1806 of yacc.c  */
07761 #line 2532 "ripper.y"
07762     {
07763 #if 0
07764                         NODE *n1;
07765                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07766                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07767                         }
07768                         else {
07769                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07770                         }
07771 #endif
07772                         (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
07773 
07774                     }
07775     break;
07776 
07777   case 273:
07778 
07779 /* Line 1806 of yacc.c  */
07780 #line 2546 "ripper.y"
07781     {
07782 #if 0
07783                         NODE *n1;
07784                         if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
07785                             (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07786                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07787                         }
07788                         else {
07789                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07790                         }
07791 #endif
07792                         (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
07793 
07794                     }
07795     break;
07796 
07797   case 274:
07798 
07799 /* Line 1806 of yacc.c  */
07800 #line 2561 "ripper.y"
07801     {
07802 #if 0
07803                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07804 #endif
07805                         (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
07806 
07807                     }
07808     break;
07809 
07810   case 285:
07811 
07812 /* Line 1806 of yacc.c  */
07813 #line 2581 "ripper.y"
07814     {
07815 #if 0
07816                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
07817 #endif
07818                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
07819 
07820                     }
07821     break;
07822 
07823   case 286:
07824 
07825 /* Line 1806 of yacc.c  */
07826 #line 2589 "ripper.y"
07827     {
07828                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07829                         cmdarg_stack = 0;
07830 #if 0
07831                         (yyval.num) = ruby_sourceline;
07832 #endif
07833 
07834                     }
07835     break;
07836 
07837   case 287:
07838 
07839 /* Line 1806 of yacc.c  */
07840 #line 2599 "ripper.y"
07841     {
07842                         cmdarg_stack = (yyvsp[(1) - (4)].val);
07843 #if 0
07844                         if ((yyvsp[(3) - (4)].val) == NULL) {
07845                             (yyval.val) = NEW_NIL();
07846                         }
07847                         else {
07848                             if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
07849                                 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
07850                                 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
07851                             (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
07852                         }
07853                         nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
07854 #endif
07855                         (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
07856 
07857                     }
07858     break;
07859 
07860   case 288:
07861 
07862 /* Line 1806 of yacc.c  */
07863 #line 2616 "ripper.y"
07864     {lex_state = EXPR_ENDARG;}
07865     break;
07866 
07867   case 289:
07868 
07869 /* Line 1806 of yacc.c  */
07870 #line 2617 "ripper.y"
07871     {
07872 #if 0
07873                         (yyval.val) = 0;
07874 #endif
07875                         (yyval.val) = dispatch1(paren, 0);
07876 
07877                     }
07878     break;
07879 
07880   case 290:
07881 
07882 /* Line 1806 of yacc.c  */
07883 #line 2625 "ripper.y"
07884     {
07885                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07886                         cmdarg_stack = 0;
07887                     }
07888     break;
07889 
07890   case 291:
07891 
07892 /* Line 1806 of yacc.c  */
07893 #line 2629 "ripper.y"
07894     {lex_state = EXPR_ENDARG;}
07895     break;
07896 
07897   case 292:
07898 
07899 /* Line 1806 of yacc.c  */
07900 #line 2630 "ripper.y"
07901     {
07902                         cmdarg_stack = (yyvsp[(1) - (5)].val);
07903 #if 0
07904                         (yyval.val) = (yyvsp[(3) - (5)].val);
07905 #endif
07906                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val));
07907 
07908                     }
07909     break;
07910 
07911   case 293:
07912 
07913 /* Line 1806 of yacc.c  */
07914 #line 2639 "ripper.y"
07915     {
07916 #if 0
07917                         (yyval.val) = (yyvsp[(2) - (3)].val);
07918 #endif
07919                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
07920 
07921                     }
07922     break;
07923 
07924   case 294:
07925 
07926 /* Line 1806 of yacc.c  */
07927 #line 2647 "ripper.y"
07928     {
07929 #if 0
07930                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07931 #endif
07932                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07933 
07934                     }
07935     break;
07936 
07937   case 295:
07938 
07939 /* Line 1806 of yacc.c  */
07940 #line 2655 "ripper.y"
07941     {
07942 #if 0
07943                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
07944 #endif
07945                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
07946 
07947                     }
07948     break;
07949 
07950   case 296:
07951 
07952 /* Line 1806 of yacc.c  */
07953 #line 2663 "ripper.y"
07954     {
07955 #if 0
07956                         if ((yyvsp[(2) - (3)].val) == 0) {
07957                             (yyval.val) = NEW_ZARRAY(); /* zero length array*/
07958                         }
07959                         else {
07960                             (yyval.val) = (yyvsp[(2) - (3)].val);
07961                         }
07962 #endif
07963                         (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
07964 
07965                     }
07966     break;
07967 
07968   case 297:
07969 
07970 /* Line 1806 of yacc.c  */
07971 #line 2676 "ripper.y"
07972     {
07973 #if 0
07974                         (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
07975 #endif
07976                         (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
07977 
07978                     }
07979     break;
07980 
07981   case 298:
07982 
07983 /* Line 1806 of yacc.c  */
07984 #line 2684 "ripper.y"
07985     {
07986 #if 0
07987                         (yyval.val) = NEW_RETURN(0);
07988 #endif
07989                         (yyval.val) = dispatch0(return0);
07990 
07991                     }
07992     break;
07993 
07994   case 299:
07995 
07996 /* Line 1806 of yacc.c  */
07997 #line 2692 "ripper.y"
07998     {
07999 #if 0
08000                         (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
08001 #endif
08002                         (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
08003 
08004                     }
08005     break;
08006 
08007   case 300:
08008 
08009 /* Line 1806 of yacc.c  */
08010 #line 2700 "ripper.y"
08011     {
08012 #if 0
08013                         (yyval.val) = NEW_YIELD(0);
08014 #endif
08015                         (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
08016 
08017                     }
08018     break;
08019 
08020   case 301:
08021 
08022 /* Line 1806 of yacc.c  */
08023 #line 2708 "ripper.y"
08024     {
08025 #if 0
08026                         (yyval.val) = NEW_YIELD(0);
08027 #endif
08028                         (yyval.val) = dispatch0(yield0);
08029 
08030                     }
08031     break;
08032 
08033   case 302:
08034 
08035 /* Line 1806 of yacc.c  */
08036 #line 2715 "ripper.y"
08037     {in_defined = 1;}
08038     break;
08039 
08040   case 303:
08041 
08042 /* Line 1806 of yacc.c  */
08043 #line 2716 "ripper.y"
08044     {
08045 #if 0
08046                         in_defined = 0;
08047                         (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
08048 #endif
08049                         in_defined = 0;
08050                         (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
08051 
08052                     }
08053     break;
08054 
08055   case 304:
08056 
08057 /* Line 1806 of yacc.c  */
08058 #line 2726 "ripper.y"
08059     {
08060 #if 0
08061                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
08062 #endif
08063                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
08064 
08065                     }
08066     break;
08067 
08068   case 305:
08069 
08070 /* Line 1806 of yacc.c  */
08071 #line 2734 "ripper.y"
08072     {
08073 #if 0
08074                         (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
08075 #endif
08076                         (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
08077 
08078                     }
08079     break;
08080 
08081   case 306:
08082 
08083 /* Line 1806 of yacc.c  */
08084 #line 2742 "ripper.y"
08085     {
08086 #if 0
08087                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
08088                         (yyval.val) = (yyvsp[(2) - (2)].val);
08089 #endif
08090                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
08091                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
08092 
08093                     }
08094     break;
08095 
08096   case 308:
08097 
08098 /* Line 1806 of yacc.c  */
08099 #line 2753 "ripper.y"
08100     {
08101 #if 0
08102                         block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
08103                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
08104                         (yyval.val) = (yyvsp[(2) - (2)].val);
08105 #endif
08106                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08107 
08108                     }
08109     break;
08110 
08111   case 309:
08112 
08113 /* Line 1806 of yacc.c  */
08114 #line 2763 "ripper.y"
08115     {
08116                         (yyval.val) = (yyvsp[(2) - (2)].val);
08117                     }
08118     break;
08119 
08120   case 310:
08121 
08122 /* Line 1806 of yacc.c  */
08123 #line 2770 "ripper.y"
08124     {
08125 #if 0
08126                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08127                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
08128 #endif
08129                         (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
08130 
08131                     }
08132     break;
08133 
08134   case 311:
08135 
08136 /* Line 1806 of yacc.c  */
08137 #line 2782 "ripper.y"
08138     {
08139 #if 0
08140                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08141                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
08142 #endif
08143                         (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
08144 
08145                     }
08146     break;
08147 
08148   case 312:
08149 
08150 /* Line 1806 of yacc.c  */
08151 #line 2790 "ripper.y"
08152     {COND_PUSH(1);}
08153     break;
08154 
08155   case 313:
08156 
08157 /* Line 1806 of yacc.c  */
08158 #line 2790 "ripper.y"
08159     {COND_POP();}
08160     break;
08161 
08162   case 314:
08163 
08164 /* Line 1806 of yacc.c  */
08165 #line 2793 "ripper.y"
08166     {
08167 #if 0
08168                         (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
08169                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
08170 #endif
08171                         (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
08172 
08173                     }
08174     break;
08175 
08176   case 315:
08177 
08178 /* Line 1806 of yacc.c  */
08179 #line 2801 "ripper.y"
08180     {COND_PUSH(1);}
08181     break;
08182 
08183   case 316:
08184 
08185 /* Line 1806 of yacc.c  */
08186 #line 2801 "ripper.y"
08187     {COND_POP();}
08188     break;
08189 
08190   case 317:
08191 
08192 /* Line 1806 of yacc.c  */
08193 #line 2804 "ripper.y"
08194     {
08195 #if 0
08196                         (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
08197                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
08198 #endif
08199                         (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
08200 
08201                     }
08202     break;
08203 
08204   case 318:
08205 
08206 /* Line 1806 of yacc.c  */
08207 #line 2815 "ripper.y"
08208     {
08209 #if 0
08210                         (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08211                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08212 #endif
08213                         (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08214 
08215                     }
08216     break;
08217 
08218   case 319:
08219 
08220 /* Line 1806 of yacc.c  */
08221 #line 2824 "ripper.y"
08222     {
08223 #if 0
08224                         (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
08225 #endif
08226                         (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
08227 
08228                     }
08229     break;
08230 
08231   case 320:
08232 
08233 /* Line 1806 of yacc.c  */
08234 #line 2832 "ripper.y"
08235     {COND_PUSH(1);}
08236     break;
08237 
08238   case 321:
08239 
08240 /* Line 1806 of yacc.c  */
08241 #line 2834 "ripper.y"
08242     {COND_POP();}
08243     break;
08244 
08245   case 322:
08246 
08247 /* Line 1806 of yacc.c  */
08248 #line 2837 "ripper.y"
08249     {
08250 #if 0
08251                         /*
08252                          *  for a, b, c in e
08253                          *  #=>
08254                          *  e.each{|*x| a, b, c = x
08255                          *
08256                          *  for a in e
08257                          *  #=>
08258                          *  e.each{|x| a, = x}
08259                          */
08260                         ID id = internal_id();
08261                         ID *tbl = ALLOC_N(ID, 2);
08262                         NODE *m = NEW_ARGS_AUX(0, 0);
08263                         NODE *args, *scope;
08264 
08265                         if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
08266                             /* if args.length == 1 && args[0].kind_of?(Array)
08267                              *   args = args[0]
08268                              * end
08269                              */
08270                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
08271                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
08272                             m->nd_next = block_append(
08273                                 NEW_IF(
08274                                     NEW_NODE(NODE_AND,
08275                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
08276                                                       idEq, one),
08277                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
08278                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
08279                                              0),
08280                                     NEW_DASGN_CURR(id,
08281                                                    NEW_CALL(NEW_DVAR(id), idAREF, zero)),
08282                                     0),
08283                                 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
08284 
08285                             args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08286                         }
08287                         else {
08288                             if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
08289                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
08290                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
08291                                 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
08292                                 m->nd_plen = 1;
08293                                 m->nd_next = (yyvsp[(2) - (9)].val);
08294                                 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
08295                             }
08296                             else {
08297                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
08298                                 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08299                             }
08300                         }
08301                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
08302                         tbl[0] = 1; tbl[1] = id;
08303                         (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
08304                         fixpos((yyval.val), (yyvsp[(2) - (9)].val));
08305 #endif
08306                         (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
08307 
08308                     }
08309     break;
08310 
08311   case 323:
08312 
08313 /* Line 1806 of yacc.c  */
08314 #line 2898 "ripper.y"
08315     {
08316                         if (in_def || in_single)
08317                             yyerror("class definition in method body");
08318                         local_push(0);
08319 #if 0
08320                         (yyval.num) = ruby_sourceline;
08321 #endif
08322 
08323                     }
08324     break;
08325 
08326   case 324:
08327 
08328 /* Line 1806 of yacc.c  */
08329 #line 2909 "ripper.y"
08330     {
08331 #if 0
08332                         (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
08333                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
08334 #endif
08335                         (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
08336 
08337                         local_pop();
08338                     }
08339     break;
08340 
08341   case 325:
08342 
08343 /* Line 1806 of yacc.c  */
08344 #line 2919 "ripper.y"
08345     {
08346                         (yyval.num) = in_def;
08347                         in_def = 0;
08348                     }
08349     break;
08350 
08351   case 326:
08352 
08353 /* Line 1806 of yacc.c  */
08354 #line 2924 "ripper.y"
08355     {
08356                         (yyval.num) = in_single;
08357                         in_single = 0;
08358                         local_push(0);
08359                     }
08360     break;
08361 
08362   case 327:
08363 
08364 /* Line 1806 of yacc.c  */
08365 #line 2931 "ripper.y"
08366     {
08367 #if 0
08368                         (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08369                         fixpos((yyval.val), (yyvsp[(3) - (8)].val));
08370 #endif
08371                         (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08372 
08373                         local_pop();
08374                         in_def = (yyvsp[(4) - (8)].num);
08375                         in_single = (yyvsp[(6) - (8)].num);
08376                     }
08377     break;
08378 
08379   case 328:
08380 
08381 /* Line 1806 of yacc.c  */
08382 #line 2943 "ripper.y"
08383     {
08384                         if (in_def || in_single)
08385                             yyerror("module definition in method body");
08386                         local_push(0);
08387 #if 0
08388                         (yyval.num) = ruby_sourceline;
08389 #endif
08390 
08391                     }
08392     break;
08393 
08394   case 329:
08395 
08396 /* Line 1806 of yacc.c  */
08397 #line 2954 "ripper.y"
08398     {
08399 #if 0
08400                         (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08401                         nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
08402 #endif
08403                         (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08404 
08405                         local_pop();
08406                     }
08407     break;
08408 
08409   case 330:
08410 
08411 /* Line 1806 of yacc.c  */
08412 #line 2964 "ripper.y"
08413     {
08414                         (yyval.id) = cur_mid;
08415                         cur_mid = (yyvsp[(2) - (2)].val);
08416                         in_def++;
08417                         local_push(0);
08418                     }
08419     break;
08420 
08421   case 331:
08422 
08423 /* Line 1806 of yacc.c  */
08424 #line 2973 "ripper.y"
08425     {
08426 #if 0
08427                         NODE *body = remove_begin((yyvsp[(5) - (6)].val));
08428                         reduce_nodes(&body);
08429                         (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
08430                         nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
08431 #endif
08432                         (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08433 
08434                         local_pop();
08435                         in_def--;
08436                         cur_mid = (yyvsp[(3) - (6)].id);
08437                     }
08438     break;
08439 
08440   case 332:
08441 
08442 /* Line 1806 of yacc.c  */
08443 #line 2986 "ripper.y"
08444     {lex_state = EXPR_FNAME;}
08445     break;
08446 
08447   case 333:
08448 
08449 /* Line 1806 of yacc.c  */
08450 #line 2987 "ripper.y"
08451     {
08452                         in_single++;
08453                         lex_state = EXPR_ENDFN; /* force for args */
08454                         local_push(0);
08455                     }
08456     break;
08457 
08458   case 334:
08459 
08460 /* Line 1806 of yacc.c  */
08461 #line 2995 "ripper.y"
08462     {
08463 #if 0
08464                         NODE *body = remove_begin((yyvsp[(8) - (9)].val));
08465                         reduce_nodes(&body);
08466                         (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
08467                         nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
08468 #endif
08469                         (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
08470 
08471                         local_pop();
08472                         in_single--;
08473                     }
08474     break;
08475 
08476   case 335:
08477 
08478 /* Line 1806 of yacc.c  */
08479 #line 3008 "ripper.y"
08480     {
08481 #if 0
08482                         (yyval.val) = NEW_BREAK(0);
08483 #endif
08484                         (yyval.val) = dispatch1(break, arg_new());
08485 
08486                     }
08487     break;
08488 
08489   case 336:
08490 
08491 /* Line 1806 of yacc.c  */
08492 #line 3016 "ripper.y"
08493     {
08494 #if 0
08495                         (yyval.val) = NEW_NEXT(0);
08496 #endif
08497                         (yyval.val) = dispatch1(next, arg_new());
08498 
08499                     }
08500     break;
08501 
08502   case 337:
08503 
08504 /* Line 1806 of yacc.c  */
08505 #line 3024 "ripper.y"
08506     {
08507 #if 0
08508                         (yyval.val) = NEW_REDO();
08509 #endif
08510                         (yyval.val) = dispatch0(redo);
08511 
08512                     }
08513     break;
08514 
08515   case 338:
08516 
08517 /* Line 1806 of yacc.c  */
08518 #line 3032 "ripper.y"
08519     {
08520 #if 0
08521                         (yyval.val) = NEW_RETRY();
08522 #endif
08523                         (yyval.val) = dispatch0(retry);
08524 
08525                     }
08526     break;
08527 
08528   case 339:
08529 
08530 /* Line 1806 of yacc.c  */
08531 #line 3042 "ripper.y"
08532     {
08533 #if 0
08534                         value_expr((yyvsp[(1) - (1)].val));
08535                         (yyval.val) = (yyvsp[(1) - (1)].val);
08536                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
08537 #endif
08538                         (yyval.val) = (yyvsp[(1) - (1)].val);
08539 
08540                     }
08541     break;
08542 
08543   case 340:
08544 
08545 /* Line 1806 of yacc.c  */
08546 #line 3054 "ripper.y"
08547     {
08548                         token_info_push("begin");
08549                     }
08550     break;
08551 
08552   case 341:
08553 
08554 /* Line 1806 of yacc.c  */
08555 #line 3060 "ripper.y"
08556     {
08557                         token_info_push("if");
08558                     }
08559     break;
08560 
08561   case 342:
08562 
08563 /* Line 1806 of yacc.c  */
08564 #line 3066 "ripper.y"
08565     {
08566                         token_info_push("unless");
08567                     }
08568     break;
08569 
08570   case 343:
08571 
08572 /* Line 1806 of yacc.c  */
08573 #line 3072 "ripper.y"
08574     {
08575                         token_info_push("while");
08576                     }
08577     break;
08578 
08579   case 344:
08580 
08581 /* Line 1806 of yacc.c  */
08582 #line 3078 "ripper.y"
08583     {
08584                         token_info_push("until");
08585                     }
08586     break;
08587 
08588   case 345:
08589 
08590 /* Line 1806 of yacc.c  */
08591 #line 3084 "ripper.y"
08592     {
08593                         token_info_push("case");
08594                     }
08595     break;
08596 
08597   case 346:
08598 
08599 /* Line 1806 of yacc.c  */
08600 #line 3090 "ripper.y"
08601     {
08602                         token_info_push("for");
08603                     }
08604     break;
08605 
08606   case 347:
08607 
08608 /* Line 1806 of yacc.c  */
08609 #line 3096 "ripper.y"
08610     {
08611                         token_info_push("class");
08612                     }
08613     break;
08614 
08615   case 348:
08616 
08617 /* Line 1806 of yacc.c  */
08618 #line 3102 "ripper.y"
08619     {
08620                         token_info_push("module");
08621                     }
08622     break;
08623 
08624   case 349:
08625 
08626 /* Line 1806 of yacc.c  */
08627 #line 3108 "ripper.y"
08628     {
08629                         token_info_push("def");
08630 #if 0
08631                         (yyval.num) = ruby_sourceline;
08632 #endif
08633 
08634                     }
08635     break;
08636 
08637   case 350:
08638 
08639 /* Line 1806 of yacc.c  */
08640 #line 3118 "ripper.y"
08641     {
08642                         token_info_pop("end");
08643                     }
08644     break;
08645 
08646   case 351:
08647 
08648 /* Line 1806 of yacc.c  */
08649 #line 3126 "ripper.y"
08650     { (yyval.val) = Qnil; }
08651     break;
08652 
08653   case 353:
08654 
08655 /* Line 1806 of yacc.c  */
08656 #line 3132 "ripper.y"
08657     { (yyval.val) = (yyvsp[(2) - (2)].val); }
08658     break;
08659 
08660   case 354:
08661 
08662 /* Line 1806 of yacc.c  */
08663 #line 3139 "ripper.y"
08664     { (yyval.val) = Qnil; }
08665     break;
08666 
08667   case 357:
08668 
08669 /* Line 1806 of yacc.c  */
08670 #line 3148 "ripper.y"
08671     {
08672 #if 0
08673                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08674                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08675 #endif
08676                         (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08677 
08678                     }
08679     break;
08680 
08681   case 359:
08682 
08683 /* Line 1806 of yacc.c  */
08684 #line 3160 "ripper.y"
08685     {
08686 #if 0
08687                         (yyval.val) = (yyvsp[(2) - (2)].val);
08688 #endif
08689                         (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
08690 
08691                     }
08692     break;
08693 
08694   case 362:
08695 
08696 /* Line 1806 of yacc.c  */
08697 #line 3174 "ripper.y"
08698     {
08699                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
08700 #if 0
08701 #endif
08702                         (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
08703 
08704                     }
08705     break;
08706 
08707   case 363:
08708 
08709 /* Line 1806 of yacc.c  */
08710 #line 3182 "ripper.y"
08711     {
08712 #if 0
08713                         (yyval.val) = (yyvsp[(2) - (3)].val);
08714 #endif
08715                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
08716 
08717                     }
08718     break;
08719 
08720   case 364:
08721 
08722 /* Line 1806 of yacc.c  */
08723 #line 3192 "ripper.y"
08724     {
08725 #if 0
08726                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
08727 #endif
08728                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
08729 
08730                     }
08731     break;
08732 
08733   case 365:
08734 
08735 /* Line 1806 of yacc.c  */
08736 #line 3200 "ripper.y"
08737     {
08738 #if 0
08739                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08740 #endif
08741                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08742 
08743                     }
08744     break;
08745 
08746   case 366:
08747 
08748 /* Line 1806 of yacc.c  */
08749 #line 3210 "ripper.y"
08750     {
08751 #if 0
08752                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
08753 #endif
08754                         (yyval.val) = (yyvsp[(1) - (1)].val);
08755 
08756                     }
08757     break;
08758 
08759   case 367:
08760 
08761 /* Line 1806 of yacc.c  */
08762 #line 3218 "ripper.y"
08763     {
08764                         (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
08765 #if 0
08766                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
08767 #endif
08768                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
08769 
08770                     }
08771     break;
08772 
08773   case 368:
08774 
08775 /* Line 1806 of yacc.c  */
08776 #line 3227 "ripper.y"
08777     {
08778                         (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
08779 #if 0
08780                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
08781 #endif
08782                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
08783 
08784                     }
08785     break;
08786 
08787   case 369:
08788 
08789 /* Line 1806 of yacc.c  */
08790 #line 3236 "ripper.y"
08791     {
08792 #if 0
08793                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
08794 #endif
08795                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
08796 
08797                     }
08798     break;
08799 
08800   case 370:
08801 
08802 /* Line 1806 of yacc.c  */
08803 #line 3244 "ripper.y"
08804     {
08805 #if 0
08806                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
08807 #endif
08808                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
08809 
08810                     }
08811     break;
08812 
08813   case 371:
08814 
08815 /* Line 1806 of yacc.c  */
08816 #line 3252 "ripper.y"
08817     {
08818                         (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
08819 #if 0
08820                         (yyval.val) = NEW_MASGN(0, (yyval.val));
08821 #endif
08822                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
08823 
08824                     }
08825     break;
08826 
08827   case 372:
08828 
08829 /* Line 1806 of yacc.c  */
08830 #line 3261 "ripper.y"
08831     {
08832                         (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
08833 #if 0
08834                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
08835 #endif
08836                       #if 0
08837                       TODO: Check me
08838                       #endif
08839                         (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
08840 
08841                     }
08842     break;
08843 
08844   case 373:
08845 
08846 /* Line 1806 of yacc.c  */
08847 #line 3273 "ripper.y"
08848     {
08849 #if 0
08850                         (yyval.val) = NEW_MASGN(0, -1);
08851 #endif
08852                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08853 
08854                     }
08855     break;
08856 
08857   case 374:
08858 
08859 /* Line 1806 of yacc.c  */
08860 #line 3281 "ripper.y"
08861     {
08862 #if 0
08863                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
08864 #endif
08865                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08866 
08867                     }
08868     break;
08869 
08870   case 375:
08871 
08872 /* Line 1806 of yacc.c  */
08873 #line 3292 "ripper.y"
08874     {
08875                         (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08876                     }
08877     break;
08878 
08879   case 376:
08880 
08881 /* Line 1806 of yacc.c  */
08882 #line 3296 "ripper.y"
08883     {
08884                         (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
08885                     }
08886     break;
08887 
08888   case 377:
08889 
08890 /* Line 1806 of yacc.c  */
08891 #line 3300 "ripper.y"
08892     {
08893                         (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08894                     }
08895     break;
08896 
08897   case 378:
08898 
08899 /* Line 1806 of yacc.c  */
08900 #line 3304 "ripper.y"
08901     {
08902                         (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
08903                     }
08904     break;
08905 
08906   case 379:
08907 
08908 /* Line 1806 of yacc.c  */
08909 #line 3310 "ripper.y"
08910     {
08911                         (yyval.val) = (yyvsp[(2) - (2)].val);
08912                     }
08913     break;
08914 
08915   case 380:
08916 
08917 /* Line 1806 of yacc.c  */
08918 #line 3314 "ripper.y"
08919     {
08920                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
08921                     }
08922     break;
08923 
08924   case 381:
08925 
08926 /* Line 1806 of yacc.c  */
08927 #line 3320 "ripper.y"
08928     {
08929                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
08930                     }
08931     break;
08932 
08933   case 382:
08934 
08935 /* Line 1806 of yacc.c  */
08936 #line 3324 "ripper.y"
08937     {
08938                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
08939                     }
08940     break;
08941 
08942   case 383:
08943 
08944 /* Line 1806 of yacc.c  */
08945 #line 3328 "ripper.y"
08946     {
08947                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
08948                     }
08949     break;
08950 
08951   case 384:
08952 
08953 /* Line 1806 of yacc.c  */
08954 #line 3332 "ripper.y"
08955     {
08956                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08957                     }
08958     break;
08959 
08960   case 385:
08961 
08962 /* Line 1806 of yacc.c  */
08963 #line 3336 "ripper.y"
08964     {
08965                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
08966                     }
08967     break;
08968 
08969   case 386:
08970 
08971 /* Line 1806 of yacc.c  */
08972 #line 3340 "ripper.y"
08973     {
08974                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
08975 #if 0
08976 #endif
08977                         dispatch1(excessed_comma, (yyval.val));
08978 
08979                     }
08980     break;
08981 
08982   case 387:
08983 
08984 /* Line 1806 of yacc.c  */
08985 #line 3348 "ripper.y"
08986     {
08987                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08988                     }
08989     break;
08990 
08991   case 388:
08992 
08993 /* Line 1806 of yacc.c  */
08994 #line 3352 "ripper.y"
08995     {
08996                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
08997                     }
08998     break;
08999 
09000   case 389:
09001 
09002 /* Line 1806 of yacc.c  */
09003 #line 3356 "ripper.y"
09004     {
09005                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
09006                     }
09007     break;
09008 
09009   case 390:
09010 
09011 /* Line 1806 of yacc.c  */
09012 #line 3360 "ripper.y"
09013     {
09014                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09015                     }
09016     break;
09017 
09018   case 391:
09019 
09020 /* Line 1806 of yacc.c  */
09021 #line 3364 "ripper.y"
09022     {
09023                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
09024                     }
09025     break;
09026 
09027   case 392:
09028 
09029 /* Line 1806 of yacc.c  */
09030 #line 3368 "ripper.y"
09031     {
09032                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09033                     }
09034     break;
09035 
09036   case 393:
09037 
09038 /* Line 1806 of yacc.c  */
09039 #line 3372 "ripper.y"
09040     {
09041                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
09042                     }
09043     break;
09044 
09045   case 394:
09046 
09047 /* Line 1806 of yacc.c  */
09048 #line 3376 "ripper.y"
09049     {
09050                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09051                     }
09052     break;
09053 
09054   case 395:
09055 
09056 /* Line 1806 of yacc.c  */
09057 #line 3380 "ripper.y"
09058     {
09059                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
09060                     }
09061     break;
09062 
09063   case 397:
09064 
09065 /* Line 1806 of yacc.c  */
09066 #line 3387 "ripper.y"
09067     {
09068                         command_start = TRUE;
09069                     }
09070     break;
09071 
09072   case 398:
09073 
09074 /* Line 1806 of yacc.c  */
09075 #line 3393 "ripper.y"
09076     {
09077 #if 0
09078                         (yyval.val) = 0;
09079 #endif
09080                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09081                                           escape_Qundef((yyvsp[(2) - (3)].val)));
09082 
09083                     }
09084     break;
09085 
09086   case 399:
09087 
09088 /* Line 1806 of yacc.c  */
09089 #line 3402 "ripper.y"
09090     {
09091 #if 0
09092                         (yyval.val) = 0;
09093 #endif
09094                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09095                                           Qnil);
09096 
09097                     }
09098     break;
09099 
09100   case 400:
09101 
09102 /* Line 1806 of yacc.c  */
09103 #line 3411 "ripper.y"
09104     {
09105 #if 0
09106                         (yyval.val) = (yyvsp[(2) - (4)].val);
09107 #endif
09108                         (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
09109 
09110                     }
09111     break;
09112 
09113   case 401:
09114 
09115 /* Line 1806 of yacc.c  */
09116 #line 3422 "ripper.y"
09117     {
09118                       (yyval.val) = 0;
09119                     }
09120     break;
09121 
09122   case 402:
09123 
09124 /* Line 1806 of yacc.c  */
09125 #line 3426 "ripper.y"
09126     {
09127 #if 0
09128                         (yyval.val) = 0;
09129 #endif
09130                         (yyval.val) = (yyvsp[(3) - (4)].val);
09131 
09132                     }
09133     break;
09134 
09135   case 403:
09136 
09137 /* Line 1806 of yacc.c  */
09138 #line 3438 "ripper.y"
09139     {
09140                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09141                     }
09142     break;
09143 
09144   case 404:
09145 
09146 /* Line 1806 of yacc.c  */
09147 #line 3445 "ripper.y"
09148     {
09149                         rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
09150                     }
09151     break;
09152 
09153   case 405:
09154 
09155 /* Line 1806 of yacc.c  */
09156 #line 3452 "ripper.y"
09157     {
09158                         new_bv(get_id((yyvsp[(1) - (1)].val)));
09159 #if 0
09160 #endif
09161                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
09162 
09163                     }
09164     break;
09165 
09166   case 406:
09167 
09168 /* Line 1806 of yacc.c  */
09169 #line 3460 "ripper.y"
09170     {
09171                         (yyval.val) = 0;
09172                     }
09173     break;
09174 
09175   case 407:
09176 
09177 /* Line 1806 of yacc.c  */
09178 #line 3465 "ripper.y"
09179     {
09180                         (yyval.vars) = dyna_push();
09181                     }
09182     break;
09183 
09184   case 408:
09185 
09186 /* Line 1806 of yacc.c  */
09187 #line 3468 "ripper.y"
09188     {
09189                         (yyval.num) = lpar_beg;
09190                         lpar_beg = ++paren_nest;
09191                     }
09192     break;
09193 
09194   case 409:
09195 
09196 /* Line 1806 of yacc.c  */
09197 #line 3473 "ripper.y"
09198     {
09199                         (yyval.num) = ruby_sourceline;
09200                     }
09201     break;
09202 
09203   case 410:
09204 
09205 /* Line 1806 of yacc.c  */
09206 #line 3477 "ripper.y"
09207     {
09208                         lpar_beg = (yyvsp[(2) - (5)].num);
09209 #if 0
09210                         (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
09211                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
09212 #endif
09213                         (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
09214 
09215                         dyna_pop((yyvsp[(1) - (5)].vars));
09216                     }
09217     break;
09218 
09219   case 411:
09220 
09221 /* Line 1806 of yacc.c  */
09222 #line 3490 "ripper.y"
09223     {
09224 #if 0
09225                         (yyval.val) = (yyvsp[(2) - (4)].val);
09226 #endif
09227                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
09228 
09229                     }
09230     break;
09231 
09232   case 412:
09233 
09234 /* Line 1806 of yacc.c  */
09235 #line 3498 "ripper.y"
09236     {
09237 #if 0
09238                         (yyval.val) = (yyvsp[(1) - (1)].val);
09239 #endif
09240                         (yyval.val) = (yyvsp[(1) - (1)].val);
09241 
09242                     }
09243     break;
09244 
09245   case 413:
09246 
09247 /* Line 1806 of yacc.c  */
09248 #line 3508 "ripper.y"
09249     {
09250                         (yyval.val) = (yyvsp[(2) - (3)].val);
09251                     }
09252     break;
09253 
09254   case 414:
09255 
09256 /* Line 1806 of yacc.c  */
09257 #line 3512 "ripper.y"
09258     {
09259                         (yyval.val) = (yyvsp[(2) - (3)].val);
09260                     }
09261     break;
09262 
09263   case 415:
09264 
09265 /* Line 1806 of yacc.c  */
09266 #line 3518 "ripper.y"
09267     {
09268                         (yyvsp[(1) - (1)].vars) = dyna_push();
09269 #if 0
09270                         (yyval.num) = ruby_sourceline;
09271 #endif
09272                     }
09273     break;
09274 
09275   case 416:
09276 
09277 /* Line 1806 of yacc.c  */
09278 #line 3527 "ripper.y"
09279     {
09280 #if 0
09281                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09282                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09283 #endif
09284                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09285 
09286                         dyna_pop((yyvsp[(1) - (5)].vars));
09287                     }
09288     break;
09289 
09290   case 417:
09291 
09292 /* Line 1806 of yacc.c  */
09293 #line 3539 "ripper.y"
09294     {
09295 #if 0
09296                         if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
09297                             compile_error(PARSER_ARG "block given to yield");
09298                         }
09299                         else {
09300                             block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
09301                         }
09302                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
09303                         (yyval.val) = (yyvsp[(2) - (2)].val);
09304                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
09305 #endif
09306                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09307 
09308                     }
09309     break;
09310 
09311   case 418:
09312 
09313 /* Line 1806 of yacc.c  */
09314 #line 3555 "ripper.y"
09315     {
09316 #if 0
09317                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09318 #endif
09319                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
09320                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09321 
09322                     }
09323     break;
09324 
09325   case 419:
09326 
09327 /* Line 1806 of yacc.c  */
09328 #line 3564 "ripper.y"
09329     {
09330 #if 0
09331                         block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09332                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09333                         (yyval.val) = (yyvsp[(5) - (5)].val);
09334                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
09335 #endif
09336                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09337                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
09338 
09339                     }
09340     break;
09341 
09342   case 420:
09343 
09344 /* Line 1806 of yacc.c  */
09345 #line 3576 "ripper.y"
09346     {
09347 #if 0
09348                         block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09349                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09350                         (yyval.val) = (yyvsp[(5) - (5)].val);
09351                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
09352 #endif
09353                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09354                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
09355 
09356                     }
09357     break;
09358 
09359   case 421:
09360 
09361 /* Line 1806 of yacc.c  */
09362 #line 3590 "ripper.y"
09363     {
09364 #if 0
09365                         (yyval.val) = (yyvsp[(1) - (2)].val);
09366                         (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
09367 #endif
09368                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
09369 
09370                     }
09371     break;
09372 
09373   case 422:
09374 
09375 /* Line 1806 of yacc.c  */
09376 #line 3599 "ripper.y"
09377     {
09378 #if 0
09379                         (yyval.num) = ruby_sourceline;
09380 #endif
09381                     }
09382     break;
09383 
09384   case 423:
09385 
09386 /* Line 1806 of yacc.c  */
09387 #line 3605 "ripper.y"
09388     {
09389 #if 0
09390                         (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
09391                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
09392 #endif
09393                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
09394                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
09395 
09396                     }
09397     break;
09398 
09399   case 424:
09400 
09401 /* Line 1806 of yacc.c  */
09402 #line 3615 "ripper.y"
09403     {
09404 #if 0
09405                         (yyval.num) = ruby_sourceline;
09406 #endif
09407                     }
09408     break;
09409 
09410   case 425:
09411 
09412 /* Line 1806 of yacc.c  */
09413 #line 3621 "ripper.y"
09414     {
09415 #if 0
09416                         (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
09417                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
09418 #endif
09419                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
09420                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
09421 
09422                     }
09423     break;
09424 
09425   case 426:
09426 
09427 /* Line 1806 of yacc.c  */
09428 #line 3631 "ripper.y"
09429     {
09430 #if 0
09431                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
09432 #endif
09433                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
09434 
09435                     }
09436     break;
09437 
09438   case 427:
09439 
09440 /* Line 1806 of yacc.c  */
09441 #line 3639 "ripper.y"
09442     {
09443 #if 0
09444                         (yyval.num) = ruby_sourceline;
09445 #endif
09446                     }
09447     break;
09448 
09449   case 428:
09450 
09451 /* Line 1806 of yacc.c  */
09452 #line 3645 "ripper.y"
09453     {
09454 #if 0
09455                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
09456                         nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
09457 #endif
09458                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
09459                                        ripper_intern("call"));
09460                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09461 
09462                     }
09463     break;
09464 
09465   case 429:
09466 
09467 /* Line 1806 of yacc.c  */
09468 #line 3656 "ripper.y"
09469     {
09470 #if 0
09471                         (yyval.num) = ruby_sourceline;
09472 #endif
09473                     }
09474     break;
09475 
09476   case 430:
09477 
09478 /* Line 1806 of yacc.c  */
09479 #line 3662 "ripper.y"
09480     {
09481 #if 0
09482                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
09483                         nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
09484 #endif
09485                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
09486                                        ripper_intern("call"));
09487                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09488 
09489                     }
09490     break;
09491 
09492   case 431:
09493 
09494 /* Line 1806 of yacc.c  */
09495 #line 3673 "ripper.y"
09496     {
09497 #if 0
09498                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
09499 #endif
09500                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
09501 
09502                     }
09503     break;
09504 
09505   case 432:
09506 
09507 /* Line 1806 of yacc.c  */
09508 #line 3681 "ripper.y"
09509     {
09510 #if 0
09511                         (yyval.val) = NEW_ZSUPER();
09512 #endif
09513                         (yyval.val) = dispatch0(zsuper);
09514 
09515                     }
09516     break;
09517 
09518   case 433:
09519 
09520 /* Line 1806 of yacc.c  */
09521 #line 3689 "ripper.y"
09522     {
09523 #if 0
09524                         if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
09525                             (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
09526                         else
09527                             (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
09528                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09529 #endif
09530                         (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
09531 
09532                     }
09533     break;
09534 
09535   case 434:
09536 
09537 /* Line 1806 of yacc.c  */
09538 #line 3703 "ripper.y"
09539     {
09540                         (yyvsp[(1) - (1)].vars) = dyna_push();
09541 #if 0
09542                         (yyval.num) = ruby_sourceline;
09543 #endif
09544 
09545                     }
09546     break;
09547 
09548   case 435:
09549 
09550 /* Line 1806 of yacc.c  */
09551 #line 3712 "ripper.y"
09552     {
09553 #if 0
09554                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09555                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09556 #endif
09557                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09558 
09559                         dyna_pop((yyvsp[(1) - (5)].vars));
09560                     }
09561     break;
09562 
09563   case 436:
09564 
09565 /* Line 1806 of yacc.c  */
09566 #line 3722 "ripper.y"
09567     {
09568                         (yyvsp[(1) - (1)].vars) = dyna_push();
09569 #if 0
09570                         (yyval.num) = ruby_sourceline;
09571 #endif
09572 
09573                     }
09574     break;
09575 
09576   case 437:
09577 
09578 /* Line 1806 of yacc.c  */
09579 #line 3731 "ripper.y"
09580     {
09581 #if 0
09582                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09583                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09584 #endif
09585                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09586 
09587                         dyna_pop((yyvsp[(1) - (5)].vars));
09588                     }
09589     break;
09590 
09591   case 438:
09592 
09593 /* Line 1806 of yacc.c  */
09594 #line 3745 "ripper.y"
09595     {
09596 #if 0
09597                         (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09598 #endif
09599                         (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
09600 
09601                     }
09602     break;
09603 
09604   case 441:
09605 
09606 /* Line 1806 of yacc.c  */
09607 #line 3761 "ripper.y"
09608     {
09609 #if 0
09610                         if ((yyvsp[(3) - (6)].val)) {
09611                             (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
09612                             (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
09613                         }
09614                         (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09615                         fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
09616 #endif
09617                         (yyval.val) = dispatch4(rescue,
09618                                        escape_Qundef((yyvsp[(2) - (6)].val)),
09619                                        escape_Qundef((yyvsp[(3) - (6)].val)),
09620                                        escape_Qundef((yyvsp[(5) - (6)].val)),
09621                                        escape_Qundef((yyvsp[(6) - (6)].val)));
09622 
09623                     }
09624     break;
09625 
09626   case 443:
09627 
09628 /* Line 1806 of yacc.c  */
09629 #line 3781 "ripper.y"
09630     {
09631 #if 0
09632                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
09633 #endif
09634                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09635 
09636                     }
09637     break;
09638 
09639   case 444:
09640 
09641 /* Line 1806 of yacc.c  */
09642 #line 3789 "ripper.y"
09643     {
09644 #if 0
09645                         if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
09646 #endif
09647                         (yyval.val) = (yyvsp[(1) - (1)].val);
09648 
09649                     }
09650     break;
09651 
09652   case 446:
09653 
09654 /* Line 1806 of yacc.c  */
09655 #line 3800 "ripper.y"
09656     {
09657                         (yyval.val) = (yyvsp[(2) - (2)].val);
09658                     }
09659     break;
09660 
09661   case 448:
09662 
09663 /* Line 1806 of yacc.c  */
09664 #line 3807 "ripper.y"
09665     {
09666 #if 0
09667                         (yyval.val) = (yyvsp[(2) - (2)].val);
09668 #endif
09669                         (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
09670 
09671                     }
09672     break;
09673 
09674   case 451:
09675 
09676 /* Line 1806 of yacc.c  */
09677 #line 3819 "ripper.y"
09678     {
09679 #if 0
09680                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
09681 #endif
09682                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
09683 
09684                     }
09685     break;
09686 
09687   case 453:
09688 
09689 /* Line 1806 of yacc.c  */
09690 #line 3830 "ripper.y"
09691     {
09692 #if 0
09693                         NODE *node = (yyvsp[(1) - (1)].val);
09694                         if (!node) {
09695                             node = NEW_STR(STR_NEW0());
09696                         }
09697                         else {
09698                             node = evstr2dstr(node);
09699                         }
09700                         (yyval.val) = node;
09701 #endif
09702                         (yyval.val) = (yyvsp[(1) - (1)].val);
09703 
09704                     }
09705     break;
09706 
09707   case 456:
09708 
09709 /* Line 1806 of yacc.c  */
09710 #line 3849 "ripper.y"
09711     {
09712 #if 0
09713                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09714 #endif
09715                         (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09716 
09717                     }
09718     break;
09719 
09720   case 457:
09721 
09722 /* Line 1806 of yacc.c  */
09723 #line 3859 "ripper.y"
09724     {
09725 #if 0
09726                         (yyval.val) = (yyvsp[(2) - (3)].val);
09727 #endif
09728                         (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
09729 
09730                     }
09731     break;
09732 
09733   case 458:
09734 
09735 /* Line 1806 of yacc.c  */
09736 #line 3869 "ripper.y"
09737     {
09738 #if 0
09739                         NODE *node = (yyvsp[(2) - (3)].val);
09740                         if (!node) {
09741                             node = NEW_XSTR(STR_NEW0());
09742                         }
09743                         else {
09744                             switch (nd_type(node)) {
09745                               case NODE_STR:
09746                                 nd_set_type(node, NODE_XSTR);
09747                                 break;
09748                               case NODE_DSTR:
09749                                 nd_set_type(node, NODE_DXSTR);
09750                                 break;
09751                               default:
09752                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09753                                 break;
09754                             }
09755                         }
09756                         (yyval.val) = node;
09757 #endif
09758                         (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
09759 
09760                     }
09761     break;
09762 
09763   case 459:
09764 
09765 /* Line 1806 of yacc.c  */
09766 #line 3896 "ripper.y"
09767     {
09768 #if 0
09769                         int options = (yyvsp[(3) - (3)].val);
09770                         NODE *node = (yyvsp[(2) - (3)].val);
09771                         NODE *list, *prev;
09772                         if (!node) {
09773                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09774                         }
09775                         else switch (nd_type(node)) {
09776                           case NODE_STR:
09777                             {
09778                                 VALUE src = node->nd_lit;
09779                                 nd_set_type(node, NODE_LIT);
09780                                 node->nd_lit = reg_compile(src, options);
09781                             }
09782                             break;
09783                           default:
09784                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09785                           case NODE_DSTR:
09786                             if (options & RE_OPTION_ONCE) {
09787                                 nd_set_type(node, NODE_DREGX_ONCE);
09788                             }
09789                             else {
09790                                 nd_set_type(node, NODE_DREGX);
09791                             }
09792                             node->nd_cflag = options & RE_OPTION_MASK;
09793                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09794                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09795                                 if (nd_type(list->nd_head) == NODE_STR) {
09796                                     VALUE tail = list->nd_head->nd_lit;
09797                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09798                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09799                                         if (!literal_concat0(parser, lit, tail)) {
09800                                             node = 0;
09801                                             break;
09802                                         }
09803                                         rb_str_resize(tail, 0);
09804                                         prev->nd_next = list->nd_next;
09805                                         rb_gc_force_recycle((VALUE)list->nd_head);
09806                                         rb_gc_force_recycle((VALUE)list);
09807                                         list = prev;
09808                                     }
09809                                     else {
09810                                         prev = list;
09811                                     }
09812                                 }
09813                                 else {
09814                                     prev = 0;
09815                                 }
09816                             }
09817                             if (!node->nd_next) {
09818                                 VALUE src = node->nd_lit;
09819                                 nd_set_type(node, NODE_LIT);
09820                                 node->nd_lit = reg_compile(src, options);
09821                             }
09822                             break;
09823                         }
09824                         (yyval.val) = node;
09825 #endif
09826                         (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
09827 
09828                     }
09829     break;
09830 
09831   case 460:
09832 
09833 /* Line 1806 of yacc.c  */
09834 #line 3961 "ripper.y"
09835     {
09836 #if 0
09837                         (yyval.val) = NEW_ZARRAY();
09838 #endif
09839                         (yyval.val) = dispatch0(words_new);
09840                         (yyval.val) = dispatch1(array, (yyval.val));
09841 
09842                     }
09843     break;
09844 
09845   case 461:
09846 
09847 /* Line 1806 of yacc.c  */
09848 #line 3970 "ripper.y"
09849     {
09850 #if 0
09851                         (yyval.val) = (yyvsp[(2) - (3)].val);
09852 #endif
09853                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09854 
09855                     }
09856     break;
09857 
09858   case 462:
09859 
09860 /* Line 1806 of yacc.c  */
09861 #line 3980 "ripper.y"
09862     {
09863 #if 0
09864                         (yyval.val) = 0;
09865 #endif
09866                         (yyval.val) = dispatch0(words_new);
09867 
09868                     }
09869     break;
09870 
09871   case 463:
09872 
09873 /* Line 1806 of yacc.c  */
09874 #line 3988 "ripper.y"
09875     {
09876 #if 0
09877                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
09878 #endif
09879                         (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09880 
09881                     }
09882     break;
09883 
09884   case 464:
09885 
09886 /* Line 1806 of yacc.c  */
09887 #line 4000 "ripper.y"
09888     {
09889                         (yyval.val) = dispatch0(word_new);
09890                         (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
09891                     }
09892     break;
09893 
09894   case 465:
09895 
09896 /* Line 1806 of yacc.c  */
09897 #line 4006 "ripper.y"
09898     {
09899 #if 0
09900                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09901 #endif
09902                         (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09903 
09904                     }
09905     break;
09906 
09907   case 466:
09908 
09909 /* Line 1806 of yacc.c  */
09910 #line 4016 "ripper.y"
09911     {
09912 #if 0
09913                         (yyval.val) = NEW_ZARRAY();
09914 #endif
09915                         (yyval.val) = dispatch0(symbols_new);
09916                         (yyval.val) = dispatch1(array, (yyval.val));
09917 
09918                     }
09919     break;
09920 
09921   case 467:
09922 
09923 /* Line 1806 of yacc.c  */
09924 #line 4025 "ripper.y"
09925     {
09926 #if 0
09927                         (yyval.val) = (yyvsp[(2) - (3)].val);
09928 #endif
09929                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09930 
09931                     }
09932     break;
09933 
09934   case 468:
09935 
09936 /* Line 1806 of yacc.c  */
09937 #line 4035 "ripper.y"
09938     {
09939 #if 0
09940                         (yyval.val) = 0;
09941 #endif
09942                         (yyval.val) = dispatch0(symbols_new);
09943 
09944                     }
09945     break;
09946 
09947   case 469:
09948 
09949 /* Line 1806 of yacc.c  */
09950 #line 4043 "ripper.y"
09951     {
09952 #if 0
09953                         (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
09954                         if (nd_type((yyvsp[(2) - (3)].val)) == NODE_DSTR) {
09955                             nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
09956                         }
09957                         else {
09958                             nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
09959                             (yyvsp[(2) - (3)].val)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].val)->nd_lit);
09960                         }
09961                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09962 #endif
09963                         (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09964 
09965                     }
09966     break;
09967 
09968   case 470:
09969 
09970 /* Line 1806 of yacc.c  */
09971 #line 4061 "ripper.y"
09972     {
09973 #if 0
09974                         (yyval.val) = NEW_ZARRAY();
09975 #endif
09976                         (yyval.val) = dispatch0(qwords_new);
09977                         (yyval.val) = dispatch1(array, (yyval.val));
09978 
09979                     }
09980     break;
09981 
09982   case 471:
09983 
09984 /* Line 1806 of yacc.c  */
09985 #line 4070 "ripper.y"
09986     {
09987 #if 0
09988                         (yyval.val) = (yyvsp[(2) - (3)].val);
09989 #endif
09990                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09991 
09992                     }
09993     break;
09994 
09995   case 472:
09996 
09997 /* Line 1806 of yacc.c  */
09998 #line 4080 "ripper.y"
09999     {
10000 #if 0
10001                         (yyval.val) = NEW_ZARRAY();
10002 #endif
10003                         (yyval.val) = dispatch0(qsymbols_new);
10004                         (yyval.val) = dispatch1(array, (yyval.val));
10005 
10006                     }
10007     break;
10008 
10009   case 473:
10010 
10011 /* Line 1806 of yacc.c  */
10012 #line 4089 "ripper.y"
10013     {
10014 #if 0
10015                         (yyval.val) = (yyvsp[(2) - (3)].val);
10016 #endif
10017                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10018 
10019                     }
10020     break;
10021 
10022   case 474:
10023 
10024 /* Line 1806 of yacc.c  */
10025 #line 4099 "ripper.y"
10026     {
10027 #if 0
10028                         (yyval.val) = 0;
10029 #endif
10030                         (yyval.val) = dispatch0(qwords_new);
10031 
10032                     }
10033     break;
10034 
10035   case 475:
10036 
10037 /* Line 1806 of yacc.c  */
10038 #line 4107 "ripper.y"
10039     {
10040 #if 0
10041                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10042 #endif
10043                         (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10044 
10045                     }
10046     break;
10047 
10048   case 476:
10049 
10050 /* Line 1806 of yacc.c  */
10051 #line 4117 "ripper.y"
10052     {
10053 #if 0
10054                         (yyval.val) = 0;
10055 #endif
10056                         (yyval.val) = dispatch0(qsymbols_new);
10057 
10058                     }
10059     break;
10060 
10061   case 477:
10062 
10063 /* Line 1806 of yacc.c  */
10064 #line 4125 "ripper.y"
10065     {
10066 #if 0
10067                         VALUE lit;
10068                         lit = (yyvsp[(2) - (3)].val)->nd_lit;
10069                         (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10070                         nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10071                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10072 #endif
10073                         (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10074 
10075                     }
10076     break;
10077 
10078   case 478:
10079 
10080 /* Line 1806 of yacc.c  */
10081 #line 4139 "ripper.y"
10082     {
10083 #if 0
10084                         (yyval.val) = 0;
10085 #endif
10086                         (yyval.val) = dispatch0(string_content);
10087 
10088                     }
10089     break;
10090 
10091   case 479:
10092 
10093 /* Line 1806 of yacc.c  */
10094 #line 4147 "ripper.y"
10095     {
10096 #if 0
10097                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10098 #endif
10099                         (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10100 
10101                     }
10102     break;
10103 
10104   case 480:
10105 
10106 /* Line 1806 of yacc.c  */
10107 #line 4157 "ripper.y"
10108     {
10109 #if 0
10110                         (yyval.val) = 0;
10111 #endif
10112                         (yyval.val) = dispatch0(xstring_new);
10113 
10114                     }
10115     break;
10116 
10117   case 481:
10118 
10119 /* Line 1806 of yacc.c  */
10120 #line 4165 "ripper.y"
10121     {
10122 #if 0
10123                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10124 #endif
10125                         (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10126 
10127                     }
10128     break;
10129 
10130   case 482:
10131 
10132 /* Line 1806 of yacc.c  */
10133 #line 4175 "ripper.y"
10134     {
10135 #if 0
10136                         (yyval.val) = 0;
10137 #endif
10138                         (yyval.val) = dispatch0(regexp_new);
10139 
10140                     }
10141     break;
10142 
10143   case 483:
10144 
10145 /* Line 1806 of yacc.c  */
10146 #line 4183 "ripper.y"
10147     {
10148 #if 0
10149                         NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10150                         if (!head) {
10151                             (yyval.val) = tail;
10152                         }
10153                         else if (!tail) {
10154                             (yyval.val) = head;
10155                         }
10156                         else {
10157                             switch (nd_type(head)) {
10158                               case NODE_STR:
10159                                 nd_set_type(head, NODE_DSTR);
10160                                 break;
10161                               case NODE_DSTR:
10162                                 break;
10163                               default:
10164                                 head = list_append(NEW_DSTR(Qnil), head);
10165                                 break;
10166                             }
10167                             (yyval.val) = list_append(head, tail);
10168                         }
10169 #endif
10170                         (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10171 
10172                     }
10173     break;
10174 
10175   case 485:
10176 
10177 /* Line 1806 of yacc.c  */
10178 #line 4213 "ripper.y"
10179     {
10180                         (yyval.node) = lex_strterm;
10181                         lex_strterm = 0;
10182                         lex_state = EXPR_BEG;
10183                     }
10184     break;
10185 
10186   case 486:
10187 
10188 /* Line 1806 of yacc.c  */
10189 #line 4219 "ripper.y"
10190     {
10191 #if 0
10192                         lex_strterm = (yyvsp[(2) - (3)].node);
10193                         (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10194 #endif
10195                         lex_strterm = (yyvsp[(2) - (3)].node);
10196                         (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10197 
10198                     }
10199     break;
10200 
10201   case 487:
10202 
10203 /* Line 1806 of yacc.c  */
10204 #line 4229 "ripper.y"
10205     {
10206                         (yyvsp[(1) - (1)].val) = cond_stack;
10207                         (yyval.val) = cmdarg_stack;
10208                         cond_stack = 0;
10209                         cmdarg_stack = 0;
10210                     }
10211     break;
10212 
10213   case 488:
10214 
10215 /* Line 1806 of yacc.c  */
10216 #line 4235 "ripper.y"
10217     {
10218                         (yyval.node) = lex_strterm;
10219                         lex_strterm = 0;
10220                         lex_state = EXPR_BEG;
10221                     }
10222     break;
10223 
10224   case 489:
10225 
10226 /* Line 1806 of yacc.c  */
10227 #line 4240 "ripper.y"
10228     {
10229                         (yyval.num) = brace_nest;
10230                         brace_nest = 0;
10231                     }
10232     break;
10233 
10234   case 490:
10235 
10236 /* Line 1806 of yacc.c  */
10237 #line 4245 "ripper.y"
10238     {
10239                         cond_stack = (yyvsp[(1) - (6)].val);
10240                         cmdarg_stack = (yyvsp[(2) - (6)].val);
10241                         lex_strterm = (yyvsp[(3) - (6)].node);
10242                         brace_nest = (yyvsp[(4) - (6)].num);
10243 #if 0
10244                         if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10245                         (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10246 #endif
10247                         (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10248 
10249                     }
10250     break;
10251 
10252   case 491:
10253 
10254 /* Line 1806 of yacc.c  */
10255 #line 4260 "ripper.y"
10256     {
10257 #if 0
10258                         (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10259 #endif
10260                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10261 
10262                     }
10263     break;
10264 
10265   case 492:
10266 
10267 /* Line 1806 of yacc.c  */
10268 #line 4268 "ripper.y"
10269     {
10270 #if 0
10271                         (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10272 #endif
10273                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10274 
10275                     }
10276     break;
10277 
10278   case 493:
10279 
10280 /* Line 1806 of yacc.c  */
10281 #line 4276 "ripper.y"
10282     {
10283 #if 0
10284                         (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10285 #endif
10286                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10287 
10288                     }
10289     break;
10290 
10291   case 495:
10292 
10293 /* Line 1806 of yacc.c  */
10294 #line 4287 "ripper.y"
10295     {
10296                         lex_state = EXPR_END;
10297 #if 0
10298                         (yyval.val) = (yyvsp[(2) - (2)].val);
10299 #endif
10300                         (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10301 
10302                     }
10303     break;
10304 
10305   case 500:
10306 
10307 /* Line 1806 of yacc.c  */
10308 #line 4304 "ripper.y"
10309     {
10310                         lex_state = EXPR_END;
10311 #if 0
10312                         (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10313 #endif
10314                         (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10315 
10316                     }
10317     break;
10318 
10319   case 503:
10320 
10321 /* Line 1806 of yacc.c  */
10322 #line 4317 "ripper.y"
10323     {
10324 #if 0
10325                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10326 #endif
10327                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10328 
10329                     }
10330     break;
10331 
10332   case 504:
10333 
10334 /* Line 1806 of yacc.c  */
10335 #line 4325 "ripper.y"
10336     {
10337 #if 0
10338                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10339 #endif
10340                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10341 
10342                     }
10343     break;
10344 
10345   case 510:
10346 
10347 /* Line 1806 of yacc.c  */
10348 #line 4341 "ripper.y"
10349     {ifndef_ripper((yyval.val) = keyword_nil);}
10350     break;
10351 
10352   case 511:
10353 
10354 /* Line 1806 of yacc.c  */
10355 #line 4342 "ripper.y"
10356     {ifndef_ripper((yyval.val) = keyword_self);}
10357     break;
10358 
10359   case 512:
10360 
10361 /* Line 1806 of yacc.c  */
10362 #line 4343 "ripper.y"
10363     {ifndef_ripper((yyval.val) = keyword_true);}
10364     break;
10365 
10366   case 513:
10367 
10368 /* Line 1806 of yacc.c  */
10369 #line 4344 "ripper.y"
10370     {ifndef_ripper((yyval.val) = keyword_false);}
10371     break;
10372 
10373   case 514:
10374 
10375 /* Line 1806 of yacc.c  */
10376 #line 4345 "ripper.y"
10377     {ifndef_ripper((yyval.val) = keyword__FILE__);}
10378     break;
10379 
10380   case 515:
10381 
10382 /* Line 1806 of yacc.c  */
10383 #line 4346 "ripper.y"
10384     {ifndef_ripper((yyval.val) = keyword__LINE__);}
10385     break;
10386 
10387   case 516:
10388 
10389 /* Line 1806 of yacc.c  */
10390 #line 4347 "ripper.y"
10391     {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10392     break;
10393 
10394   case 517:
10395 
10396 /* Line 1806 of yacc.c  */
10397 #line 4351 "ripper.y"
10398     {
10399 #if 0
10400                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10401 #endif
10402                         if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10403                             (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10404                         }
10405                         else {
10406                             (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10407                         }
10408 
10409                     }
10410     break;
10411 
10412   case 518:
10413 
10414 /* Line 1806 of yacc.c  */
10415 #line 4364 "ripper.y"
10416     {
10417 #if 0
10418                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10419 #endif
10420                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10421 
10422                     }
10423     break;
10424 
10425   case 519:
10426 
10427 /* Line 1806 of yacc.c  */
10428 #line 4374 "ripper.y"
10429     {
10430                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10431 #if 0
10432 #endif
10433                         (yyval.val) = dispatch1(var_field, (yyval.val));
10434 
10435                     }
10436     break;
10437 
10438   case 520:
10439 
10440 /* Line 1806 of yacc.c  */
10441 #line 4382 "ripper.y"
10442     {
10443                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10444 #if 0
10445 #endif
10446                         (yyval.val) = dispatch1(var_field, (yyval.val));
10447 
10448                     }
10449     break;
10450 
10451   case 523:
10452 
10453 /* Line 1806 of yacc.c  */
10454 #line 4396 "ripper.y"
10455     {
10456 #if 0
10457                         (yyval.val) = 0;
10458 #endif
10459                         (yyval.val) = Qnil;
10460 
10461                     }
10462     break;
10463 
10464   case 524:
10465 
10466 /* Line 1806 of yacc.c  */
10467 #line 4404 "ripper.y"
10468     {
10469                         lex_state = EXPR_BEG;
10470                         command_start = TRUE;
10471                     }
10472     break;
10473 
10474   case 525:
10475 
10476 /* Line 1806 of yacc.c  */
10477 #line 4409 "ripper.y"
10478     {
10479                         (yyval.val) = (yyvsp[(3) - (4)].val);
10480                     }
10481     break;
10482 
10483   case 526:
10484 
10485 /* Line 1806 of yacc.c  */
10486 #line 4413 "ripper.y"
10487     {
10488 #if 0
10489                         yyerrok;
10490                         (yyval.val) = 0;
10491 #endif
10492                         yyerrok;
10493                         (yyval.val) = Qnil;
10494 
10495                     }
10496     break;
10497 
10498   case 527:
10499 
10500 /* Line 1806 of yacc.c  */
10501 #line 4425 "ripper.y"
10502     {
10503 #if 0
10504                         (yyval.val) = (yyvsp[(2) - (3)].val);
10505 #endif
10506                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10507 
10508                         lex_state = EXPR_BEG;
10509                         command_start = TRUE;
10510                     }
10511     break;
10512 
10513   case 528:
10514 
10515 /* Line 1806 of yacc.c  */
10516 #line 4435 "ripper.y"
10517     {
10518                         (yyval.val) = (yyvsp[(1) - (2)].val);
10519                         lex_state = EXPR_BEG;
10520                         command_start = TRUE;
10521                     }
10522     break;
10523 
10524   case 529:
10525 
10526 /* Line 1806 of yacc.c  */
10527 #line 4443 "ripper.y"
10528     {
10529                         (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10530                     }
10531     break;
10532 
10533   case 530:
10534 
10535 /* Line 1806 of yacc.c  */
10536 #line 4447 "ripper.y"
10537     {
10538                         (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10539                     }
10540     break;
10541 
10542   case 531:
10543 
10544 /* Line 1806 of yacc.c  */
10545 #line 4451 "ripper.y"
10546     {
10547                         (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10548                     }
10549     break;
10550 
10551   case 532:
10552 
10553 /* Line 1806 of yacc.c  */
10554 #line 4455 "ripper.y"
10555     {
10556                         (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10557                     }
10558     break;
10559 
10560   case 533:
10561 
10562 /* Line 1806 of yacc.c  */
10563 #line 4461 "ripper.y"
10564     {
10565                         (yyval.val) = (yyvsp[(2) - (2)].val);
10566                     }
10567     break;
10568 
10569   case 534:
10570 
10571 /* Line 1806 of yacc.c  */
10572 #line 4465 "ripper.y"
10573     {
10574                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10575                     }
10576     break;
10577 
10578   case 535:
10579 
10580 /* Line 1806 of yacc.c  */
10581 #line 4471 "ripper.y"
10582     {
10583                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10584                     }
10585     break;
10586 
10587   case 536:
10588 
10589 /* Line 1806 of yacc.c  */
10590 #line 4475 "ripper.y"
10591     {
10592                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10593                     }
10594     break;
10595 
10596   case 537:
10597 
10598 /* Line 1806 of yacc.c  */
10599 #line 4479 "ripper.y"
10600     {
10601                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10602                     }
10603     break;
10604 
10605   case 538:
10606 
10607 /* Line 1806 of yacc.c  */
10608 #line 4483 "ripper.y"
10609     {
10610                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10611                     }
10612     break;
10613 
10614   case 539:
10615 
10616 /* Line 1806 of yacc.c  */
10617 #line 4487 "ripper.y"
10618     {
10619                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10620                     }
10621     break;
10622 
10623   case 540:
10624 
10625 /* Line 1806 of yacc.c  */
10626 #line 4491 "ripper.y"
10627     {
10628                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10629                     }
10630     break;
10631 
10632   case 541:
10633 
10634 /* Line 1806 of yacc.c  */
10635 #line 4495 "ripper.y"
10636     {
10637                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10638                     }
10639     break;
10640 
10641   case 542:
10642 
10643 /* Line 1806 of yacc.c  */
10644 #line 4499 "ripper.y"
10645     {
10646                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10647                     }
10648     break;
10649 
10650   case 543:
10651 
10652 /* Line 1806 of yacc.c  */
10653 #line 4503 "ripper.y"
10654     {
10655                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10656                     }
10657     break;
10658 
10659   case 544:
10660 
10661 /* Line 1806 of yacc.c  */
10662 #line 4507 "ripper.y"
10663     {
10664                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10665                     }
10666     break;
10667 
10668   case 545:
10669 
10670 /* Line 1806 of yacc.c  */
10671 #line 4511 "ripper.y"
10672     {
10673                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10674                     }
10675     break;
10676 
10677   case 546:
10678 
10679 /* Line 1806 of yacc.c  */
10680 #line 4515 "ripper.y"
10681     {
10682                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10683                     }
10684     break;
10685 
10686   case 547:
10687 
10688 /* Line 1806 of yacc.c  */
10689 #line 4519 "ripper.y"
10690     {
10691                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10692                     }
10693     break;
10694 
10695   case 548:
10696 
10697 /* Line 1806 of yacc.c  */
10698 #line 4523 "ripper.y"
10699     {
10700                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10701                     }
10702     break;
10703 
10704   case 549:
10705 
10706 /* Line 1806 of yacc.c  */
10707 #line 4527 "ripper.y"
10708     {
10709                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10710                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10711                     }
10712     break;
10713 
10714   case 550:
10715 
10716 /* Line 1806 of yacc.c  */
10717 #line 4534 "ripper.y"
10718     {
10719 #if 0
10720                         yyerror("formal argument cannot be a constant");
10721                         (yyval.val) = 0;
10722 #endif
10723                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10724 
10725                     }
10726     break;
10727 
10728   case 551:
10729 
10730 /* Line 1806 of yacc.c  */
10731 #line 4543 "ripper.y"
10732     {
10733 #if 0
10734                         yyerror("formal argument cannot be an instance variable");
10735                         (yyval.val) = 0;
10736 #endif
10737                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10738 
10739                     }
10740     break;
10741 
10742   case 552:
10743 
10744 /* Line 1806 of yacc.c  */
10745 #line 4552 "ripper.y"
10746     {
10747 #if 0
10748                         yyerror("formal argument cannot be a global variable");
10749                         (yyval.val) = 0;
10750 #endif
10751                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10752 
10753                     }
10754     break;
10755 
10756   case 553:
10757 
10758 /* Line 1806 of yacc.c  */
10759 #line 4561 "ripper.y"
10760     {
10761 #if 0
10762                         yyerror("formal argument cannot be a class variable");
10763                         (yyval.val) = 0;
10764 #endif
10765                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10766 
10767                     }
10768     break;
10769 
10770   case 555:
10771 
10772 /* Line 1806 of yacc.c  */
10773 #line 4573 "ripper.y"
10774     {
10775                         formal_argument(get_id((yyvsp[(1) - (1)].val)));
10776                         (yyval.val) = (yyvsp[(1) - (1)].val);
10777                     }
10778     break;
10779 
10780   case 556:
10781 
10782 /* Line 1806 of yacc.c  */
10783 #line 4580 "ripper.y"
10784     {
10785                         arg_var(get_id((yyvsp[(1) - (1)].val)));
10786 #if 0
10787                         (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10788 #endif
10789                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10790 
10791                     }
10792     break;
10793 
10794   case 557:
10795 
10796 /* Line 1806 of yacc.c  */
10797 #line 4589 "ripper.y"
10798     {
10799                         ID tid = internal_id();
10800                         arg_var(tid);
10801 #if 0
10802                         if (dyna_in_block()) {
10803                             (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10804                         }
10805                         else {
10806                             (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10807                         }
10808                         (yyval.val) = NEW_ARGS_AUX(tid, 1);
10809                         (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10810 #endif
10811                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10812 
10813                     }
10814     break;
10815 
10816   case 558:
10817 
10818 /* Line 1806 of yacc.c  */
10819 #line 4610 "ripper.y"
10820     {
10821                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10822                     }
10823     break;
10824 
10825   case 559:
10826 
10827 /* Line 1806 of yacc.c  */
10828 #line 4615 "ripper.y"
10829     {
10830 #if 0
10831                         (yyval.val) = (yyvsp[(1) - (3)].val);
10832                         (yyval.val)->nd_plen++;
10833                         (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10834                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10835 #endif
10836                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10837 
10838                     }
10839     break;
10840 
10841   case 560:
10842 
10843 /* Line 1806 of yacc.c  */
10844 #line 4628 "ripper.y"
10845     {
10846                         arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10847                         (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10848 #if 0
10849                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10850 #endif
10851                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10852 
10853                     }
10854     break;
10855 
10856   case 561:
10857 
10858 /* Line 1806 of yacc.c  */
10859 #line 4640 "ripper.y"
10860     {
10861                         arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10862                         (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10863 #if 0
10864                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10865 #endif
10866                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10867 
10868                     }
10869     break;
10870 
10871   case 562:
10872 
10873 /* Line 1806 of yacc.c  */
10874 #line 4652 "ripper.y"
10875     {
10876 #if 0
10877                         (yyval.val) = (yyvsp[(1) - (1)].val);
10878 #endif
10879                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10880 
10881                     }
10882     break;
10883 
10884   case 563:
10885 
10886 /* Line 1806 of yacc.c  */
10887 #line 4660 "ripper.y"
10888     {
10889 #if 0
10890                         NODE *kws = (yyvsp[(1) - (3)].val);
10891 
10892                         while (kws->nd_next) {
10893                             kws = kws->nd_next;
10894                         }
10895                         kws->nd_next = (yyvsp[(3) - (3)].val);
10896                         (yyval.val) = (yyvsp[(1) - (3)].val);
10897 #endif
10898                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10899 
10900                     }
10901     break;
10902 
10903   case 564:
10904 
10905 /* Line 1806 of yacc.c  */
10906 #line 4677 "ripper.y"
10907     {
10908 #if 0
10909                         (yyval.val) = (yyvsp[(1) - (1)].val);
10910 #endif
10911                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10912 
10913                     }
10914     break;
10915 
10916   case 565:
10917 
10918 /* Line 1806 of yacc.c  */
10919 #line 4685 "ripper.y"
10920     {
10921 #if 0
10922                         NODE *kws = (yyvsp[(1) - (3)].val);
10923 
10924                         while (kws->nd_next) {
10925                             kws = kws->nd_next;
10926                         }
10927                         kws->nd_next = (yyvsp[(3) - (3)].val);
10928                         (yyval.val) = (yyvsp[(1) - (3)].val);
10929 #endif
10930                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10931 
10932                     }
10933     break;
10934 
10935   case 568:
10936 
10937 /* Line 1806 of yacc.c  */
10938 #line 4705 "ripper.y"
10939     {
10940                         shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10941                         (yyval.val) = (yyvsp[(2) - (2)].val);
10942                     }
10943     break;
10944 
10945   case 569:
10946 
10947 /* Line 1806 of yacc.c  */
10948 #line 4710 "ripper.y"
10949     {
10950                         (yyval.val) = internal_id();
10951                     }
10952     break;
10953 
10954   case 570:
10955 
10956 /* Line 1806 of yacc.c  */
10957 #line 4716 "ripper.y"
10958     {
10959                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10960                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10961 #if 0
10962                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10963 #endif
10964                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10965 
10966                     }
10967     break;
10968 
10969   case 571:
10970 
10971 /* Line 1806 of yacc.c  */
10972 #line 4728 "ripper.y"
10973     {
10974                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10975                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10976 #if 0
10977                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10978 #endif
10979                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10980 
10981                     }
10982     break;
10983 
10984   case 572:
10985 
10986 /* Line 1806 of yacc.c  */
10987 #line 4740 "ripper.y"
10988     {
10989 #if 0
10990                         (yyval.val) = (yyvsp[(1) - (1)].val);
10991 #endif
10992                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10993 
10994                     }
10995     break;
10996 
10997   case 573:
10998 
10999 /* Line 1806 of yacc.c  */
11000 #line 4748 "ripper.y"
11001     {
11002 #if 0
11003                         NODE *opts = (yyvsp[(1) - (3)].val);
11004 
11005                         while (opts->nd_next) {
11006                             opts = opts->nd_next;
11007                         }
11008                         opts->nd_next = (yyvsp[(3) - (3)].val);
11009                         (yyval.val) = (yyvsp[(1) - (3)].val);
11010 #endif
11011                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11012 
11013                     }
11014     break;
11015 
11016   case 574:
11017 
11018 /* Line 1806 of yacc.c  */
11019 #line 4764 "ripper.y"
11020     {
11021 #if 0
11022                         (yyval.val) = (yyvsp[(1) - (1)].val);
11023 #endif
11024                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11025 
11026                     }
11027     break;
11028 
11029   case 575:
11030 
11031 /* Line 1806 of yacc.c  */
11032 #line 4772 "ripper.y"
11033     {
11034 #if 0
11035                         NODE *opts = (yyvsp[(1) - (3)].val);
11036 
11037                         while (opts->nd_next) {
11038                             opts = opts->nd_next;
11039                         }
11040                         opts->nd_next = (yyvsp[(3) - (3)].val);
11041                         (yyval.val) = (yyvsp[(1) - (3)].val);
11042 #endif
11043                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11044 
11045                     }
11046     break;
11047 
11048   case 578:
11049 
11050 /* Line 1806 of yacc.c  */
11051 #line 4792 "ripper.y"
11052     {
11053 #if 0
11054                         if (!is_local_id((yyvsp[(2) - (2)].val)))
11055                             yyerror("rest argument must be local variable");
11056 #endif
11057                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11058 #if 0
11059                         (yyval.val) = (yyvsp[(2) - (2)].val);
11060 #endif
11061                         (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11062 
11063                     }
11064     break;
11065 
11066   case 579:
11067 
11068 /* Line 1806 of yacc.c  */
11069 #line 4805 "ripper.y"
11070     {
11071 #if 0
11072                         (yyval.val) = internal_id();
11073                         arg_var((yyval.val));
11074 #endif
11075                         (yyval.val) = dispatch1(rest_param, Qnil);
11076 
11077                     }
11078     break;
11079 
11080   case 582:
11081 
11082 /* Line 1806 of yacc.c  */
11083 #line 4820 "ripper.y"
11084     {
11085 #if 0
11086                         if (!is_local_id((yyvsp[(2) - (2)].val)))
11087                             yyerror("block argument must be local variable");
11088                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11089                             yyerror("duplicated block argument name");
11090 #endif
11091                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11092 #if 0
11093                         (yyval.val) = (yyvsp[(2) - (2)].val);
11094 #endif
11095                         (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11096 
11097                     }
11098     break;
11099 
11100   case 583:
11101 
11102 /* Line 1806 of yacc.c  */
11103 #line 4837 "ripper.y"
11104     {
11105                         (yyval.val) = (yyvsp[(2) - (2)].val);
11106                     }
11107     break;
11108 
11109   case 584:
11110 
11111 /* Line 1806 of yacc.c  */
11112 #line 4841 "ripper.y"
11113     {
11114 #if 0
11115                         (yyval.val) = 0;
11116 #endif
11117                         (yyval.val) = Qundef;
11118 
11119                     }
11120     break;
11121 
11122   case 585:
11123 
11124 /* Line 1806 of yacc.c  */
11125 #line 4851 "ripper.y"
11126     {
11127 #if 0
11128                         value_expr((yyvsp[(1) - (1)].val));
11129                         (yyval.val) = (yyvsp[(1) - (1)].val);
11130                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
11131 #endif
11132                         (yyval.val) = (yyvsp[(1) - (1)].val);
11133 
11134                     }
11135     break;
11136 
11137   case 586:
11138 
11139 /* Line 1806 of yacc.c  */
11140 #line 4860 "ripper.y"
11141     {lex_state = EXPR_BEG;}
11142     break;
11143 
11144   case 587:
11145 
11146 /* Line 1806 of yacc.c  */
11147 #line 4861 "ripper.y"
11148     {
11149 #if 0
11150                         if ((yyvsp[(3) - (4)].val) == 0) {
11151                             yyerror("can't define singleton method for ().");
11152                         }
11153                         else {
11154                             switch (nd_type((yyvsp[(3) - (4)].val))) {
11155                               case NODE_STR:
11156                               case NODE_DSTR:
11157                               case NODE_XSTR:
11158                               case NODE_DXSTR:
11159                               case NODE_DREGX:
11160                               case NODE_LIT:
11161                               case NODE_ARRAY:
11162                               case NODE_ZARRAY:
11163                                 yyerror("can't define singleton method for literals");
11164                               default:
11165                                 value_expr((yyvsp[(3) - (4)].val));
11166                                 break;
11167                             }
11168                         }
11169                         (yyval.val) = (yyvsp[(3) - (4)].val);
11170 #endif
11171                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11172 
11173                     }
11174     break;
11175 
11176   case 589:
11177 
11178 /* Line 1806 of yacc.c  */
11179 #line 4891 "ripper.y"
11180     {
11181 #if 0
11182                         (yyval.val) = (yyvsp[(1) - (2)].val);
11183 #endif
11184                         (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11185 
11186                     }
11187     break;
11188 
11189   case 590:
11190 
11191 /* Line 1806 of yacc.c  */
11192 #line 4903 "ripper.y"
11193     {
11194                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11195                     }
11196     break;
11197 
11198   case 591:
11199 
11200 /* Line 1806 of yacc.c  */
11201 #line 4908 "ripper.y"
11202     {
11203 #if 0
11204                         (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11205 #endif
11206                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11207 
11208                     }
11209     break;
11210 
11211   case 592:
11212 
11213 /* Line 1806 of yacc.c  */
11214 #line 4918 "ripper.y"
11215     {
11216 #if 0
11217                         (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11218 #endif
11219                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11220 
11221                     }
11222     break;
11223 
11224   case 593:
11225 
11226 /* Line 1806 of yacc.c  */
11227 #line 4926 "ripper.y"
11228     {
11229 #if 0
11230                         (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11231 #endif
11232                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11233 
11234                     }
11235     break;
11236 
11237   case 594:
11238 
11239 /* Line 1806 of yacc.c  */
11240 #line 4934 "ripper.y"
11241     {
11242 #if 0
11243                         (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11244 #endif
11245                         (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11246 
11247                     }
11248     break;
11249 
11250   case 605:
11251 
11252 /* Line 1806 of yacc.c  */
11253 #line 4964 "ripper.y"
11254     { (yyval.val) = (yyvsp[(1) - (1)].val); }
11255     break;
11256 
11257   case 606:
11258 
11259 /* Line 1806 of yacc.c  */
11260 #line 4969 "ripper.y"
11261     { (yyval.val) = (yyvsp[(1) - (1)].val); }
11262     break;
11263 
11264   case 616:
11265 
11266 /* Line 1806 of yacc.c  */
11267 #line 4992 "ripper.y"
11268     {yyerrok;}
11269     break;
11270 
11271   case 619:
11272 
11273 /* Line 1806 of yacc.c  */
11274 #line 4997 "ripper.y"
11275     {yyerrok;}
11276     break;
11277 
11278   case 620:
11279 
11280 /* Line 1806 of yacc.c  */
11281 #line 5001 "ripper.y"
11282     {
11283 #if 0
11284                         (yyval.val) = 0;
11285 #endif
11286                         (yyval.val) = Qundef;
11287 
11288                     }
11289     break;
11290 
11291 
11292 
11293 /* Line 1806 of yacc.c  */
11294 #line 11293 "parse.c"
11295       default: break;
11296     }
11297   /* User semantic actions sometimes alter yychar, and that requires
11298      that yytoken be updated with the new translation.  We take the
11299      approach of translating immediately before every use of yytoken.
11300      One alternative is translating here after every semantic action,
11301      but that translation would be missed if the semantic action invokes
11302      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11303      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
11304      incorrect destructor might then be invoked immediately.  In the
11305      case of YYERROR or YYBACKUP, subsequent parser actions might lead
11306      to an incorrect destructor call or verbose syntax error message
11307      before the lookahead is translated.  */
11308   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11309 
11310   YYPOPSTACK (yylen);
11311   yylen = 0;
11312   YY_STACK_PRINT (yyss, yyssp);
11313 
11314   *++yyvsp = yyval;
11315 
11316   /* Now `shift' the result of the reduction.  Determine what state
11317      that goes to, based on the state we popped back to and the rule
11318      number reduced by.  */
11319 
11320   yyn = yyr1[yyn];
11321 
11322   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11323   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11324     yystate = yytable[yystate];
11325   else
11326     yystate = yydefgoto[yyn - YYNTOKENS];
11327 
11328   goto yynewstate;
11329 
11330 
11331 /*------------------------------------.
11332 | yyerrlab -- here on detecting error |
11333 `------------------------------------*/
11334 yyerrlab:
11335   /* Make sure we have latest lookahead translation.  See comments at
11336      user semantic actions for why this is necessary.  */
11337   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11338 
11339   /* If not already recovering from an error, report this error.  */
11340   if (!yyerrstatus)
11341     {
11342       ++yynerrs;
11343 #if ! YYERROR_VERBOSE
11344       parser_yyerror (parser, YY_("syntax error"));
11345 #else
11346 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11347                                         yyssp, yytoken)
11348       {
11349         char const *yymsgp = YY_("syntax error");
11350         int yysyntax_error_status;
11351         yysyntax_error_status = YYSYNTAX_ERROR;
11352         if (yysyntax_error_status == 0)
11353           yymsgp = yymsg;
11354         else if (yysyntax_error_status == 1)
11355           {
11356             if (yymsg != yymsgbuf)
11357               YYSTACK_FREE (yymsg);
11358             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11359             if (!yymsg)
11360               {
11361                 yymsg = yymsgbuf;
11362                 yymsg_alloc = sizeof yymsgbuf;
11363                 yysyntax_error_status = 2;
11364               }
11365             else
11366               {
11367                 yysyntax_error_status = YYSYNTAX_ERROR;
11368                 yymsgp = yymsg;
11369               }
11370           }
11371         parser_yyerror (parser, yymsgp);
11372         if (yysyntax_error_status == 2)
11373           goto yyexhaustedlab;
11374       }
11375 # undef YYSYNTAX_ERROR
11376 #endif
11377     }
11378 
11379 
11380 
11381   if (yyerrstatus == 3)
11382     {
11383       /* If just tried and failed to reuse lookahead token after an
11384          error, discard it.  */
11385 
11386       if (yychar <= YYEOF)
11387         {
11388           /* Return failure if at end of input.  */
11389           if (yychar == YYEOF)
11390             YYABORT;
11391         }
11392       else
11393         {
11394           yydestruct ("Error: discarding",
11395                       yytoken, &yylval, parser);
11396           yychar = YYEMPTY;
11397         }
11398     }
11399 
11400   /* Else will try to reuse lookahead token after shifting the error
11401      token.  */
11402   goto yyerrlab1;
11403 
11404 
11405 /*---------------------------------------------------.
11406 | yyerrorlab -- error raised explicitly by YYERROR.  |
11407 `---------------------------------------------------*/
11408 yyerrorlab:
11409 
11410   /* Pacify compilers like GCC when the user code never invokes
11411      YYERROR and the label yyerrorlab therefore never appears in user
11412      code.  */
11413   if (/*CONSTCOND*/ 0)
11414      goto yyerrorlab;
11415 
11416   /* Do not reclaim the symbols of the rule which action triggered
11417      this YYERROR.  */
11418   YYPOPSTACK (yylen);
11419   yylen = 0;
11420   YY_STACK_PRINT (yyss, yyssp);
11421   yystate = *yyssp;
11422   goto yyerrlab1;
11423 
11424 
11425 /*-------------------------------------------------------------.
11426 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
11427 `-------------------------------------------------------------*/
11428 yyerrlab1:
11429   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
11430 
11431   for (;;)
11432     {
11433       yyn = yypact[yystate];
11434       if (!yypact_value_is_default (yyn))
11435         {
11436           yyn += YYTERROR;
11437           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11438             {
11439               yyn = yytable[yyn];
11440               if (0 < yyn)
11441                 break;
11442             }
11443         }
11444 
11445       /* Pop the current state because it cannot handle the error token.  */
11446       if (yyssp == yyss)
11447         YYABORT;
11448 
11449 
11450       yydestruct ("Error: popping",
11451                   yystos[yystate], yyvsp, parser);
11452       YYPOPSTACK (1);
11453       yystate = *yyssp;
11454       YY_STACK_PRINT (yyss, yyssp);
11455     }
11456 
11457   *++yyvsp = yylval;
11458 
11459 
11460   /* Shift the error token.  */
11461   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11462 
11463   yystate = yyn;
11464   goto yynewstate;
11465 
11466 
11467 /*-------------------------------------.
11468 | yyacceptlab -- YYACCEPT comes here.  |
11469 `-------------------------------------*/
11470 yyacceptlab:
11471   yyresult = 0;
11472   goto yyreturn;
11473 
11474 /*-----------------------------------.
11475 | yyabortlab -- YYABORT comes here.  |
11476 `-----------------------------------*/
11477 yyabortlab:
11478   yyresult = 1;
11479   goto yyreturn;
11480 
11481 #if !defined(yyoverflow) || YYERROR_VERBOSE
11482 /*-------------------------------------------------.
11483 | yyexhaustedlab -- memory exhaustion comes here.  |
11484 `-------------------------------------------------*/
11485 yyexhaustedlab:
11486   parser_yyerror (parser, YY_("memory exhausted"));
11487   yyresult = 2;
11488   /* Fall through.  */
11489 #endif
11490 
11491 yyreturn:
11492   if (yychar != YYEMPTY)
11493     {
11494       /* Make sure we have latest lookahead translation.  See comments at
11495          user semantic actions for why this is necessary.  */
11496       yytoken = YYTRANSLATE (yychar);
11497       yydestruct ("Cleanup: discarding lookahead",
11498                   yytoken, &yylval, parser);
11499     }
11500   /* Do not reclaim the symbols of the rule which action triggered
11501      this YYABORT or YYACCEPT.  */
11502   YYPOPSTACK (yylen);
11503   YY_STACK_PRINT (yyss, yyssp);
11504   while (yyssp != yyss)
11505     {
11506       yydestruct ("Cleanup: popping",
11507                   yystos[*yyssp], yyvsp, parser);
11508       YYPOPSTACK (1);
11509     }
11510 #ifndef yyoverflow
11511   if (yyss != yyssa)
11512     YYSTACK_FREE (yyss);
11513 #endif
11514 #if YYERROR_VERBOSE
11515   if (yymsg != yymsgbuf)
11516     YYSTACK_FREE (yymsg);
11517 #endif
11518   /* Make sure YYID is used.  */
11519   return YYID (yyresult);
11520 }
11521 
11522 
11523 
11524 /* Line 2067 of yacc.c  */
11525 #line 5009 "ripper.y"
11526 
11527 # undef parser
11528 # undef yylex
11529 # undef yylval
11530 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
11531 
11532 static int parser_regx_options(struct parser_params*);
11533 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11534 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11535 static int parser_parse_string(struct parser_params*,NODE*);
11536 static int parser_here_document(struct parser_params*,NODE*);
11537 
11538 
11539 # define nextc()                   parser_nextc(parser)
11540 # define pushback(c)               parser_pushback(parser, (c))
11541 # define newtok()                  parser_newtok(parser)
11542 # define tokspace(n)               parser_tokspace(parser, (n))
11543 # define tokadd(c)                 parser_tokadd(parser, (c))
11544 # define tok_hex(numlen)           parser_tok_hex(parser, (numlen))
11545 # define read_escape(flags,e)      parser_read_escape(parser, (flags), (e))
11546 # define tokadd_escape(e)          parser_tokadd_escape(parser, (e))
11547 # define regx_options()            parser_regx_options(parser)
11548 # define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11549 # define parse_string(n)           parser_parse_string(parser,(n))
11550 # define tokaddmbc(c, enc)         parser_tokaddmbc(parser, (c), (enc))
11551 # define here_document(n)          parser_here_document(parser,(n))
11552 # define heredoc_identifier()      parser_heredoc_identifier(parser)
11553 # define heredoc_restore(n)        parser_heredoc_restore(parser,(n))
11554 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,(e),(l),(i))
11555 
11556 #ifndef RIPPER
11557 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11558 # define set_yylval_num(x) (yylval.num = (x))
11559 # define set_yylval_id(x)  (yylval.id = (x))
11560 # define set_yylval_name(x)  (yylval.id = (x))
11561 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11562 # define set_yylval_node(x) (yylval.node = (x))
11563 # define yylval_id() (yylval.id)
11564 #else
11565 static inline VALUE
11566 ripper_yylval_id(ID x)
11567 {
11568     return (VALUE)NEW_LASGN(x, ID2SYM(x));
11569 }
11570 # define set_yylval_str(x) (void)(x)
11571 # define set_yylval_num(x) (void)(x)
11572 # define set_yylval_id(x)  (void)(x)
11573 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11574 # define set_yylval_literal(x) (void)(x)
11575 # define set_yylval_node(x) (void)(x)
11576 # define yylval_id() yylval.id
11577 #endif
11578 
11579 #ifndef RIPPER
11580 #define ripper_flush(p) (void)(p)
11581 #else
11582 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11583 
11584 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11585 
11586 static int
11587 ripper_has_scan_event(struct parser_params *parser)
11588 {
11589 
11590     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11591     return lex_p > parser->tokp;
11592 }
11593 
11594 static VALUE
11595 ripper_scan_event_val(struct parser_params *parser, int t)
11596 {
11597     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11598     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11599     ripper_flush(parser);
11600     return rval;
11601 }
11602 
11603 static void
11604 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11605 {
11606     if (!ripper_has_scan_event(parser)) return;
11607     yylval_rval = ripper_scan_event_val(parser, t);
11608 }
11609 
11610 static void
11611 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11612 {
11613     if (!ripper_has_scan_event(parser)) return;
11614     (void)ripper_scan_event_val(parser, t);
11615 }
11616 
11617 static void
11618 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11619 {
11620     int saved_line = ruby_sourceline;
11621     const char *saved_tokp = parser->tokp;
11622 
11623     ruby_sourceline = parser->delayed_line;
11624     parser->tokp = lex_pbeg + parser->delayed_col;
11625     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11626     parser->delayed = Qnil;
11627     ruby_sourceline = saved_line;
11628     parser->tokp = saved_tokp;
11629 }
11630 #endif /* RIPPER */
11631 
11632 #include "ruby/regex.h"
11633 #include "ruby/util.h"
11634 
11635 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11636    since ours (we hope) works properly with all combinations of
11637    machines, compilers, `char' and `unsigned char' argument types.
11638    (Per Bothner suggested the basic approach.)  */
11639 #undef SIGN_EXTEND_CHAR
11640 #if __STDC__
11641 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11642 #else  /* not __STDC__ */
11643 /* As in Harbison and Steele.  */
11644 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11645 #endif
11646 
11647 #define parser_encoding_name()  (current_enc->name)
11648 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,current_enc)
11649 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11650 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11651 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11652 
11653 #define parser_isascii() ISASCII(*(lex_p-1))
11654 
11655 #ifndef RIPPER
11656 static int
11657 token_info_get_column(struct parser_params *parser, const char *token)
11658 {
11659     int column = 1;
11660     const char *p, *pend = lex_p - strlen(token);
11661     for (p = lex_pbeg; p < pend; p++) {
11662         if (*p == '\t') {
11663             column = (((column - 1) / 8) + 1) * 8;
11664         }
11665         column++;
11666     }
11667     return column;
11668 }
11669 
11670 static int
11671 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11672 {
11673     const char *p, *pend = lex_p - strlen(token);
11674     for (p = lex_pbeg; p < pend; p++) {
11675         if (*p != ' ' && *p != '\t') {
11676             return 1;
11677         }
11678     }
11679     return 0;
11680 }
11681 
11682 #undef token_info_push
11683 static void
11684 token_info_push(struct parser_params *parser, const char *token)
11685 {
11686     token_info *ptinfo;
11687 
11688     if (!parser->parser_token_info_enabled) return;
11689     ptinfo = ALLOC(token_info);
11690     ptinfo->token = token;
11691     ptinfo->linenum = ruby_sourceline;
11692     ptinfo->column = token_info_get_column(parser, token);
11693     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11694     ptinfo->next = parser->parser_token_info;
11695 
11696     parser->parser_token_info = ptinfo;
11697 }
11698 
11699 #undef token_info_pop
11700 static void
11701 token_info_pop(struct parser_params *parser, const char *token)
11702 {
11703     int linenum;
11704     token_info *ptinfo = parser->parser_token_info;
11705 
11706     if (!ptinfo) return;
11707     parser->parser_token_info = ptinfo->next;
11708     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11709         goto finish;
11710     }
11711     linenum = ruby_sourceline;
11712     if (linenum == ptinfo->linenum) { /* SKIP */
11713         goto finish;
11714     }
11715     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11716         goto finish;
11717     }
11718     if (parser->parser_token_info_enabled) {
11719         rb_compile_warn(ruby_sourcefile, linenum,
11720                         "mismatched indentations at '%s' with '%s' at %d",
11721                         token, ptinfo->token, ptinfo->linenum);
11722     }
11723 
11724   finish:
11725     xfree(ptinfo);
11726 }
11727 #endif  /* RIPPER */
11728 
11729 static int
11730 parser_yyerror(struct parser_params *parser, const char *msg)
11731 {
11732 #ifndef RIPPER
11733     const int max_line_margin = 30;
11734     const char *p, *pe;
11735     char *buf;
11736     long len;
11737     int i;
11738 
11739     compile_error(PARSER_ARG "%s", msg);
11740     p = lex_p;
11741     while (lex_pbeg <= p) {
11742         if (*p == '\n') break;
11743         p--;
11744     }
11745     p++;
11746 
11747     pe = lex_p;
11748     while (pe < lex_pend) {
11749         if (*pe == '\n') break;
11750         pe++;
11751     }
11752 
11753     len = pe - p;
11754     if (len > 4) {
11755         char *p2;
11756         const char *pre = "", *post = "";
11757 
11758         if (len > max_line_margin * 2 + 10) {
11759             if (lex_p - p > max_line_margin) {
11760                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11761                 pre = "...";
11762             }
11763             if (pe - lex_p > max_line_margin) {
11764                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11765                 post = "...";
11766             }
11767             len = pe - p;
11768         }
11769         buf = ALLOCA_N(char, len+2);
11770         MEMCPY(buf, p, char, len);
11771         buf[len] = '\0';
11772         rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11773 
11774         i = (int)(lex_p - p);
11775         p2 = buf; pe = buf + len;
11776 
11777         while (p2 < pe) {
11778             if (*p2 != '\t') *p2 = ' ';
11779             p2++;
11780         }
11781         buf[i] = '^';
11782         buf[i+1] = '\0';
11783         rb_compile_error_append("%s%s", pre, buf);
11784     }
11785 #else
11786     dispatch1(parse_error, STR_NEW2(msg));
11787 #endif /* !RIPPER */
11788     return 0;
11789 }
11790 
11791 static void parser_prepare(struct parser_params *parser);
11792 
11793 #ifndef RIPPER
11794 static VALUE
11795 debug_lines(VALUE fname)
11796 {
11797     ID script_lines;
11798     CONST_ID(script_lines, "SCRIPT_LINES__");
11799     if (rb_const_defined_at(rb_cObject, script_lines)) {
11800         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11801         if (RB_TYPE_P(hash, T_HASH)) {
11802             VALUE lines = rb_ary_new();
11803             rb_hash_aset(hash, fname, lines);
11804             return lines;
11805         }
11806     }
11807     return 0;
11808 }
11809 
11810 static VALUE
11811 coverage(VALUE fname, int n)
11812 {
11813     VALUE coverages = rb_get_coverages();
11814     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11815         VALUE lines = rb_ary_new2(n);
11816         int i;
11817         RBASIC(lines)->klass = 0;
11818         for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11819         RARRAY(lines)->as.heap.len = n;
11820         rb_hash_aset(coverages, fname, lines);
11821         return lines;
11822     }
11823     return 0;
11824 }
11825 
11826 static int
11827 e_option_supplied(struct parser_params *parser)
11828 {
11829     return strcmp(ruby_sourcefile, "-e") == 0;
11830 }
11831 
11832 static VALUE
11833 yycompile0(VALUE arg)
11834 {
11835     int n;
11836     NODE *tree;
11837     struct parser_params *parser = (struct parser_params *)arg;
11838 
11839     if (!compile_for_eval && rb_safe_level() == 0) {
11840         ruby_debug_lines = debug_lines(ruby_sourcefile_string);
11841         if (ruby_debug_lines && ruby_sourceline > 0) {
11842             VALUE str = STR_NEW0();
11843             n = ruby_sourceline;
11844             do {
11845                 rb_ary_push(ruby_debug_lines, str);
11846             } while (--n);
11847         }
11848 
11849         if (!e_option_supplied(parser)) {
11850             ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
11851         }
11852     }
11853 
11854     parser_prepare(parser);
11855     deferred_nodes = 0;
11856 #ifndef RIPPER
11857     parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
11858 #endif
11859 #ifndef RIPPER
11860     if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
11861         RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
11862                                 parser->parser_ruby_sourceline);
11863     }
11864 #endif
11865     n = yyparse((void*)parser);
11866 #ifndef RIPPER
11867     if (RUBY_DTRACE_PARSE_END_ENABLED()) {
11868         RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
11869                               parser->parser_ruby_sourceline);
11870     }
11871 #endif
11872     ruby_debug_lines = 0;
11873     ruby_coverage = 0;
11874     compile_for_eval = 0;
11875 
11876     lex_strterm = 0;
11877     lex_p = lex_pbeg = lex_pend = 0;
11878     lex_lastline = lex_nextline = 0;
11879     if (parser->nerr) {
11880         return 0;
11881     }
11882     tree = ruby_eval_tree;
11883     if (!tree) {
11884         tree = NEW_NIL();
11885     }
11886     else if (ruby_eval_tree_begin) {
11887         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11888     }
11889     return (VALUE)tree;
11890 }
11891 
11892 static NODE*
11893 yycompile(struct parser_params *parser, VALUE fname, int line)
11894 {
11895     ruby_sourcefile_string = rb_str_new_frozen(fname);
11896     ruby_sourcefile = RSTRING_PTR(fname);
11897     ruby_sourceline = line - 1;
11898     return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11899 }
11900 #endif /* !RIPPER */
11901 
11902 static rb_encoding *
11903 must_be_ascii_compatible(VALUE s)
11904 {
11905     rb_encoding *enc = rb_enc_get(s);
11906     if (!rb_enc_asciicompat(enc)) {
11907         rb_raise(rb_eArgError, "invalid source encoding");
11908     }
11909     return enc;
11910 }
11911 
11912 static VALUE
11913 lex_get_str(struct parser_params *parser, VALUE s)
11914 {
11915     char *beg, *end, *pend;
11916     rb_encoding *enc = must_be_ascii_compatible(s);
11917 
11918     beg = RSTRING_PTR(s);
11919     if (lex_gets_ptr) {
11920         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11921         beg += lex_gets_ptr;
11922     }
11923     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11924     end = beg;
11925     while (end < pend) {
11926         if (*end++ == '\n') break;
11927     }
11928     lex_gets_ptr = end - RSTRING_PTR(s);
11929     return rb_enc_str_new(beg, end - beg, enc);
11930 }
11931 
11932 static VALUE
11933 lex_getline(struct parser_params *parser)
11934 {
11935     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11936     if (NIL_P(line)) return line;
11937     must_be_ascii_compatible(line);
11938 #ifndef RIPPER
11939     if (ruby_debug_lines) {
11940         rb_enc_associate(line, current_enc);
11941         rb_ary_push(ruby_debug_lines, line);
11942     }
11943     if (ruby_coverage) {
11944         rb_ary_push(ruby_coverage, Qnil);
11945     }
11946 #endif
11947     return line;
11948 }
11949 
11950 #ifdef RIPPER
11951 static rb_data_type_t parser_data_type;
11952 #else
11953 static const rb_data_type_t parser_data_type;
11954 
11955 static NODE*
11956 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11957 {
11958     struct parser_params *parser;
11959     NODE *node;
11960 
11961     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11962     lex_gets = lex_get_str;
11963     lex_gets_ptr = 0;
11964     lex_input = s;
11965     lex_pbeg = lex_p = lex_pend = 0;
11966     compile_for_eval = rb_parse_in_eval();
11967 
11968     node = yycompile(parser, fname, line);
11969     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11970 
11971     return node;
11972 }
11973 
11974 NODE*
11975 rb_compile_string(const char *f, VALUE s, int line)
11976 {
11977     must_be_ascii_compatible(s);
11978     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
11979 }
11980 
11981 NODE*
11982 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11983 {
11984     return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
11985 }
11986 
11987 NODE*
11988 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
11989 {
11990     must_be_ascii_compatible(s);
11991     return parser_compile_string(vparser, f, s, line);
11992 }
11993 
11994 NODE*
11995 rb_compile_cstr(const char *f, const char *s, int len, int line)
11996 {
11997     VALUE str = rb_str_new(s, len);
11998     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
11999 }
12000 
12001 NODE*
12002 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12003 {
12004     VALUE str = rb_str_new(s, len);
12005     return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12006 }
12007 
12008 static VALUE
12009 lex_io_gets(struct parser_params *parser, VALUE io)
12010 {
12011     return rb_io_gets(io);
12012 }
12013 
12014 NODE*
12015 rb_compile_file(const char *f, VALUE file, int start)
12016 {
12017     VALUE volatile vparser = rb_parser_new();
12018 
12019     return rb_parser_compile_file(vparser, f, file, start);
12020 }
12021 
12022 NODE*
12023 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12024 {
12025     return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12026 }
12027 
12028 NODE*
12029 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12030 {
12031     struct parser_params *parser;
12032     NODE *node;
12033 
12034     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12035     lex_gets = lex_io_gets;
12036     lex_input = file;
12037     lex_pbeg = lex_p = lex_pend = 0;
12038     compile_for_eval = rb_parse_in_eval();
12039 
12040     node = yycompile(parser, fname, start);
12041     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12042 
12043     return node;
12044 }
12045 #endif  /* !RIPPER */
12046 
12047 #define STR_FUNC_ESCAPE 0x01
12048 #define STR_FUNC_EXPAND 0x02
12049 #define STR_FUNC_REGEXP 0x04
12050 #define STR_FUNC_QWORDS 0x08
12051 #define STR_FUNC_SYMBOL 0x10
12052 #define STR_FUNC_INDENT 0x20
12053 
12054 enum string_type {
12055     str_squote = (0),
12056     str_dquote = (STR_FUNC_EXPAND),
12057     str_xquote = (STR_FUNC_EXPAND),
12058     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
12059     str_sword  = (STR_FUNC_QWORDS),
12060     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
12061     str_ssym   = (STR_FUNC_SYMBOL),
12062     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
12063 };
12064 
12065 static VALUE
12066 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12067 {
12068     VALUE str;
12069 
12070     str = rb_enc_str_new(p, n, enc);
12071     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12072         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
12073         }
12074         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12075             rb_enc_associate(str, rb_ascii8bit_encoding());
12076         }
12077     }
12078 
12079     return str;
12080 }
12081 
12082 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12083 #define lex_eol_p() (lex_p >= lex_pend)
12084 #define peek(c) peek_n((c), 0)
12085 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12086 
12087 static inline int
12088 parser_nextc(struct parser_params *parser)
12089 {
12090     int c;
12091 
12092     if (lex_p == lex_pend) {
12093         VALUE v = lex_nextline;
12094         lex_nextline = 0;
12095         if (!v) {
12096             if (parser->eofp)
12097                 return -1;
12098 
12099             if (!lex_input || NIL_P(v = lex_getline(parser))) {
12100                 parser->eofp = Qtrue;
12101                 lex_goto_eol(parser);
12102                 return -1;
12103             }
12104         }
12105         {
12106 #ifdef RIPPER
12107             if (parser->tokp < lex_pend) {
12108                 if (NIL_P(parser->delayed)) {
12109                     parser->delayed = rb_str_buf_new(1024);
12110                     rb_enc_associate(parser->delayed, current_enc);
12111                     rb_str_buf_cat(parser->delayed,
12112                                    parser->tokp, lex_pend - parser->tokp);
12113                     parser->delayed_line = ruby_sourceline;
12114                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12115                 }
12116                 else {
12117                     rb_str_buf_cat(parser->delayed,
12118                                    parser->tokp, lex_pend - parser->tokp);
12119                 }
12120             }
12121 #endif
12122             if (heredoc_end > 0) {
12123                 ruby_sourceline = heredoc_end;
12124                 heredoc_end = 0;
12125             }
12126             ruby_sourceline++;
12127             parser->line_count++;
12128             lex_pbeg = lex_p = RSTRING_PTR(v);
12129             lex_pend = lex_p + RSTRING_LEN(v);
12130             ripper_flush(parser);
12131             lex_lastline = v;
12132         }
12133     }
12134     c = (unsigned char)*lex_p++;
12135     if (c == '\r' && peek('\n')) {
12136         lex_p++;
12137         c = '\n';
12138     }
12139 
12140     return c;
12141 }
12142 
12143 static void
12144 parser_pushback(struct parser_params *parser, int c)
12145 {
12146     if (c == -1) return;
12147     lex_p--;
12148     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12149         lex_p--;
12150     }
12151 }
12152 
12153 #define was_bol() (lex_p == lex_pbeg + 1)
12154 
12155 #define tokfix() (tokenbuf[tokidx]='\0')
12156 #define tok() tokenbuf
12157 #define toklen() tokidx
12158 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12159 
12160 static char*
12161 parser_newtok(struct parser_params *parser)
12162 {
12163     tokidx = 0;
12164     tokline = ruby_sourceline;
12165     if (!tokenbuf) {
12166         toksiz = 60;
12167         tokenbuf = ALLOC_N(char, 60);
12168     }
12169     if (toksiz > 4096) {
12170         toksiz = 60;
12171         REALLOC_N(tokenbuf, char, 60);
12172     }
12173     return tokenbuf;
12174 }
12175 
12176 static char *
12177 parser_tokspace(struct parser_params *parser, int n)
12178 {
12179     tokidx += n;
12180 
12181     if (tokidx >= toksiz) {
12182         do {toksiz *= 2;} while (toksiz < tokidx);
12183         REALLOC_N(tokenbuf, char, toksiz);
12184     }
12185     return &tokenbuf[tokidx-n];
12186 }
12187 
12188 static void
12189 parser_tokadd(struct parser_params *parser, int c)
12190 {
12191     tokenbuf[tokidx++] = (char)c;
12192     if (tokidx >= toksiz) {
12193         toksiz *= 2;
12194         REALLOC_N(tokenbuf, char, toksiz);
12195     }
12196 }
12197 
12198 static int
12199 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12200 {
12201     int c;
12202 
12203     c = scan_hex(lex_p, 2, numlen);
12204     if (!*numlen) {
12205         yyerror("invalid hex escape");
12206         return 0;
12207     }
12208     lex_p += *numlen;
12209     return c;
12210 }
12211 
12212 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12213 
12214 /* return value is for ?\u3042 */
12215 static int
12216 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
12217                    int string_literal, int symbol_literal, int regexp_literal)
12218 {
12219     /*
12220      * If string_literal is true, then we allow multiple codepoints
12221      * in \u{}, and add the codepoints to the current token.
12222      * Otherwise we're parsing a character literal and return a single
12223      * codepoint without adding it
12224      */
12225 
12226     int codepoint;
12227     size_t numlen;
12228 
12229     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12230 
12231     if (peek('{')) {  /* handle \u{...} form */
12232         do {
12233             if (regexp_literal) { tokadd(*lex_p); }
12234             nextc();
12235             codepoint = scan_hex(lex_p, 6, &numlen);
12236             if (numlen == 0)  {
12237                 yyerror("invalid Unicode escape");
12238                 return 0;
12239             }
12240             if (codepoint > 0x10ffff) {
12241                 yyerror("invalid Unicode codepoint (too large)");
12242                 return 0;
12243             }
12244             lex_p += numlen;
12245             if (regexp_literal) {
12246                 tokcopy((int)numlen);
12247             }
12248             else if (codepoint >= 0x80) {
12249                 *encp = rb_utf8_encoding();
12250                 if (string_literal) tokaddmbc(codepoint, *encp);
12251             }
12252             else if (string_literal) {
12253                 tokadd(codepoint);
12254             }
12255         } while (string_literal && (peek(' ') || peek('\t')));
12256 
12257         if (!peek('}')) {
12258             yyerror("unterminated Unicode escape");
12259             return 0;
12260         }
12261 
12262         if (regexp_literal) { tokadd('}'); }
12263         nextc();
12264     }
12265     else {                      /* handle \uxxxx form */
12266         codepoint = scan_hex(lex_p, 4, &numlen);
12267         if (numlen < 4) {
12268             yyerror("invalid Unicode escape");
12269             return 0;
12270         }
12271         lex_p += 4;
12272         if (regexp_literal) {
12273             tokcopy(4);
12274         }
12275         else if (codepoint >= 0x80) {
12276             *encp = rb_utf8_encoding();
12277             if (string_literal) tokaddmbc(codepoint, *encp);
12278         }
12279         else if (string_literal) {
12280             tokadd(codepoint);
12281         }
12282     }
12283 
12284     return codepoint;
12285 }
12286 
12287 #define ESCAPE_CONTROL 1
12288 #define ESCAPE_META    2
12289 
12290 static int
12291 parser_read_escape(struct parser_params *parser, int flags,
12292                    rb_encoding **encp)
12293 {
12294     int c;
12295     size_t numlen;
12296 
12297     switch (c = nextc()) {
12298       case '\\':        /* Backslash */
12299         return c;
12300 
12301       case 'n': /* newline */
12302         return '\n';
12303 
12304       case 't': /* horizontal tab */
12305         return '\t';
12306 
12307       case 'r': /* carriage-return */
12308         return '\r';
12309 
12310       case 'f': /* form-feed */
12311         return '\f';
12312 
12313       case 'v': /* vertical tab */
12314         return '\13';
12315 
12316       case 'a': /* alarm(bell) */
12317         return '\007';
12318 
12319       case 'e': /* escape */
12320         return 033;
12321 
12322       case '0': case '1': case '2': case '3': /* octal constant */
12323       case '4': case '5': case '6': case '7':
12324         pushback(c);
12325         c = scan_oct(lex_p, 3, &numlen);
12326         lex_p += numlen;
12327         return c;
12328 
12329       case 'x': /* hex constant */
12330         c = tok_hex(&numlen);
12331         if (numlen == 0) return 0;
12332         return c;
12333 
12334       case 'b': /* backspace */
12335         return '\010';
12336 
12337       case 's': /* space */
12338         return ' ';
12339 
12340       case 'M':
12341         if (flags & ESCAPE_META) goto eof;
12342         if ((c = nextc()) != '-') {
12343             pushback(c);
12344             goto eof;
12345         }
12346         if ((c = nextc()) == '\\') {
12347             if (peek('u')) goto eof;
12348             return read_escape(flags|ESCAPE_META, encp) | 0x80;
12349         }
12350         else if (c == -1 || !ISASCII(c)) goto eof;
12351         else {
12352             return ((c & 0xff) | 0x80);
12353         }
12354 
12355       case 'C':
12356         if ((c = nextc()) != '-') {
12357             pushback(c);
12358             goto eof;
12359         }
12360       case 'c':
12361         if (flags & ESCAPE_CONTROL) goto eof;
12362         if ((c = nextc())== '\\') {
12363             if (peek('u')) goto eof;
12364             c = read_escape(flags|ESCAPE_CONTROL, encp);
12365         }
12366         else if (c == '?')
12367             return 0177;
12368         else if (c == -1 || !ISASCII(c)) goto eof;
12369         return c & 0x9f;
12370 
12371       eof:
12372       case -1:
12373         yyerror("Invalid escape character syntax");
12374         return '\0';
12375 
12376       default:
12377         return c;
12378     }
12379 }
12380 
12381 static void
12382 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
12383 {
12384     int len = rb_enc_codelen(c, enc);
12385     rb_enc_mbcput(c, tokspace(len), enc);
12386 }
12387 
12388 static int
12389 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
12390 {
12391     int c;
12392     int flags = 0;
12393     size_t numlen;
12394 
12395   first:
12396     switch (c = nextc()) {
12397       case '\n':
12398         return 0;               /* just ignore */
12399 
12400       case '0': case '1': case '2': case '3': /* octal constant */
12401       case '4': case '5': case '6': case '7':
12402         {
12403             ruby_scan_oct(--lex_p, 3, &numlen);
12404             if (numlen == 0) goto eof;
12405             lex_p += numlen;
12406             tokcopy((int)numlen + 1);
12407         }
12408         return 0;
12409 
12410       case 'x': /* hex constant */
12411         {
12412             tok_hex(&numlen);
12413             if (numlen == 0) return -1;
12414             tokcopy((int)numlen + 2);
12415         }
12416         return 0;
12417 
12418       case 'M':
12419         if (flags & ESCAPE_META) goto eof;
12420         if ((c = nextc()) != '-') {
12421             pushback(c);
12422             goto eof;
12423         }
12424         tokcopy(3);
12425         flags |= ESCAPE_META;
12426         goto escaped;
12427 
12428       case 'C':
12429         if (flags & ESCAPE_CONTROL) goto eof;
12430         if ((c = nextc()) != '-') {
12431             pushback(c);
12432             goto eof;
12433         }
12434         tokcopy(3);
12435         goto escaped;
12436 
12437       case 'c':
12438         if (flags & ESCAPE_CONTROL) goto eof;
12439         tokcopy(2);
12440         flags |= ESCAPE_CONTROL;
12441       escaped:
12442         if ((c = nextc()) == '\\') {
12443             goto first;
12444         }
12445         else if (c == -1) goto eof;
12446         tokadd(c);
12447         return 0;
12448 
12449       eof:
12450       case -1:
12451         yyerror("Invalid escape character syntax");
12452         return -1;
12453 
12454       default:
12455         tokadd('\\');
12456         tokadd(c);
12457     }
12458     return 0;
12459 }
12460 
12461 static int
12462 parser_regx_options(struct parser_params *parser)
12463 {
12464     int kcode = 0;
12465     int kopt = 0;
12466     int options = 0;
12467     int c, opt, kc;
12468 
12469     newtok();
12470     while (c = nextc(), ISALPHA(c)) {
12471         if (c == 'o') {
12472             options |= RE_OPTION_ONCE;
12473         }
12474         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12475             if (kc >= 0) {
12476                 if (kc != rb_ascii8bit_encindex()) kcode = c;
12477                 kopt = opt;
12478             }
12479             else {
12480                 options |= opt;
12481             }
12482         }
12483         else {
12484             tokadd(c);
12485         }
12486     }
12487     options |= kopt;
12488     pushback(c);
12489     if (toklen()) {
12490         tokfix();
12491         compile_error(PARSER_ARG "unknown regexp option%s - %s",
12492                       toklen() > 1 ? "s" : "", tok());
12493     }
12494     return options | RE_OPTION_ENCODING(kcode);
12495 }
12496 
12497 static void
12498 dispose_string(VALUE str)
12499 {
12500     rb_str_free(str);
12501     rb_gc_force_recycle(str);
12502 }
12503 
12504 static int
12505 parser_tokadd_mbchar(struct parser_params *parser, int c)
12506 {
12507     int len = parser_precise_mbclen();
12508     if (!MBCLEN_CHARFOUND_P(len)) {
12509         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12510         return -1;
12511     }
12512     tokadd(c);
12513     lex_p += --len;
12514     if (len > 0) tokcopy(len);
12515     return c;
12516 }
12517 
12518 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12519 
12520 static inline int
12521 simple_re_meta(int c)
12522 {
12523     switch (c) {
12524       case '$': case '*': case '+': case '.':
12525       case '?': case '^': case '|':
12526       case ')': case ']': case '}': case '>':
12527         return TRUE;
12528       default:
12529         return FALSE;
12530     }
12531 }
12532 
12533 static int
12534 parser_tokadd_string(struct parser_params *parser,
12535                      int func, int term, int paren, long *nest,
12536                      rb_encoding **encp)
12537 {
12538     int c;
12539     int has_nonascii = 0;
12540     rb_encoding *enc = *encp;
12541     char *errbuf = 0;
12542     static const char mixed_msg[] = "%s mixed within %s source";
12543 
12544 #define mixed_error(enc1, enc2) if (!errbuf) {  \
12545         size_t len = sizeof(mixed_msg) - 4;     \
12546         len += strlen(rb_enc_name(enc1));       \
12547         len += strlen(rb_enc_name(enc2));       \
12548         errbuf = ALLOCA_N(char, len);           \
12549         snprintf(errbuf, len, mixed_msg,        \
12550                  rb_enc_name(enc1),             \
12551                  rb_enc_name(enc2));            \
12552         yyerror(errbuf);                        \
12553     }
12554 #define mixed_escape(beg, enc1, enc2) do {      \
12555         const char *pos = lex_p;                \
12556         lex_p = (beg);                          \
12557         mixed_error((enc1), (enc2));            \
12558         lex_p = pos;                            \
12559     } while (0)
12560 
12561     while ((c = nextc()) != -1) {
12562         if (paren && c == paren) {
12563             ++*nest;
12564         }
12565         else if (c == term) {
12566             if (!nest || !*nest) {
12567                 pushback(c);
12568                 break;
12569             }
12570             --*nest;
12571         }
12572         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12573             int c2 = *lex_p;
12574             if (c2 == '$' || c2 == '@' || c2 == '{') {
12575                 pushback(c);
12576                 break;
12577             }
12578         }
12579         else if (c == '\\') {
12580             const char *beg = lex_p - 1;
12581             c = nextc();
12582             switch (c) {
12583               case '\n':
12584                 if (func & STR_FUNC_QWORDS) break;
12585                 if (func & STR_FUNC_EXPAND) continue;
12586                 tokadd('\\');
12587                 break;
12588 
12589               case '\\':
12590                 if (func & STR_FUNC_ESCAPE) tokadd(c);
12591                 break;
12592 
12593               case 'u':
12594                 if ((func & STR_FUNC_EXPAND) == 0) {
12595                     tokadd('\\');
12596                     break;
12597                 }
12598                 parser_tokadd_utf8(parser, &enc, 1,
12599                                    func & STR_FUNC_SYMBOL,
12600                                    func & STR_FUNC_REGEXP);
12601                 if (has_nonascii && enc != *encp) {
12602                     mixed_escape(beg, enc, *encp);
12603                 }
12604                 continue;
12605 
12606               default:
12607                 if (c == -1) return -1;
12608                 if (!ISASCII(c)) {
12609                     if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12610                     goto non_ascii;
12611                 }
12612                 if (func & STR_FUNC_REGEXP) {
12613                     if (c == term && !simple_re_meta(c)) {
12614                         tokadd(c);
12615                         continue;
12616                     }
12617                     pushback(c);
12618                     if ((c = tokadd_escape(&enc)) < 0)
12619                         return -1;
12620                     if (has_nonascii && enc != *encp) {
12621                         mixed_escape(beg, enc, *encp);
12622                     }
12623                     continue;
12624                 }
12625                 else if (func & STR_FUNC_EXPAND) {
12626                     pushback(c);
12627                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
12628                     c = read_escape(0, &enc);
12629                 }
12630                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12631                     /* ignore backslashed spaces in %w */
12632                 }
12633                 else if (c != term && !(paren && c == paren)) {
12634                     tokadd('\\');
12635                     pushback(c);
12636                     continue;
12637                 }
12638             }
12639         }
12640         else if (!parser_isascii()) {
12641           non_ascii:
12642             has_nonascii = 1;
12643             if (enc != *encp) {
12644                 mixed_error(enc, *encp);
12645                 continue;
12646             }
12647             if (tokadd_mbchar(c) == -1) return -1;
12648             continue;
12649         }
12650         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12651             pushback(c);
12652             break;
12653         }
12654         if (c & 0x80) {
12655             has_nonascii = 1;
12656             if (enc != *encp) {
12657                 mixed_error(enc, *encp);
12658                 continue;
12659             }
12660         }
12661         tokadd(c);
12662     }
12663     *encp = enc;
12664     return c;
12665 }
12666 
12667 #define NEW_STRTERM(func, term, paren) \
12668         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12669 
12670 #ifdef RIPPER
12671 static void
12672 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12673 {
12674     if (!NIL_P(parser->delayed)) {
12675         ptrdiff_t len = lex_p - parser->tokp;
12676         if (len > 0) {
12677             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12678         }
12679         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12680         parser->tokp = lex_p;
12681     }
12682 }
12683 
12684 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12685 #else
12686 #define flush_string_content(enc) ((void)(enc))
12687 #endif
12688 
12689 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12690 /* this can be shared with ripper, since it's independent from struct
12691  * parser_params. */
12692 #ifndef RIPPER
12693 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12694 #define SPECIAL_PUNCT(idx) ( \
12695         BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12696         BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12697         BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12698         BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12699         BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12700         BIT('0', idx))
12701 const unsigned int ruby_global_name_punct_bits[] = {
12702     SPECIAL_PUNCT(0),
12703     SPECIAL_PUNCT(1),
12704     SPECIAL_PUNCT(2),
12705 };
12706 #undef BIT
12707 #undef SPECIAL_PUNCT
12708 #endif
12709 
12710 static inline int
12711 is_global_name_punct(const char c)
12712 {
12713     if (c <= 0x20 || 0x7e < c) return 0;
12714     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12715 }
12716 
12717 static int
12718 parser_peek_variable_name(struct parser_params *parser)
12719 {
12720     int c;
12721     const char *p = lex_p;
12722 
12723     if (p + 1 >= lex_pend) return 0;
12724     c = *p++;
12725     switch (c) {
12726       case '$':
12727         if ((c = *p) == '-') {
12728             if (++p >= lex_pend) return 0;
12729             c = *p;
12730         }
12731         else if (is_global_name_punct(c) || ISDIGIT(c)) {
12732             return tSTRING_DVAR;
12733         }
12734         break;
12735       case '@':
12736         if ((c = *p) == '@') {
12737             if (++p >= lex_pend) return 0;
12738             c = *p;
12739         }
12740         break;
12741       case '{':
12742         lex_p = p;
12743         command_start = TRUE;
12744         return tSTRING_DBEG;
12745       default:
12746         return 0;
12747     }
12748     if (!ISASCII(c) || c == '_' || ISALPHA(c))
12749         return tSTRING_DVAR;
12750     return 0;
12751 }
12752 
12753 static int
12754 parser_parse_string(struct parser_params *parser, NODE *quote)
12755 {
12756     int func = (int)quote->nd_func;
12757     int term = nd_term(quote);
12758     int paren = nd_paren(quote);
12759     int c, space = 0;
12760     rb_encoding *enc = current_enc;
12761 
12762     if (func == -1) return tSTRING_END;
12763     c = nextc();
12764     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12765         do {c = nextc();} while (ISSPACE(c));
12766         space = 1;
12767     }
12768     if (c == term && !quote->nd_nest) {
12769         if (func & STR_FUNC_QWORDS) {
12770             quote->nd_func = -1;
12771             return ' ';
12772         }
12773         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12774         set_yylval_num(regx_options());
12775         return tREGEXP_END;
12776     }
12777     if (space) {
12778         pushback(c);
12779         return ' ';
12780     }
12781     newtok();
12782     if ((func & STR_FUNC_EXPAND) && c == '#') {
12783         int t = parser_peek_variable_name(parser);
12784         if (t) return t;
12785         tokadd('#');
12786         c = nextc();
12787     }
12788     pushback(c);
12789     if (tokadd_string(func, term, paren, &quote->nd_nest,
12790                       &enc) == -1) {
12791         ruby_sourceline = nd_line(quote);
12792         if (func & STR_FUNC_REGEXP) {
12793             if (parser->eofp)
12794                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
12795             return tREGEXP_END;
12796         }
12797         else {
12798             if (parser->eofp)
12799                 compile_error(PARSER_ARG "unterminated string meets end of file");
12800             return tSTRING_END;
12801         }
12802     }
12803 
12804     tokfix();
12805     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12806     flush_string_content(enc);
12807 
12808     return tSTRING_CONTENT;
12809 }
12810 
12811 static int
12812 parser_heredoc_identifier(struct parser_params *parser)
12813 {
12814     int c = nextc(), term, func = 0;
12815     long len;
12816 
12817     if (c == '-') {
12818         c = nextc();
12819         func = STR_FUNC_INDENT;
12820     }
12821     switch (c) {
12822       case '\'':
12823         func |= str_squote; goto quoted;
12824       case '"':
12825         func |= str_dquote; goto quoted;
12826       case '`':
12827         func |= str_xquote;
12828       quoted:
12829         newtok();
12830         tokadd(func);
12831         term = c;
12832         while ((c = nextc()) != -1 && c != term) {
12833             if (tokadd_mbchar(c) == -1) return 0;
12834         }
12835         if (c == -1) {
12836             compile_error(PARSER_ARG "unterminated here document identifier");
12837             return 0;
12838         }
12839         break;
12840 
12841       default:
12842         if (!parser_is_identchar()) {
12843             pushback(c);
12844             if (func & STR_FUNC_INDENT) {
12845                 pushback('-');
12846             }
12847             return 0;
12848         }
12849         newtok();
12850         term = '"';
12851         tokadd(func |= str_dquote);
12852         do {
12853             if (tokadd_mbchar(c) == -1) return 0;
12854         } while ((c = nextc()) != -1 && parser_is_identchar());
12855         pushback(c);
12856         break;
12857     }
12858 
12859     tokfix();
12860 #ifdef RIPPER
12861     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12862 #endif
12863     len = lex_p - lex_pbeg;
12864     lex_goto_eol(parser);
12865     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12866                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12867                                   len,                          /* nd_nth */
12868                                   lex_lastline);                /* nd_orig */
12869     nd_set_line(lex_strterm, ruby_sourceline);
12870     ripper_flush(parser);
12871     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12872 }
12873 
12874 static void
12875 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12876 {
12877     VALUE line;
12878 
12879     line = here->nd_orig;
12880     lex_lastline = line;
12881     lex_pbeg = RSTRING_PTR(line);
12882     lex_pend = lex_pbeg + RSTRING_LEN(line);
12883     lex_p = lex_pbeg + here->nd_nth;
12884     heredoc_end = ruby_sourceline;
12885     ruby_sourceline = nd_line(here);
12886     dispose_string(here->nd_lit);
12887     rb_gc_force_recycle((VALUE)here);
12888     ripper_flush(parser);
12889 }
12890 
12891 static int
12892 parser_whole_match_p(struct parser_params *parser,
12893     const char *eos, long len, int indent)
12894 {
12895     const char *p = lex_pbeg;
12896     long n;
12897 
12898     if (indent) {
12899         while (*p && ISSPACE(*p)) p++;
12900     }
12901     n = lex_pend - (p + len);
12902     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12903     return strncmp(eos, p, len) == 0;
12904 }
12905 
12906 #ifdef RIPPER
12907 static void
12908 ripper_dispatch_heredoc_end(struct parser_params *parser)
12909 {
12910     if (!NIL_P(parser->delayed))
12911         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12912     lex_goto_eol(parser);
12913     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12914 }
12915 
12916 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12917 #else
12918 #define dispatch_heredoc_end() ((void)0)
12919 #endif
12920 
12921 static int
12922 parser_here_document(struct parser_params *parser, NODE *here)
12923 {
12924     int c, func, indent = 0;
12925     const char *eos, *p, *pend;
12926     long len;
12927     VALUE str = 0;
12928     rb_encoding *enc = current_enc;
12929 
12930     eos = RSTRING_PTR(here->nd_lit);
12931     len = RSTRING_LEN(here->nd_lit) - 1;
12932     indent = (func = *eos++) & STR_FUNC_INDENT;
12933 
12934     if ((c = nextc()) == -1) {
12935       error:
12936         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12937 #ifdef RIPPER
12938         if (NIL_P(parser->delayed)) {
12939             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12940         }
12941         else {
12942             if (str ||
12943                 ((len = lex_p - parser->tokp) > 0 &&
12944                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12945                 rb_str_append(parser->delayed, str);
12946             }
12947             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12948         }
12949         lex_goto_eol(parser);
12950 #endif
12951       restore:
12952         heredoc_restore(lex_strterm);
12953         lex_strterm = 0;
12954         return 0;
12955     }
12956     if (was_bol() && whole_match_p(eos, len, indent)) {
12957         dispatch_heredoc_end();
12958         heredoc_restore(lex_strterm);
12959         return tSTRING_END;
12960     }
12961 
12962     if (!(func & STR_FUNC_EXPAND)) {
12963         do {
12964             p = RSTRING_PTR(lex_lastline);
12965             pend = lex_pend;
12966             if (pend > p) {
12967                 switch (pend[-1]) {
12968                   case '\n':
12969                     if (--pend == p || pend[-1] != '\r') {
12970                         pend++;
12971                         break;
12972                     }
12973                   case '\r':
12974                     --pend;
12975                 }
12976             }
12977             if (str)
12978                 rb_str_cat(str, p, pend - p);
12979             else
12980                 str = STR_NEW(p, pend - p);
12981             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12982             lex_goto_eol(parser);
12983             if (nextc() == -1) {
12984                 if (str) {
12985                     dispose_string(str);
12986                     str = 0;
12987                 }
12988                 goto error;
12989             }
12990         } while (!whole_match_p(eos, len, indent));
12991     }
12992     else {
12993         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12994         newtok();
12995         if (c == '#') {
12996             int t = parser_peek_variable_name(parser);
12997             if (t) return t;
12998             tokadd('#');
12999             c = nextc();
13000         }
13001         do {
13002             pushback(c);
13003             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13004                 if (parser->eofp) goto error;
13005                 goto restore;
13006             }
13007             if (c != '\n') {
13008                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13009                 flush_string_content(enc);
13010                 return tSTRING_CONTENT;
13011             }
13012             tokadd(nextc());
13013             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13014             if ((c = nextc()) == -1) goto error;
13015         } while (!whole_match_p(eos, len, indent));
13016         str = STR_NEW3(tok(), toklen(), enc, func);
13017     }
13018     dispatch_heredoc_end();
13019     heredoc_restore(lex_strterm);
13020     lex_strterm = NEW_STRTERM(-1, 0, 0);
13021     set_yylval_str(str);
13022     return tSTRING_CONTENT;
13023 }
13024 
13025 #include "lex.c"
13026 
13027 static void
13028 arg_ambiguous_gen(struct parser_params *parser)
13029 {
13030 #ifndef RIPPER
13031     rb_warning0("ambiguous first argument; put parentheses or even spaces");
13032 #else
13033     dispatch0(arg_ambiguous);
13034 #endif
13035 }
13036 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13037 
13038 static ID
13039 formal_argument_gen(struct parser_params *parser, ID lhs)
13040 {
13041 #ifndef RIPPER
13042     if (!is_local_id(lhs))
13043         yyerror("formal argument must be local variable");
13044 #endif
13045     shadowing_lvar(lhs);
13046     return lhs;
13047 }
13048 
13049 static int
13050 lvar_defined_gen(struct parser_params *parser, ID id)
13051 {
13052     return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13053 }
13054 
13055 /* emacsen -*- hack */
13056 static long
13057 parser_encode_length(struct parser_params *parser, const char *name, long len)
13058 {
13059     long nlen;
13060 
13061     if (len > 5 && name[nlen = len - 5] == '-') {
13062         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13063             return nlen;
13064     }
13065     if (len > 4 && name[nlen = len - 4] == '-') {
13066         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13067             return nlen;
13068         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13069             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13070             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13071             return nlen;
13072     }
13073     return len;
13074 }
13075 
13076 static void
13077 parser_set_encode(struct parser_params *parser, const char *name)
13078 {
13079     int idx = rb_enc_find_index(name);
13080     rb_encoding *enc;
13081     VALUE excargs[3];
13082 
13083     if (idx < 0) {
13084         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13085       error:
13086         excargs[0] = rb_eArgError;
13087         excargs[2] = rb_make_backtrace();
13088         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13089         rb_exc_raise(rb_make_exception(3, excargs));
13090     }
13091     enc = rb_enc_from_index(idx);
13092     if (!rb_enc_asciicompat(enc)) {
13093         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13094         goto error;
13095     }
13096     parser->enc = enc;
13097 #ifndef RIPPER
13098     if (ruby_debug_lines) {
13099         long i, n = RARRAY_LEN(ruby_debug_lines);
13100         const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13101         for (i = 0; i < n; ++i) {
13102             rb_enc_associate_index(*p, idx);
13103         }
13104     }
13105 #endif
13106 }
13107 
13108 static int
13109 comment_at_top(struct parser_params *parser)
13110 {
13111     const char *p = lex_pbeg, *pend = lex_p - 1;
13112     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13113     while (p < pend) {
13114         if (!ISSPACE(*p)) return 0;
13115         p++;
13116     }
13117     return 1;
13118 }
13119 
13120 #ifndef RIPPER
13121 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13122 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13123 
13124 static void
13125 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13126 {
13127     if (!comment_at_top(parser)) {
13128         return;
13129     }
13130     parser_set_encode(parser, val);
13131 }
13132 
13133 static void
13134 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13135 {
13136     int *p = &parser->parser_token_info_enabled;
13137 
13138     switch (*val) {
13139       case 't': case 'T':
13140         if (strcasecmp(val, "true") == 0) {
13141             *p = TRUE;
13142             return;
13143         }
13144         break;
13145       case 'f': case 'F':
13146         if (strcasecmp(val, "false") == 0) {
13147             *p = FALSE;
13148             return;
13149         }
13150         break;
13151     }
13152     rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13153 }
13154 
13155 struct magic_comment {
13156     const char *name;
13157     rb_magic_comment_setter_t func;
13158     rb_magic_comment_length_t length;
13159 };
13160 
13161 static const struct magic_comment magic_comments[] = {
13162     {"coding", magic_comment_encoding, parser_encode_length},
13163     {"encoding", magic_comment_encoding, parser_encode_length},
13164     {"warn_indent", parser_set_token_info},
13165 };
13166 #endif
13167 
13168 static const char *
13169 magic_comment_marker(const char *str, long len)
13170 {
13171     long i = 2;
13172 
13173     while (i < len) {
13174         switch (str[i]) {
13175           case '-':
13176             if (str[i-1] == '*' && str[i-2] == '-') {
13177                 return str + i + 1;
13178             }
13179             i += 2;
13180             break;
13181           case '*':
13182             if (i + 1 >= len) return 0;
13183             if (str[i+1] != '-') {
13184                 i += 4;
13185             }
13186             else if (str[i-1] != '-') {
13187                 i += 2;
13188             }
13189             else {
13190                 return str + i + 2;
13191             }
13192             break;
13193           default:
13194             i += 3;
13195             break;
13196         }
13197     }
13198     return 0;
13199 }
13200 
13201 static int
13202 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13203 {
13204     VALUE name = 0, val = 0;
13205     const char *beg, *end, *vbeg, *vend;
13206 #define str_copy(_s, _p, _n) ((_s) \
13207         ? (void)(rb_str_resize((_s), (_n)), \
13208            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13209         : (void)((_s) = STR_NEW((_p), (_n))))
13210 
13211     if (len <= 7) return FALSE;
13212     if (!(beg = magic_comment_marker(str, len))) return FALSE;
13213     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13214     str = beg;
13215     len = end - beg - 3;
13216 
13217     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13218     while (len > 0) {
13219 #ifndef RIPPER
13220         const struct magic_comment *p = magic_comments;
13221 #endif
13222         char *s;
13223         int i;
13224         long n = 0;
13225 
13226         for (; len > 0 && *str; str++, --len) {
13227             switch (*str) {
13228               case '\'': case '"': case ':': case ';':
13229                 continue;
13230             }
13231             if (!ISSPACE(*str)) break;
13232         }
13233         for (beg = str; len > 0; str++, --len) {
13234             switch (*str) {
13235               case '\'': case '"': case ':': case ';':
13236                 break;
13237               default:
13238                 if (ISSPACE(*str)) break;
13239                 continue;
13240             }
13241             break;
13242         }
13243         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13244         if (!len) break;
13245         if (*str != ':') continue;
13246 
13247         do str++; while (--len > 0 && ISSPACE(*str));
13248         if (!len) break;
13249         if (*str == '"') {
13250             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13251                 if (*str == '\\') {
13252                     --len;
13253                     ++str;
13254                 }
13255             }
13256             vend = str;
13257             if (len) {
13258                 --len;
13259                 ++str;
13260             }
13261         }
13262         else {
13263             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13264             vend = str;
13265         }
13266         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13267 
13268         n = end - beg;
13269         str_copy(name, beg, n);
13270         s = RSTRING_PTR(name);
13271         for (i = 0; i < n; ++i) {
13272             if (s[i] == '-') s[i] = '_';
13273         }
13274 #ifndef RIPPER
13275         do {
13276             if (STRNCASECMP(p->name, s, n) == 0) {
13277                 n = vend - vbeg;
13278                 if (p->length) {
13279                     n = (*p->length)(parser, vbeg, n);
13280                 }
13281                 str_copy(val, vbeg, n);
13282                 (*p->func)(parser, s, RSTRING_PTR(val));
13283                 break;
13284             }
13285         } while (++p < magic_comments + numberof(magic_comments));
13286 #else
13287         str_copy(val, vbeg, vend - vbeg);
13288         dispatch2(magic_comment, name, val);
13289 #endif
13290     }
13291 
13292     return TRUE;
13293 }
13294 
13295 static void
13296 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13297 {
13298     int sep = 0;
13299     const char *beg = str;
13300     VALUE s;
13301 
13302     for (;;) {
13303         if (send - str <= 6) return;
13304         switch (str[6]) {
13305           case 'C': case 'c': str += 6; continue;
13306           case 'O': case 'o': str += 5; continue;
13307           case 'D': case 'd': str += 4; continue;
13308           case 'I': case 'i': str += 3; continue;
13309           case 'N': case 'n': str += 2; continue;
13310           case 'G': case 'g': str += 1; continue;
13311           case '=': case ':':
13312             sep = 1;
13313             str += 6;
13314             break;
13315           default:
13316             str += 6;
13317             if (ISSPACE(*str)) break;
13318             continue;
13319         }
13320         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13321     }
13322     for (;;) {
13323         do {
13324             if (++str >= send) return;
13325         } while (ISSPACE(*str));
13326         if (sep) break;
13327         if (*str != '=' && *str != ':') return;
13328         sep = 1;
13329         str++;
13330     }
13331     beg = str;
13332     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13333     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13334     parser_set_encode(parser, RSTRING_PTR(s));
13335     rb_str_resize(s, 0);
13336 }
13337 
13338 static void
13339 parser_prepare(struct parser_params *parser)
13340 {
13341     int c = nextc();
13342     switch (c) {
13343       case '#':
13344         if (peek('!')) parser->has_shebang = 1;
13345         break;
13346       case 0xef:                /* UTF-8 BOM marker */
13347         if (lex_pend - lex_p >= 2 &&
13348             (unsigned char)lex_p[0] == 0xbb &&
13349             (unsigned char)lex_p[1] == 0xbf) {
13350             parser->enc = rb_utf8_encoding();
13351             lex_p += 2;
13352             lex_pbeg = lex_p;
13353             return;
13354         }
13355         break;
13356       case EOF:
13357         return;
13358     }
13359     pushback(c);
13360     parser->enc = rb_enc_get(lex_lastline);
13361 }
13362 
13363 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13364 #define IS_END() IS_lex_state(EXPR_END_ANY)
13365 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13366 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13367 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13368 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13369 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13370 
13371 #ifndef RIPPER
13372 #define ambiguous_operator(op, syn) ( \
13373     rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13374     rb_warning0("even though it seems like "syn""))
13375 #else
13376 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13377 #endif
13378 #define warn_balanced(op, syn) ((void) \
13379     (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13380      space_seen && !ISSPACE(c) && \
13381      (ambiguous_operator(op, syn), 0)))
13382 
13383 static int
13384 parser_yylex(struct parser_params *parser)
13385 {
13386     register int c;
13387     int space_seen = 0;
13388     int cmd_state;
13389     enum lex_state_e last_state;
13390     rb_encoding *enc;
13391     int mb;
13392 #ifdef RIPPER
13393     int fallthru = FALSE;
13394 #endif
13395 
13396     if (lex_strterm) {
13397         int token;
13398         if (nd_type(lex_strterm) == NODE_HEREDOC) {
13399             token = here_document(lex_strterm);
13400             if (token == tSTRING_END) {
13401                 lex_strterm = 0;
13402                 lex_state = EXPR_END;
13403             }
13404         }
13405         else {
13406             token = parse_string(lex_strterm);
13407             if (token == tSTRING_END || token == tREGEXP_END) {
13408                 rb_gc_force_recycle((VALUE)lex_strterm);
13409                 lex_strterm = 0;
13410                 lex_state = EXPR_END;
13411             }
13412         }
13413         return token;
13414     }
13415     cmd_state = command_start;
13416     command_start = FALSE;
13417   retry:
13418     last_state = lex_state;
13419     switch (c = nextc()) {
13420       case '\0':                /* NUL */
13421       case '\004':              /* ^D */
13422       case '\032':              /* ^Z */
13423       case -1:                  /* end of script. */
13424         return 0;
13425 
13426         /* white spaces */
13427       case ' ': case '\t': case '\f': case '\r':
13428       case '\13': /* '\v' */
13429         space_seen = 1;
13430 #ifdef RIPPER
13431         while ((c = nextc())) {
13432             switch (c) {
13433               case ' ': case '\t': case '\f': case '\r':
13434               case '\13': /* '\v' */
13435                 break;
13436               default:
13437                 goto outofloop;
13438             }
13439         }
13440       outofloop:
13441         pushback(c);
13442         ripper_dispatch_scan_event(parser, tSP);
13443 #endif
13444         goto retry;
13445 
13446       case '#':         /* it's a comment */
13447         /* no magic_comment in shebang line */
13448         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13449             if (comment_at_top(parser)) {
13450                 set_file_encoding(parser, lex_p, lex_pend);
13451             }
13452         }
13453         lex_p = lex_pend;
13454 #ifdef RIPPER
13455         ripper_dispatch_scan_event(parser, tCOMMENT);
13456         fallthru = TRUE;
13457 #endif
13458         /* fall through */
13459       case '\n':
13460         if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13461 #ifdef RIPPER
13462             if (!fallthru) {
13463                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
13464             }
13465             fallthru = FALSE;
13466 #endif
13467             goto retry;
13468         }
13469         while ((c = nextc())) {
13470             switch (c) {
13471               case ' ': case '\t': case '\f': case '\r':
13472               case '\13': /* '\v' */
13473                 space_seen = 1;
13474                 break;
13475               case '.': {
13476                   if ((c = nextc()) != '.') {
13477                       pushback(c);
13478                       pushback('.');
13479                       goto retry;
13480                   }
13481               }
13482               default:
13483                 --ruby_sourceline;
13484                 lex_nextline = lex_lastline;
13485               case -1:          /* EOF no decrement*/
13486                 lex_goto_eol(parser);
13487 #ifdef RIPPER
13488                 if (c != -1) {
13489                     parser->tokp = lex_p;
13490                 }
13491 #endif
13492                 goto normal_newline;
13493             }
13494         }
13495       normal_newline:
13496         command_start = TRUE;
13497         lex_state = EXPR_BEG;
13498         return '\n';
13499 
13500       case '*':
13501         if ((c = nextc()) == '*') {
13502             if ((c = nextc()) == '=') {
13503                 set_yylval_id(tPOW);
13504                 lex_state = EXPR_BEG;
13505                 return tOP_ASGN;
13506             }
13507             pushback(c);
13508             if (IS_SPCARG(c)) {
13509                 rb_warning0("`**' interpreted as argument prefix");
13510                 c = tDSTAR;
13511             }
13512             else if (IS_BEG()) {
13513                 c = tDSTAR;
13514             }
13515             else {
13516                 warn_balanced("**", "argument prefix");
13517                 c = tPOW;
13518             }
13519         }
13520         else {
13521             if (c == '=') {
13522                 set_yylval_id('*');
13523                 lex_state = EXPR_BEG;
13524                 return tOP_ASGN;
13525             }
13526             pushback(c);
13527             if (IS_SPCARG(c)) {
13528                 rb_warning0("`*' interpreted as argument prefix");
13529                 c = tSTAR;
13530             }
13531             else if (IS_BEG()) {
13532                 c = tSTAR;
13533             }
13534             else {
13535                 warn_balanced("*", "argument prefix");
13536                 c = '*';
13537             }
13538         }
13539         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13540         return c;
13541 
13542       case '!':
13543         c = nextc();
13544         if (IS_AFTER_OPERATOR()) {
13545             lex_state = EXPR_ARG;
13546             if (c == '@') {
13547                 return '!';
13548             }
13549         }
13550         else {
13551             lex_state = EXPR_BEG;
13552         }
13553         if (c == '=') {
13554             return tNEQ;
13555         }
13556         if (c == '~') {
13557             return tNMATCH;
13558         }
13559         pushback(c);
13560         return '!';
13561 
13562       case '=':
13563         if (was_bol()) {
13564             /* skip embedded rd document */
13565             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13566 #ifdef RIPPER
13567                 int first_p = TRUE;
13568 
13569                 lex_goto_eol(parser);
13570                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13571 #endif
13572                 for (;;) {
13573                     lex_goto_eol(parser);
13574 #ifdef RIPPER
13575                     if (!first_p) {
13576                         ripper_dispatch_scan_event(parser, tEMBDOC);
13577                     }
13578                     first_p = FALSE;
13579 #endif
13580                     c = nextc();
13581                     if (c == -1) {
13582                         compile_error(PARSER_ARG "embedded document meets end of file");
13583                         return 0;
13584                     }
13585                     if (c != '=') continue;
13586                     if (strncmp(lex_p, "end", 3) == 0 &&
13587                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13588                         break;
13589                     }
13590                 }
13591                 lex_goto_eol(parser);
13592 #ifdef RIPPER
13593                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
13594 #endif
13595                 goto retry;
13596             }
13597         }
13598 
13599         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13600         if ((c = nextc()) == '=') {
13601             if ((c = nextc()) == '=') {
13602                 return tEQQ;
13603             }
13604             pushback(c);
13605             return tEQ;
13606         }
13607         if (c == '~') {
13608             return tMATCH;
13609         }
13610         else if (c == '>') {
13611             return tASSOC;
13612         }
13613         pushback(c);
13614         return '=';
13615 
13616       case '<':
13617         last_state = lex_state;
13618         c = nextc();
13619         if (c == '<' &&
13620             !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13621             !IS_END() &&
13622             (!IS_ARG() || space_seen)) {
13623             int token = heredoc_identifier();
13624             if (token) return token;
13625         }
13626         if (IS_AFTER_OPERATOR()) {
13627             lex_state = EXPR_ARG;
13628         }
13629         else {
13630             if (IS_lex_state(EXPR_CLASS))
13631                 command_start = TRUE;
13632             lex_state = EXPR_BEG;
13633         }
13634         if (c == '=') {
13635             if ((c = nextc()) == '>') {
13636                 return tCMP;
13637             }
13638             pushback(c);
13639             return tLEQ;
13640         }
13641         if (c == '<') {
13642             if ((c = nextc()) == '=') {
13643                 set_yylval_id(tLSHFT);
13644                 lex_state = EXPR_BEG;
13645                 return tOP_ASGN;
13646             }
13647             pushback(c);
13648             warn_balanced("<<", "here document");
13649             return tLSHFT;
13650         }
13651         pushback(c);
13652         return '<';
13653 
13654       case '>':
13655         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13656         if ((c = nextc()) == '=') {
13657             return tGEQ;
13658         }
13659         if (c == '>') {
13660             if ((c = nextc()) == '=') {
13661                 set_yylval_id(tRSHFT);
13662                 lex_state = EXPR_BEG;
13663                 return tOP_ASGN;
13664             }
13665             pushback(c);
13666             return tRSHFT;
13667         }
13668         pushback(c);
13669         return '>';
13670 
13671       case '"':
13672         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13673         return tSTRING_BEG;
13674 
13675       case '`':
13676         if (IS_lex_state(EXPR_FNAME)) {
13677             lex_state = EXPR_ENDFN;
13678             return c;
13679         }
13680         if (IS_lex_state(EXPR_DOT)) {
13681             if (cmd_state)
13682                 lex_state = EXPR_CMDARG;
13683             else
13684                 lex_state = EXPR_ARG;
13685             return c;
13686         }
13687         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13688         return tXSTRING_BEG;
13689 
13690       case '\'':
13691         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13692         return tSTRING_BEG;
13693 
13694       case '?':
13695         if (IS_END()) {
13696             lex_state = EXPR_VALUE;
13697             return '?';
13698         }
13699         c = nextc();
13700         if (c == -1) {
13701             compile_error(PARSER_ARG "incomplete character syntax");
13702             return 0;
13703         }
13704         if (rb_enc_isspace(c, current_enc)) {
13705             if (!IS_ARG()) {
13706                 int c2 = 0;
13707                 switch (c) {
13708                   case ' ':
13709                     c2 = 's';
13710                     break;
13711                   case '\n':
13712                     c2 = 'n';
13713                     break;
13714                   case '\t':
13715                     c2 = 't';
13716                     break;
13717                   case '\v':
13718                     c2 = 'v';
13719                     break;
13720                   case '\r':
13721                     c2 = 'r';
13722                     break;
13723                   case '\f':
13724                     c2 = 'f';
13725                     break;
13726                 }
13727                 if (c2) {
13728                     rb_warnI("invalid character syntax; use ?\\%c", c2);
13729                 }
13730             }
13731           ternary:
13732             pushback(c);
13733             lex_state = EXPR_VALUE;
13734             return '?';
13735         }
13736         newtok();
13737         enc = current_enc;
13738         if (!parser_isascii()) {
13739             if (tokadd_mbchar(c) == -1) return 0;
13740         }
13741         else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13742                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13743             goto ternary;
13744         }
13745         else if (c == '\\') {
13746             if (peek('u')) {
13747                 nextc();
13748                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13749                 if (0x80 <= c) {
13750                     tokaddmbc(c, enc);
13751                 }
13752                 else {
13753                     tokadd(c);
13754                 }
13755             }
13756             else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13757                 nextc();
13758                 if (tokadd_mbchar(c) == -1) return 0;
13759             }
13760             else {
13761                 c = read_escape(0, &enc);
13762                 tokadd(c);
13763             }
13764         }
13765         else {
13766             tokadd(c);
13767         }
13768         tokfix();
13769         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13770         lex_state = EXPR_END;
13771         return tCHAR;
13772 
13773       case '&':
13774         if ((c = nextc()) == '&') {
13775             lex_state = EXPR_BEG;
13776             if ((c = nextc()) == '=') {
13777                 set_yylval_id(tANDOP);
13778                 lex_state = EXPR_BEG;
13779                 return tOP_ASGN;
13780             }
13781             pushback(c);
13782             return tANDOP;
13783         }
13784         else if (c == '=') {
13785             set_yylval_id('&');
13786             lex_state = EXPR_BEG;
13787             return tOP_ASGN;
13788         }
13789         pushback(c);
13790         if (IS_SPCARG(c)) {
13791             rb_warning0("`&' interpreted as argument prefix");
13792             c = tAMPER;
13793         }
13794         else if (IS_BEG()) {
13795             c = tAMPER;
13796         }
13797         else {
13798             warn_balanced("&", "argument prefix");
13799             c = '&';
13800         }
13801         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13802         return c;
13803 
13804       case '|':
13805         if ((c = nextc()) == '|') {
13806             lex_state = EXPR_BEG;
13807             if ((c = nextc()) == '=') {
13808                 set_yylval_id(tOROP);
13809                 lex_state = EXPR_BEG;
13810                 return tOP_ASGN;
13811             }
13812             pushback(c);
13813             return tOROP;
13814         }
13815         if (c == '=') {
13816             set_yylval_id('|');
13817             lex_state = EXPR_BEG;
13818             return tOP_ASGN;
13819         }
13820         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13821         pushback(c);
13822         return '|';
13823 
13824       case '+':
13825         c = nextc();
13826         if (IS_AFTER_OPERATOR()) {
13827             lex_state = EXPR_ARG;
13828             if (c == '@') {
13829                 return tUPLUS;
13830             }
13831             pushback(c);
13832             return '+';
13833         }
13834         if (c == '=') {
13835             set_yylval_id('+');
13836             lex_state = EXPR_BEG;
13837             return tOP_ASGN;
13838         }
13839         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13840             lex_state = EXPR_BEG;
13841             pushback(c);
13842             if (c != -1 && ISDIGIT(c)) {
13843                 c = '+';
13844                 goto start_num;
13845             }
13846             return tUPLUS;
13847         }
13848         lex_state = EXPR_BEG;
13849         pushback(c);
13850         warn_balanced("+", "unary operator");
13851         return '+';
13852 
13853       case '-':
13854         c = nextc();
13855         if (IS_AFTER_OPERATOR()) {
13856             lex_state = EXPR_ARG;
13857             if (c == '@') {
13858                 return tUMINUS;
13859             }
13860             pushback(c);
13861             return '-';
13862         }
13863         if (c == '=') {
13864             set_yylval_id('-');
13865             lex_state = EXPR_BEG;
13866             return tOP_ASGN;
13867         }
13868         if (c == '>') {
13869             lex_state = EXPR_ENDFN;
13870             return tLAMBDA;
13871         }
13872         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13873             lex_state = EXPR_BEG;
13874             pushback(c);
13875             if (c != -1 && ISDIGIT(c)) {
13876                 return tUMINUS_NUM;
13877             }
13878             return tUMINUS;
13879         }
13880         lex_state = EXPR_BEG;
13881         pushback(c);
13882         warn_balanced("-", "unary operator");
13883         return '-';
13884 
13885       case '.':
13886         lex_state = EXPR_BEG;
13887         if ((c = nextc()) == '.') {
13888             if ((c = nextc()) == '.') {
13889                 return tDOT3;
13890             }
13891             pushback(c);
13892             return tDOT2;
13893         }
13894         pushback(c);
13895         if (c != -1 && ISDIGIT(c)) {
13896             yyerror("no .<digit> floating literal anymore; put 0 before dot");
13897         }
13898         lex_state = EXPR_DOT;
13899         return '.';
13900 
13901       start_num:
13902       case '0': case '1': case '2': case '3': case '4':
13903       case '5': case '6': case '7': case '8': case '9':
13904         {
13905             int is_float, seen_point, seen_e, nondigit;
13906 
13907             is_float = seen_point = seen_e = nondigit = 0;
13908             lex_state = EXPR_END;
13909             newtok();
13910             if (c == '-' || c == '+') {
13911                 tokadd(c);
13912                 c = nextc();
13913             }
13914             if (c == '0') {
13915 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13916                 int start = toklen();
13917                 c = nextc();
13918                 if (c == 'x' || c == 'X') {
13919                     /* hexadecimal */
13920                     c = nextc();
13921                     if (c != -1 && ISXDIGIT(c)) {
13922                         do {
13923                             if (c == '_') {
13924                                 if (nondigit) break;
13925                                 nondigit = c;
13926                                 continue;
13927                             }
13928                             if (!ISXDIGIT(c)) break;
13929                             nondigit = 0;
13930                             tokadd(c);
13931                         } while ((c = nextc()) != -1);
13932                     }
13933                     pushback(c);
13934                     tokfix();
13935                     if (toklen() == start) {
13936                         no_digits();
13937                     }
13938                     else if (nondigit) goto trailing_uc;
13939                     set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
13940                     return tINTEGER;
13941                 }
13942                 if (c == 'b' || c == 'B') {
13943                     /* binary */
13944                     c = nextc();
13945                     if (c == '0' || c == '1') {
13946                         do {
13947                             if (c == '_') {
13948                                 if (nondigit) break;
13949                                 nondigit = c;
13950                                 continue;
13951                             }
13952                             if (c != '0' && c != '1') break;
13953                             nondigit = 0;
13954                             tokadd(c);
13955                         } while ((c = nextc()) != -1);
13956                     }
13957                     pushback(c);
13958                     tokfix();
13959                     if (toklen() == start) {
13960                         no_digits();
13961                     }
13962                     else if (nondigit) goto trailing_uc;
13963                     set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
13964                     return tINTEGER;
13965                 }
13966                 if (c == 'd' || c == 'D') {
13967                     /* decimal */
13968                     c = nextc();
13969                     if (c != -1 && ISDIGIT(c)) {
13970                         do {
13971                             if (c == '_') {
13972                                 if (nondigit) break;
13973                                 nondigit = c;
13974                                 continue;
13975                             }
13976                             if (!ISDIGIT(c)) break;
13977                             nondigit = 0;
13978                             tokadd(c);
13979                         } while ((c = nextc()) != -1);
13980                     }
13981                     pushback(c);
13982                     tokfix();
13983                     if (toklen() == start) {
13984                         no_digits();
13985                     }
13986                     else if (nondigit) goto trailing_uc;
13987                     set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13988                     return tINTEGER;
13989                 }
13990                 if (c == '_') {
13991                     /* 0_0 */
13992                     goto octal_number;
13993                 }
13994                 if (c == 'o' || c == 'O') {
13995                     /* prefixed octal */
13996                     c = nextc();
13997                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
13998                         no_digits();
13999                     }
14000                 }
14001                 if (c >= '0' && c <= '7') {
14002                     /* octal */
14003                   octal_number:
14004                     do {
14005                         if (c == '_') {
14006                             if (nondigit) break;
14007                             nondigit = c;
14008                             continue;
14009                         }
14010                         if (c < '0' || c > '9') break;
14011                         if (c > '7') goto invalid_octal;
14012                         nondigit = 0;
14013                         tokadd(c);
14014                     } while ((c = nextc()) != -1);
14015                     if (toklen() > start) {
14016                         pushback(c);
14017                         tokfix();
14018                         if (nondigit) goto trailing_uc;
14019                         set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
14020                         return tINTEGER;
14021                     }
14022                     if (nondigit) {
14023                         pushback(c);
14024                         goto trailing_uc;
14025                     }
14026                 }
14027                 if (c > '7' && c <= '9') {
14028                   invalid_octal:
14029                     yyerror("Invalid octal digit");
14030                 }
14031                 else if (c == '.' || c == 'e' || c == 'E') {
14032                     tokadd('0');
14033                 }
14034                 else {
14035                     pushback(c);
14036                     set_yylval_literal(INT2FIX(0));
14037                     return tINTEGER;
14038                 }
14039             }
14040 
14041             for (;;) {
14042                 switch (c) {
14043                   case '0': case '1': case '2': case '3': case '4':
14044                   case '5': case '6': case '7': case '8': case '9':
14045                     nondigit = 0;
14046                     tokadd(c);
14047                     break;
14048 
14049                   case '.':
14050                     if (nondigit) goto trailing_uc;
14051                     if (seen_point || seen_e) {
14052                         goto decode_num;
14053                     }
14054                     else {
14055                         int c0 = nextc();
14056                         if (c0 == -1 || !ISDIGIT(c0)) {
14057                             pushback(c0);
14058                             goto decode_num;
14059                         }
14060                         c = c0;
14061                     }
14062                     tokadd('.');
14063                     tokadd(c);
14064                     is_float++;
14065                     seen_point++;
14066                     nondigit = 0;
14067                     break;
14068 
14069                   case 'e':
14070                   case 'E':
14071                     if (nondigit) {
14072                         pushback(c);
14073                         c = nondigit;
14074                         goto decode_num;
14075                     }
14076                     if (seen_e) {
14077                         goto decode_num;
14078                     }
14079                     tokadd(c);
14080                     seen_e++;
14081                     is_float++;
14082                     nondigit = c;
14083                     c = nextc();
14084                     if (c != '-' && c != '+') continue;
14085                     tokadd(c);
14086                     nondigit = c;
14087                     break;
14088 
14089                   case '_':     /* `_' in number just ignored */
14090                     if (nondigit) goto decode_num;
14091                     nondigit = c;
14092                     break;
14093 
14094                   default:
14095                     goto decode_num;
14096                 }
14097                 c = nextc();
14098             }
14099 
14100           decode_num:
14101             pushback(c);
14102             if (nondigit) {
14103                 char tmp[30];
14104               trailing_uc:
14105                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14106                 yyerror(tmp);
14107             }
14108             tokfix();
14109             if (is_float) {
14110                 double d = strtod(tok(), 0);
14111                 if (errno == ERANGE) {
14112                     rb_warningS("Float %s out of range", tok());
14113                     errno = 0;
14114                 }
14115                 set_yylval_literal(DBL2NUM(d));
14116                 return tFLOAT;
14117             }
14118             set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
14119             return tINTEGER;
14120         }
14121 
14122       case ')':
14123       case ']':
14124         paren_nest--;
14125       case '}':
14126         COND_LEXPOP();
14127         CMDARG_LEXPOP();
14128         if (c == ')')
14129             lex_state = EXPR_ENDFN;
14130         else
14131             lex_state = EXPR_ENDARG;
14132         if (c == '}') {
14133             if (!brace_nest--) c = tSTRING_DEND;
14134         }
14135         return c;
14136 
14137       case ':':
14138         c = nextc();
14139         if (c == ':') {
14140             if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14141                 lex_state = EXPR_BEG;
14142                 return tCOLON3;
14143             }
14144             lex_state = EXPR_DOT;
14145             return tCOLON2;
14146         }
14147         if (IS_END() || ISSPACE(c)) {
14148             pushback(c);
14149             warn_balanced(":", "symbol literal");
14150             lex_state = EXPR_BEG;
14151             return ':';
14152         }
14153         switch (c) {
14154           case '\'':
14155             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14156             break;
14157           case '"':
14158             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14159             break;
14160           default:
14161             pushback(c);
14162             break;
14163         }
14164         lex_state = EXPR_FNAME;
14165         return tSYMBEG;
14166 
14167       case '/':
14168         if (IS_lex_state(EXPR_BEG_ANY)) {
14169             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14170             return tREGEXP_BEG;
14171         }
14172         if ((c = nextc()) == '=') {
14173             set_yylval_id('/');
14174             lex_state = EXPR_BEG;
14175             return tOP_ASGN;
14176         }
14177         pushback(c);
14178         if (IS_SPCARG(c)) {
14179             (void)arg_ambiguous();
14180             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14181             return tREGEXP_BEG;
14182         }
14183         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14184         warn_balanced("/", "regexp literal");
14185         return '/';
14186 
14187       case '^':
14188         if ((c = nextc()) == '=') {
14189             set_yylval_id('^');
14190             lex_state = EXPR_BEG;
14191             return tOP_ASGN;
14192         }
14193         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14194         pushback(c);
14195         return '^';
14196 
14197       case ';':
14198         lex_state = EXPR_BEG;
14199         command_start = TRUE;
14200         return ';';
14201 
14202       case ',':
14203         lex_state = EXPR_BEG;
14204         return ',';
14205 
14206       case '~':
14207         if (IS_AFTER_OPERATOR()) {
14208             if ((c = nextc()) != '@') {
14209                 pushback(c);
14210             }
14211             lex_state = EXPR_ARG;
14212         }
14213         else {
14214             lex_state = EXPR_BEG;
14215         }
14216         return '~';
14217 
14218       case '(':
14219         if (IS_BEG()) {
14220             c = tLPAREN;
14221         }
14222         else if (IS_SPCARG(-1)) {
14223             c = tLPAREN_ARG;
14224         }
14225         paren_nest++;
14226         COND_PUSH(0);
14227         CMDARG_PUSH(0);
14228         lex_state = EXPR_BEG;
14229         return c;
14230 
14231       case '[':
14232         paren_nest++;
14233         if (IS_AFTER_OPERATOR()) {
14234             lex_state = EXPR_ARG;
14235             if ((c = nextc()) == ']') {
14236                 if ((c = nextc()) == '=') {
14237                     return tASET;
14238                 }
14239                 pushback(c);
14240                 return tAREF;
14241             }
14242             pushback(c);
14243             return '[';
14244         }
14245         else if (IS_BEG()) {
14246             c = tLBRACK;
14247         }
14248         else if (IS_ARG() && space_seen) {
14249             c = tLBRACK;
14250         }
14251         lex_state = EXPR_BEG;
14252         COND_PUSH(0);
14253         CMDARG_PUSH(0);
14254         return c;
14255 
14256       case '{':
14257         ++brace_nest;
14258         if (lpar_beg && lpar_beg == paren_nest) {
14259             lex_state = EXPR_BEG;
14260             lpar_beg = 0;
14261             --paren_nest;
14262             COND_PUSH(0);
14263             CMDARG_PUSH(0);
14264             return tLAMBEG;
14265         }
14266         if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14267             c = '{';          /* block (primary) */
14268         else if (IS_lex_state(EXPR_ENDARG))
14269             c = tLBRACE_ARG;  /* block (expr) */
14270         else
14271             c = tLBRACE;      /* hash */
14272         COND_PUSH(0);
14273         CMDARG_PUSH(0);
14274         lex_state = EXPR_BEG;
14275         if (c != tLBRACE) command_start = TRUE;
14276         return c;
14277 
14278       case '\\':
14279         c = nextc();
14280         if (c == '\n') {
14281             space_seen = 1;
14282 #ifdef RIPPER
14283             ripper_dispatch_scan_event(parser, tSP);
14284 #endif
14285             goto retry; /* skip \\n */
14286         }
14287         pushback(c);
14288         return '\\';
14289 
14290       case '%':
14291         if (IS_lex_state(EXPR_BEG_ANY)) {
14292             int term;
14293             int paren;
14294 
14295             c = nextc();
14296           quotation:
14297             if (c == -1 || !ISALNUM(c)) {
14298                 term = c;
14299                 c = 'Q';
14300             }
14301             else {
14302                 term = nextc();
14303                 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14304                     yyerror("unknown type of %string");
14305                     return 0;
14306                 }
14307             }
14308             if (c == -1 || term == -1) {
14309                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14310                 return 0;
14311             }
14312             paren = term;
14313             if (term == '(') term = ')';
14314             else if (term == '[') term = ']';
14315             else if (term == '{') term = '}';
14316             else if (term == '<') term = '>';
14317             else paren = 0;
14318 
14319             switch (c) {
14320               case 'Q':
14321                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14322                 return tSTRING_BEG;
14323 
14324               case 'q':
14325                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
14326                 return tSTRING_BEG;
14327 
14328               case 'W':
14329                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14330                 do {c = nextc();} while (ISSPACE(c));
14331                 pushback(c);
14332                 return tWORDS_BEG;
14333 
14334               case 'w':
14335                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14336                 do {c = nextc();} while (ISSPACE(c));
14337                 pushback(c);
14338                 return tQWORDS_BEG;
14339 
14340               case 'I':
14341                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14342                 do {c = nextc();} while (ISSPACE(c));
14343                 pushback(c);
14344                 return tSYMBOLS_BEG;
14345 
14346               case 'i':
14347                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14348                 do {c = nextc();} while (ISSPACE(c));
14349                 pushback(c);
14350                 return tQSYMBOLS_BEG;
14351 
14352               case 'x':
14353                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14354                 return tXSTRING_BEG;
14355 
14356               case 'r':
14357                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14358                 return tREGEXP_BEG;
14359 
14360               case 's':
14361                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14362                 lex_state = EXPR_FNAME;
14363                 return tSYMBEG;
14364 
14365               default:
14366                 yyerror("unknown type of %string");
14367                 return 0;
14368             }
14369         }
14370         if ((c = nextc()) == '=') {
14371             set_yylval_id('%');
14372             lex_state = EXPR_BEG;
14373             return tOP_ASGN;
14374         }
14375         if (IS_SPCARG(c)) {
14376             goto quotation;
14377         }
14378         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14379         pushback(c);
14380         warn_balanced("%%", "string literal");
14381         return '%';
14382 
14383       case '$':
14384         lex_state = EXPR_END;
14385         newtok();
14386         c = nextc();
14387         switch (c) {
14388           case '_':             /* $_: last read line string */
14389             c = nextc();
14390             if (parser_is_identchar()) {
14391                 tokadd('$');
14392                 tokadd('_');
14393                 break;
14394             }
14395             pushback(c);
14396             c = '_';
14397             /* fall through */
14398           case '~':             /* $~: match-data */
14399           case '*':             /* $*: argv */
14400           case '$':             /* $$: pid */
14401           case '?':             /* $?: last status */
14402           case '!':             /* $!: error string */
14403           case '@':             /* $@: error position */
14404           case '/':             /* $/: input record separator */
14405           case '\\':            /* $\: output record separator */
14406           case ';':             /* $;: field separator */
14407           case ',':             /* $,: output field separator */
14408           case '.':             /* $.: last read line number */
14409           case '=':             /* $=: ignorecase */
14410           case ':':             /* $:: load path */
14411           case '<':             /* $<: reading filename */
14412           case '>':             /* $>: default output handle */
14413           case '\"':            /* $": already loaded files */
14414             tokadd('$');
14415             tokadd(c);
14416             tokfix();
14417             set_yylval_name(rb_intern(tok()));
14418             return tGVAR;
14419 
14420           case '-':
14421             tokadd('$');
14422             tokadd(c);
14423             c = nextc();
14424             if (parser_is_identchar()) {
14425                 if (tokadd_mbchar(c) == -1) return 0;
14426             }
14427             else {
14428                 pushback(c);
14429             }
14430           gvar:
14431             tokfix();
14432             set_yylval_name(rb_intern(tok()));
14433             return tGVAR;
14434 
14435           case '&':             /* $&: last match */
14436           case '`':             /* $`: string before last match */
14437           case '\'':            /* $': string after last match */
14438           case '+':             /* $+: string matches last paren. */
14439             if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14440                 tokadd('$');
14441                 tokadd(c);
14442                 goto gvar;
14443             }
14444             set_yylval_node(NEW_BACK_REF(c));
14445             return tBACK_REF;
14446 
14447           case '1': case '2': case '3':
14448           case '4': case '5': case '6':
14449           case '7': case '8': case '9':
14450             tokadd('$');
14451             do {
14452                 tokadd(c);
14453                 c = nextc();
14454             } while (c != -1 && ISDIGIT(c));
14455             pushback(c);
14456             if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14457             tokfix();
14458             set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14459             return tNTH_REF;
14460 
14461           default:
14462             if (!parser_is_identchar()) {
14463                 pushback(c);
14464                 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14465                 return 0;
14466             }
14467           case '0':
14468             tokadd('$');
14469         }
14470         break;
14471 
14472       case '@':
14473         c = nextc();
14474         newtok();
14475         tokadd('@');
14476         if (c == '@') {
14477             tokadd('@');
14478             c = nextc();
14479         }
14480         if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14481             pushback(c);
14482             if (tokidx == 1) {
14483                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14484             }
14485             else {
14486                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14487             }
14488             return 0;
14489         }
14490         break;
14491 
14492       case '_':
14493         if (was_bol() && whole_match_p("__END__", 7, 0)) {
14494             ruby__end__seen = 1;
14495             parser->eofp = Qtrue;
14496 #ifndef RIPPER
14497             return -1;
14498 #else
14499             lex_goto_eol(parser);
14500             ripper_dispatch_scan_event(parser, k__END__);
14501             return 0;
14502 #endif
14503         }
14504         newtok();
14505         break;
14506 
14507       default:
14508         if (!parser_is_identchar()) {
14509             compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
14510             goto retry;
14511         }
14512 
14513         newtok();
14514         break;
14515     }
14516 
14517     mb = ENC_CODERANGE_7BIT;
14518     do {
14519         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14520         if (tokadd_mbchar(c) == -1) return 0;
14521         c = nextc();
14522     } while (parser_is_identchar());
14523     switch (tok()[0]) {
14524       case '@': case '$':
14525         pushback(c);
14526         break;
14527       default:
14528         if ((c == '!' || c == '?') && !peek('=')) {
14529             tokadd(c);
14530         }
14531         else {
14532             pushback(c);
14533         }
14534     }
14535     tokfix();
14536 
14537     {
14538         int result = 0;
14539 
14540         last_state = lex_state;
14541         switch (tok()[0]) {
14542           case '$':
14543             lex_state = EXPR_END;
14544             result = tGVAR;
14545             break;
14546           case '@':
14547             lex_state = EXPR_END;
14548             if (tok()[1] == '@')
14549                 result = tCVAR;
14550             else
14551                 result = tIVAR;
14552             break;
14553 
14554           default:
14555             if (toklast() == '!' || toklast() == '?') {
14556                 result = tFID;
14557             }
14558             else {
14559                 if (IS_lex_state(EXPR_FNAME)) {
14560                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14561                         (!peek('=') || (peek_n('>', 1)))) {
14562                         result = tIDENTIFIER;
14563                         tokadd(c);
14564                         tokfix();
14565                     }
14566                     else {
14567                         pushback(c);
14568                     }
14569                 }
14570                 if (result == 0 && ISUPPER(tok()[0])) {
14571                     result = tCONSTANT;
14572                 }
14573                 else {
14574                     result = tIDENTIFIER;
14575                 }
14576             }
14577 
14578             if (IS_LABEL_POSSIBLE()) {
14579                 if (IS_LABEL_SUFFIX(0)) {
14580                     lex_state = EXPR_BEG;
14581                     nextc();
14582                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
14583                     return tLABEL;
14584                 }
14585             }
14586             if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14587                 const struct kwtable *kw;
14588 
14589                 /* See if it is a reserved word.  */
14590                 kw = rb_reserved_word(tok(), toklen());
14591                 if (kw) {
14592                     enum lex_state_e state = lex_state;
14593                     lex_state = kw->state;
14594                     if (state == EXPR_FNAME) {
14595                         set_yylval_name(rb_intern(kw->name));
14596                         return kw->id[0];
14597                     }
14598                     if (lex_state == EXPR_BEG) {
14599                         command_start = TRUE;
14600                     }
14601                     if (kw->id[0] == keyword_do) {
14602                         if (lpar_beg && lpar_beg == paren_nest) {
14603                             lpar_beg = 0;
14604                             --paren_nest;
14605                             return keyword_do_LAMBDA;
14606                         }
14607                         if (COND_P()) return keyword_do_cond;
14608                         if (CMDARG_P() && state != EXPR_CMDARG)
14609                             return keyword_do_block;
14610                         if (state & (EXPR_BEG | EXPR_ENDARG))
14611                             return keyword_do_block;
14612                         return keyword_do;
14613                     }
14614                     if (state & (EXPR_BEG | EXPR_VALUE))
14615                         return kw->id[0];
14616                     else {
14617                         if (kw->id[0] != kw->id[1])
14618                             lex_state = EXPR_BEG;
14619                         return kw->id[1];
14620                     }
14621                 }
14622             }
14623 
14624             if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14625                 if (cmd_state) {
14626                     lex_state = EXPR_CMDARG;
14627                 }
14628                 else {
14629                     lex_state = EXPR_ARG;
14630                 }
14631             }
14632             else if (lex_state == EXPR_FNAME) {
14633                 lex_state = EXPR_ENDFN;
14634             }
14635             else {
14636                 lex_state = EXPR_END;
14637             }
14638         }
14639         {
14640             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14641 
14642             set_yylval_name(ident);
14643             if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14644                 is_local_id(ident) && lvar_defined(ident)) {
14645                 lex_state = EXPR_END;
14646             }
14647         }
14648         return result;
14649     }
14650 }
14651 
14652 #if YYPURE
14653 static int
14654 yylex(void *lval, void *p)
14655 #else
14656 yylex(void *p)
14657 #endif
14658 {
14659     struct parser_params *parser = (struct parser_params*)p;
14660     int t;
14661 
14662 #if YYPURE
14663     parser->parser_yylval = lval;
14664     parser->parser_yylval->val = Qundef;
14665 #endif
14666     t = parser_yylex(parser);
14667 #ifdef RIPPER
14668     if (!NIL_P(parser->delayed)) {
14669         ripper_dispatch_delayed_token(parser, t);
14670         return t;
14671     }
14672     if (t != 0)
14673         ripper_dispatch_scan_event(parser, t);
14674 #endif
14675 
14676     return t;
14677 }
14678 
14679 #ifndef RIPPER
14680 static NODE*
14681 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14682 {
14683     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14684     nd_set_line(n, ruby_sourceline);
14685     return n;
14686 }
14687 
14688 static enum node_type
14689 nodetype(NODE *node)                    /* for debug */
14690 {
14691     return (enum node_type)nd_type(node);
14692 }
14693 
14694 static int
14695 nodeline(NODE *node)
14696 {
14697     return nd_line(node);
14698 }
14699 
14700 static NODE*
14701 newline_node(NODE *node)
14702 {
14703     if (node) {
14704         node = remove_begin(node);
14705         node->flags |= NODE_FL_NEWLINE;
14706     }
14707     return node;
14708 }
14709 
14710 static void
14711 fixpos(NODE *node, NODE *orig)
14712 {
14713     if (!node) return;
14714     if (!orig) return;
14715     if (orig == (NODE*)1) return;
14716     nd_set_line(node, nd_line(orig));
14717 }
14718 
14719 static void
14720 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14721 {
14722     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14723 }
14724 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14725 
14726 static void
14727 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14728 {
14729     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14730 }
14731 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14732 
14733 static NODE*
14734 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14735 {
14736     NODE *end, *h = head, *nd;
14737 
14738     if (tail == 0) return head;
14739 
14740     if (h == 0) return tail;
14741     switch (nd_type(h)) {
14742       case NODE_LIT:
14743       case NODE_STR:
14744       case NODE_SELF:
14745       case NODE_TRUE:
14746       case NODE_FALSE:
14747       case NODE_NIL:
14748         parser_warning(h, "unused literal ignored");
14749         return tail;
14750       default:
14751         h = end = NEW_BLOCK(head);
14752         end->nd_end = end;
14753         fixpos(end, head);
14754         head = end;
14755         break;
14756       case NODE_BLOCK:
14757         end = h->nd_end;
14758         break;
14759     }
14760 
14761     nd = end->nd_head;
14762     switch (nd_type(nd)) {
14763       case NODE_RETURN:
14764       case NODE_BREAK:
14765       case NODE_NEXT:
14766       case NODE_REDO:
14767       case NODE_RETRY:
14768         if (RTEST(ruby_verbose)) {
14769             parser_warning(tail, "statement not reached");
14770         }
14771         break;
14772 
14773       default:
14774         break;
14775     }
14776 
14777     if (nd_type(tail) != NODE_BLOCK) {
14778         tail = NEW_BLOCK(tail);
14779         tail->nd_end = tail;
14780     }
14781     end->nd_next = tail;
14782     h->nd_end = tail->nd_end;
14783     return head;
14784 }
14785 
14786 /* append item to the list */
14787 static NODE*
14788 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14789 {
14790     NODE *last;
14791 
14792     if (list == 0) return NEW_LIST(item);
14793     if (list->nd_next) {
14794         last = list->nd_next->nd_end;
14795     }
14796     else {
14797         last = list;
14798     }
14799 
14800     list->nd_alen += 1;
14801     last->nd_next = NEW_LIST(item);
14802     list->nd_next->nd_end = last->nd_next;
14803     return list;
14804 }
14805 
14806 /* concat two lists */
14807 static NODE*
14808 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14809 {
14810     NODE *last;
14811 
14812     if (head->nd_next) {
14813         last = head->nd_next->nd_end;
14814     }
14815     else {
14816         last = head;
14817     }
14818 
14819     head->nd_alen += tail->nd_alen;
14820     last->nd_next = tail;
14821     if (tail->nd_next) {
14822         head->nd_next->nd_end = tail->nd_next->nd_end;
14823     }
14824     else {
14825         head->nd_next->nd_end = tail;
14826     }
14827 
14828     return head;
14829 }
14830 
14831 static int
14832 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14833 {
14834     if (NIL_P(tail)) return 1;
14835     if (!rb_enc_compatible(head, tail)) {
14836         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14837                       rb_enc_name(rb_enc_get(head)),
14838                       rb_enc_name(rb_enc_get(tail)));
14839         rb_str_resize(head, 0);
14840         rb_str_resize(tail, 0);
14841         return 0;
14842     }
14843     rb_str_buf_append(head, tail);
14844     return 1;
14845 }
14846 
14847 /* concat two string literals */
14848 static NODE *
14849 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14850 {
14851     enum node_type htype;
14852     NODE *headlast;
14853     VALUE lit;
14854 
14855     if (!head) return tail;
14856     if (!tail) return head;
14857 
14858     htype = nd_type(head);
14859     if (htype == NODE_EVSTR) {
14860         NODE *node = NEW_DSTR(Qnil);
14861         head = list_append(node, head);
14862         htype = NODE_DSTR;
14863     }
14864     switch (nd_type(tail)) {
14865       case NODE_STR:
14866         if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14867             nd_type(headlast) == NODE_STR) {
14868             htype = NODE_STR;
14869             lit = headlast->nd_lit;
14870         }
14871         else {
14872             lit = head->nd_lit;
14873         }
14874         if (htype == NODE_STR) {
14875             if (!literal_concat0(parser, lit, tail->nd_lit)) {
14876               error:
14877                 rb_gc_force_recycle((VALUE)head);
14878                 rb_gc_force_recycle((VALUE)tail);
14879                 return 0;
14880             }
14881             rb_gc_force_recycle((VALUE)tail);
14882         }
14883         else {
14884             list_append(head, tail);
14885         }
14886         break;
14887 
14888       case NODE_DSTR:
14889         if (htype == NODE_STR) {
14890             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14891                 goto error;
14892             tail->nd_lit = head->nd_lit;
14893             rb_gc_force_recycle((VALUE)head);
14894             head = tail;
14895         }
14896         else if (NIL_P(tail->nd_lit)) {
14897           append:
14898             head->nd_alen += tail->nd_alen - 1;
14899             head->nd_next->nd_end->nd_next = tail->nd_next;
14900             head->nd_next->nd_end = tail->nd_next->nd_end;
14901             rb_gc_force_recycle((VALUE)tail);
14902         }
14903         else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14904                  nd_type(headlast) == NODE_STR) {
14905             lit = headlast->nd_lit;
14906             if (!literal_concat0(parser, lit, tail->nd_lit))
14907                 goto error;
14908             tail->nd_lit = Qnil;
14909             goto append;
14910         }
14911         else {
14912             nd_set_type(tail, NODE_ARRAY);
14913             tail->nd_head = NEW_STR(tail->nd_lit);
14914             list_concat(head, tail);
14915         }
14916         break;
14917 
14918       case NODE_EVSTR:
14919         if (htype == NODE_STR) {
14920             nd_set_type(head, NODE_DSTR);
14921             head->nd_alen = 1;
14922         }
14923         list_append(head, tail);
14924         break;
14925     }
14926     return head;
14927 }
14928 
14929 static NODE *
14930 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14931 {
14932     if (nd_type(node) == NODE_EVSTR) {
14933         node = list_append(NEW_DSTR(Qnil), node);
14934     }
14935     return node;
14936 }
14937 
14938 static NODE *
14939 new_evstr_gen(struct parser_params *parser, NODE *node)
14940 {
14941     NODE *head = node;
14942 
14943     if (node) {
14944         switch (nd_type(node)) {
14945           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14946             return node;
14947         }
14948     }
14949     return NEW_EVSTR(head);
14950 }
14951 
14952 static NODE *
14953 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14954 {
14955     value_expr(recv);
14956     value_expr(arg1);
14957     return NEW_CALL(recv, id, NEW_LIST(arg1));
14958 }
14959 
14960 static NODE *
14961 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14962 {
14963     value_expr(recv);
14964     return NEW_CALL(recv, id, 0);
14965 }
14966 
14967 static NODE*
14968 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14969 {
14970     value_expr(node1);
14971     value_expr(node2);
14972     if (node1) {
14973         switch (nd_type(node1)) {
14974           case NODE_DREGX:
14975           case NODE_DREGX_ONCE:
14976             return NEW_MATCH2(node1, node2);
14977 
14978           case NODE_LIT:
14979             if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14980                 return NEW_MATCH2(node1, node2);
14981             }
14982         }
14983     }
14984 
14985     if (node2) {
14986         switch (nd_type(node2)) {
14987           case NODE_DREGX:
14988           case NODE_DREGX_ONCE:
14989             return NEW_MATCH3(node2, node1);
14990 
14991           case NODE_LIT:
14992             if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14993                 return NEW_MATCH3(node2, node1);
14994             }
14995         }
14996     }
14997 
14998     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14999 }
15000 
15001 static NODE*
15002 gettable_gen(struct parser_params *parser, ID id)
15003 {
15004     switch (id) {
15005       case keyword_self:
15006         return NEW_SELF();
15007       case keyword_nil:
15008         return NEW_NIL();
15009       case keyword_true:
15010         return NEW_TRUE();
15011       case keyword_false:
15012         return NEW_FALSE();
15013       case keyword__FILE__:
15014         return NEW_STR(rb_str_dup(ruby_sourcefile_string));
15015       case keyword__LINE__:
15016         return NEW_LIT(INT2FIX(tokline));
15017       case keyword__ENCODING__:
15018         return NEW_LIT(rb_enc_from_encoding(current_enc));
15019     }
15020     switch (id_type(id)) {
15021       case ID_LOCAL:
15022         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15023         if (local_id(id)) return NEW_LVAR(id);
15024         /* method call without arguments */
15025         return NEW_VCALL(id);
15026       case ID_GLOBAL:
15027         return NEW_GVAR(id);
15028       case ID_INSTANCE:
15029         return NEW_IVAR(id);
15030       case ID_CONST:
15031         return NEW_CONST(id);
15032       case ID_CLASS:
15033         return NEW_CVAR(id);
15034     }
15035     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15036     return 0;
15037 }
15038 #else  /* !RIPPER */
15039 static int
15040 id_is_var_gen(struct parser_params *parser, ID id)
15041 {
15042     if (is_notop_id(id)) {
15043         switch (id & ID_SCOPE_MASK) {
15044           case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15045             return 1;
15046           case ID_LOCAL:
15047             if (dyna_in_block() && dvar_defined(id)) return 1;
15048             if (local_id(id)) return 1;
15049             /* method call without arguments */
15050             return 0;
15051         }
15052     }
15053     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15054     return 0;
15055 }
15056 #endif /* !RIPPER */
15057 
15058 #if PARSER_DEBUG
15059 static const char *
15060 lex_state_name(enum lex_state_e state)
15061 {
15062     static const char names[][12] = {
15063         "EXPR_BEG",    "EXPR_END",    "EXPR_ENDARG", "EXPR_ENDFN",  "EXPR_ARG",
15064         "EXPR_CMDARG", "EXPR_MID",    "EXPR_FNAME",  "EXPR_DOT",    "EXPR_CLASS",
15065         "EXPR_VALUE",
15066     };
15067 
15068     if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15069         return names[ffs(state)];
15070     return NULL;
15071 }
15072 #endif
15073 
15074 #ifdef RIPPER
15075 static VALUE
15076 assignable_gen(struct parser_params *parser, VALUE lhs)
15077 #else
15078 static NODE*
15079 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15080 #endif
15081 {
15082 #ifdef RIPPER
15083     ID id = get_id(lhs);
15084 # define assignable_result(x) get_value(lhs)
15085 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15086 #else
15087 # define assignable_result(x) (x)
15088 #endif
15089     if (!id) return assignable_result(0);
15090     switch (id) {
15091       case keyword_self:
15092         yyerror("Can't change the value of self");
15093         goto error;
15094       case keyword_nil:
15095         yyerror("Can't assign to nil");
15096         goto error;
15097       case keyword_true:
15098         yyerror("Can't assign to true");
15099         goto error;
15100       case keyword_false:
15101         yyerror("Can't assign to false");
15102         goto error;
15103       case keyword__FILE__:
15104         yyerror("Can't assign to __FILE__");
15105         goto error;
15106       case keyword__LINE__:
15107         yyerror("Can't assign to __LINE__");
15108         goto error;
15109       case keyword__ENCODING__:
15110         yyerror("Can't assign to __ENCODING__");
15111         goto error;
15112     }
15113     switch (id_type(id)) {
15114       case ID_LOCAL:
15115         if (dyna_in_block()) {
15116             if (dvar_curr(id)) {
15117                 return assignable_result(NEW_DASGN_CURR(id, val));
15118             }
15119             else if (dvar_defined(id)) {
15120                 return assignable_result(NEW_DASGN(id, val));
15121             }
15122             else if (local_id(id)) {
15123                 return assignable_result(NEW_LASGN(id, val));
15124             }
15125             else {
15126                 dyna_var(id);
15127                 return assignable_result(NEW_DASGN_CURR(id, val));
15128             }
15129         }
15130         else {
15131             if (!local_id(id)) {
15132                 local_var(id);
15133             }
15134             return assignable_result(NEW_LASGN(id, val));
15135         }
15136         break;
15137       case ID_GLOBAL:
15138         return assignable_result(NEW_GASGN(id, val));
15139       case ID_INSTANCE:
15140         return assignable_result(NEW_IASGN(id, val));
15141       case ID_CONST:
15142         if (!in_def && !in_single)
15143             return assignable_result(NEW_CDECL(id, val, 0));
15144         yyerror("dynamic constant assignment");
15145         break;
15146       case ID_CLASS:
15147         return assignable_result(NEW_CVASGN(id, val));
15148       default:
15149         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15150     }
15151   error:
15152     return assignable_result(0);
15153 #undef assignable_result
15154 #undef parser_yyerror
15155 }
15156 
15157 static int
15158 is_private_local_id(ID name)
15159 {
15160     VALUE s;
15161     if (name == idUScore) return 1;
15162     if (!is_local_id(name)) return 0;
15163     s = rb_id2str(name);
15164     if (!s) return 0;
15165     return RSTRING_PTR(s)[0] == '_';
15166 }
15167 
15168 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15169 
15170 static ID
15171 shadowing_lvar_gen(struct parser_params *parser, ID name)
15172 {
15173     if (is_private_local_id(name)) return name;
15174     if (dyna_in_block()) {
15175         if (dvar_curr(name)) {
15176             yyerror("duplicated argument name");
15177         }
15178         else if (dvar_defined_get(name) || local_id(name)) {
15179             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15180             vtable_add(lvtbl->vars, name);
15181             if (lvtbl->used) {
15182                 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15183             }
15184         }
15185     }
15186     else {
15187         if (local_id(name)) {
15188             yyerror("duplicated argument name");
15189         }
15190     }
15191     return name;
15192 }
15193 
15194 static void
15195 new_bv_gen(struct parser_params *parser, ID name)
15196 {
15197     if (!name) return;
15198     if (!is_local_id(name)) {
15199         compile_error(PARSER_ARG "invalid local variable - %s",
15200                       rb_id2name(name));
15201         return;
15202     }
15203     shadowing_lvar(name);
15204     dyna_var(name);
15205 }
15206 
15207 #ifndef RIPPER
15208 static NODE *
15209 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15210 {
15211     if (recv && nd_type(recv) == NODE_SELF)
15212         recv = (NODE *)1;
15213     return NEW_ATTRASGN(recv, tASET, idx);
15214 }
15215 
15216 static void
15217 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15218 {
15219     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15220         compile_error(PARSER_ARG "both block arg and actual block given");
15221     }
15222 }
15223 
15224 static const char id_type_names[][9] = {
15225     "LOCAL",
15226     "INSTANCE",
15227     "",                         /* INSTANCE2 */
15228     "GLOBAL",
15229     "ATTRSET",
15230     "CONST",
15231     "CLASS",
15232     "JUNK",
15233 };
15234 
15235 ID
15236 rb_id_attrset(ID id)
15237 {
15238     if (!is_notop_id(id)) {
15239         switch (id) {
15240           case tAREF: case tASET:
15241             return tASET;       /* only exception */
15242         }
15243         rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15244     }
15245     else {
15246         int scope = (int)(id & ID_SCOPE_MASK);
15247         switch (scope) {
15248           case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15249           case ID_CONST: case ID_CLASS: case ID_JUNK:
15250             break;
15251           case ID_ATTRSET:
15252             return id;
15253           default:
15254             rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15255                           id_type_names[scope], ID2SYM(id));
15256 
15257         }
15258     }
15259     id &= ~ID_SCOPE_MASK;
15260     id |= ID_ATTRSET;
15261     return id;
15262 }
15263 
15264 static NODE *
15265 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15266 {
15267     if (recv && nd_type(recv) == NODE_SELF)
15268         recv = (NODE *)1;
15269     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15270 }
15271 
15272 static void
15273 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15274 {
15275     switch (nd_type(node)) {
15276       case NODE_NTH_REF:
15277         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15278         break;
15279       case NODE_BACK_REF:
15280         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15281         break;
15282     }
15283 }
15284 
15285 static NODE *
15286 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15287 {
15288     if (!node2) return node1;
15289     switch (nd_type(node1)) {
15290       case NODE_BLOCK_PASS:
15291         if (node1->nd_head)
15292             node1->nd_head = arg_concat(node1->nd_head, node2);
15293         else
15294             node1->nd_head = NEW_LIST(node2);
15295         return node1;
15296       case NODE_ARGSPUSH:
15297         if (nd_type(node2) != NODE_ARRAY) break;
15298         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15299         nd_set_type(node1, NODE_ARGSCAT);
15300         return node1;
15301       case NODE_ARGSCAT:
15302         if (nd_type(node2) != NODE_ARRAY ||
15303             nd_type(node1->nd_body) != NODE_ARRAY) break;
15304         node1->nd_body = list_concat(node1->nd_body, node2);
15305         return node1;
15306     }
15307     return NEW_ARGSCAT(node1, node2);
15308 }
15309 
15310 static NODE *
15311 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15312 {
15313     if (!node1) return NEW_LIST(node2);
15314     switch (nd_type(node1))  {
15315       case NODE_ARRAY:
15316         return list_append(node1, node2);
15317       case NODE_BLOCK_PASS:
15318         node1->nd_head = arg_append(node1->nd_head, node2);
15319         return node1;
15320       case NODE_ARGSPUSH:
15321         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15322         nd_set_type(node1, NODE_ARGSCAT);
15323         return node1;
15324     }
15325     return NEW_ARGSPUSH(node1, node2);
15326 }
15327 
15328 static NODE *
15329 splat_array(NODE* node)
15330 {
15331     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15332     if (nd_type(node) == NODE_ARRAY) return node;
15333     return 0;
15334 }
15335 
15336 static NODE *
15337 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15338 {
15339     if (!lhs) return 0;
15340 
15341     switch (nd_type(lhs)) {
15342       case NODE_GASGN:
15343       case NODE_IASGN:
15344       case NODE_IASGN2:
15345       case NODE_LASGN:
15346       case NODE_DASGN:
15347       case NODE_DASGN_CURR:
15348       case NODE_MASGN:
15349       case NODE_CDECL:
15350       case NODE_CVASGN:
15351         lhs->nd_value = rhs;
15352         break;
15353 
15354       case NODE_ATTRASGN:
15355       case NODE_CALL:
15356         lhs->nd_args = arg_append(lhs->nd_args, rhs);
15357         break;
15358 
15359       default:
15360         /* should not happen */
15361         break;
15362     }
15363 
15364     return lhs;
15365 }
15366 
15367 static int
15368 value_expr_gen(struct parser_params *parser, NODE *node)
15369 {
15370     int cond = 0;
15371 
15372     if (!node) {
15373         rb_warning0("empty expression");
15374     }
15375     while (node) {
15376         switch (nd_type(node)) {
15377           case NODE_DEFN:
15378           case NODE_DEFS:
15379             parser_warning(node, "void value expression");
15380             return FALSE;
15381 
15382           case NODE_RETURN:
15383           case NODE_BREAK:
15384           case NODE_NEXT:
15385           case NODE_REDO:
15386           case NODE_RETRY:
15387             if (!cond) yyerror("void value expression");
15388             /* or "control never reach"? */
15389             return FALSE;
15390 
15391           case NODE_BLOCK:
15392             while (node->nd_next) {
15393                 node = node->nd_next;
15394             }
15395             node = node->nd_head;
15396             break;
15397 
15398           case NODE_BEGIN:
15399             node = node->nd_body;
15400             break;
15401 
15402           case NODE_IF:
15403             if (!node->nd_body) {
15404                 node = node->nd_else;
15405                 break;
15406             }
15407             else if (!node->nd_else) {
15408                 node = node->nd_body;
15409                 break;
15410             }
15411             if (!value_expr(node->nd_body)) return FALSE;
15412             node = node->nd_else;
15413             break;
15414 
15415           case NODE_AND:
15416           case NODE_OR:
15417             cond = 1;
15418             node = node->nd_2nd;
15419             break;
15420 
15421           default:
15422             return TRUE;
15423         }
15424     }
15425 
15426     return TRUE;
15427 }
15428 
15429 static void
15430 void_expr_gen(struct parser_params *parser, NODE *node)
15431 {
15432     const char *useless = 0;
15433 
15434     if (!RTEST(ruby_verbose)) return;
15435 
15436     if (!node) return;
15437     switch (nd_type(node)) {
15438       case NODE_CALL:
15439         switch (node->nd_mid) {
15440           case '+':
15441           case '-':
15442           case '*':
15443           case '/':
15444           case '%':
15445           case tPOW:
15446           case tUPLUS:
15447           case tUMINUS:
15448           case '|':
15449           case '^':
15450           case '&':
15451           case tCMP:
15452           case '>':
15453           case tGEQ:
15454           case '<':
15455           case tLEQ:
15456           case tEQ:
15457           case tNEQ:
15458             useless = rb_id2name(node->nd_mid);
15459             break;
15460         }
15461         break;
15462 
15463       case NODE_LVAR:
15464       case NODE_DVAR:
15465       case NODE_GVAR:
15466       case NODE_IVAR:
15467       case NODE_CVAR:
15468       case NODE_NTH_REF:
15469       case NODE_BACK_REF:
15470         useless = "a variable";
15471         break;
15472       case NODE_CONST:
15473         useless = "a constant";
15474         break;
15475       case NODE_LIT:
15476       case NODE_STR:
15477       case NODE_DSTR:
15478       case NODE_DREGX:
15479       case NODE_DREGX_ONCE:
15480         useless = "a literal";
15481         break;
15482       case NODE_COLON2:
15483       case NODE_COLON3:
15484         useless = "::";
15485         break;
15486       case NODE_DOT2:
15487         useless = "..";
15488         break;
15489       case NODE_DOT3:
15490         useless = "...";
15491         break;
15492       case NODE_SELF:
15493         useless = "self";
15494         break;
15495       case NODE_NIL:
15496         useless = "nil";
15497         break;
15498       case NODE_TRUE:
15499         useless = "true";
15500         break;
15501       case NODE_FALSE:
15502         useless = "false";
15503         break;
15504       case NODE_DEFINED:
15505         useless = "defined?";
15506         break;
15507     }
15508 
15509     if (useless) {
15510         int line = ruby_sourceline;
15511 
15512         ruby_sourceline = nd_line(node);
15513         rb_warnS("possibly useless use of %s in void context", useless);
15514         ruby_sourceline = line;
15515     }
15516 }
15517 
15518 static void
15519 void_stmts_gen(struct parser_params *parser, NODE *node)
15520 {
15521     if (!RTEST(ruby_verbose)) return;
15522     if (!node) return;
15523     if (nd_type(node) != NODE_BLOCK) return;
15524 
15525     for (;;) {
15526         if (!node->nd_next) return;
15527         void_expr0(node->nd_head);
15528         node = node->nd_next;
15529     }
15530 }
15531 
15532 static NODE *
15533 remove_begin(NODE *node)
15534 {
15535     NODE **n = &node, *n1 = node;
15536     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15537         *n = n1 = n1->nd_body;
15538     }
15539     return node;
15540 }
15541 
15542 static void
15543 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15544 {
15545     NODE *node = *body;
15546 
15547     if (!node) {
15548         *body = NEW_NIL();
15549         return;
15550     }
15551 #define subnodes(n1, n2) \
15552     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15553      (!node->n2) ? (body = &node->n1, 1) : \
15554      (reduce_nodes(&node->n1), body = &node->n2, 1))
15555 
15556     while (node) {
15557         int newline = (int)(node->flags & NODE_FL_NEWLINE);
15558         switch (nd_type(node)) {
15559           end:
15560           case NODE_NIL:
15561             *body = 0;
15562             return;
15563           case NODE_RETURN:
15564             *body = node = node->nd_stts;
15565             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15566             continue;
15567           case NODE_BEGIN:
15568             *body = node = node->nd_body;
15569             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15570             continue;
15571           case NODE_BLOCK:
15572             body = &node->nd_end->nd_head;
15573             break;
15574           case NODE_IF:
15575             if (subnodes(nd_body, nd_else)) break;
15576             return;
15577           case NODE_CASE:
15578             body = &node->nd_body;
15579             break;
15580           case NODE_WHEN:
15581             if (!subnodes(nd_body, nd_next)) goto end;
15582             break;
15583           case NODE_ENSURE:
15584             if (!subnodes(nd_head, nd_resq)) goto end;
15585             break;
15586           case NODE_RESCUE:
15587             if (node->nd_else) {
15588                 body = &node->nd_resq;
15589                 break;
15590             }
15591             if (!subnodes(nd_head, nd_resq)) goto end;
15592             break;
15593           default:
15594             return;
15595         }
15596         node = *body;
15597         if (newline && node) node->flags |= NODE_FL_NEWLINE;
15598     }
15599 
15600 #undef subnodes
15601 }
15602 
15603 static int
15604 is_static_content(NODE *node)
15605 {
15606     if (!node) return 1;
15607     switch (nd_type(node)) {
15608       case NODE_HASH:
15609         if (!(node = node->nd_head)) break;
15610       case NODE_ARRAY:
15611         do {
15612             if (!is_static_content(node->nd_head)) return 0;
15613         } while ((node = node->nd_next) != 0);
15614       case NODE_LIT:
15615       case NODE_STR:
15616       case NODE_NIL:
15617       case NODE_TRUE:
15618       case NODE_FALSE:
15619       case NODE_ZARRAY:
15620         break;
15621       default:
15622         return 0;
15623     }
15624     return 1;
15625 }
15626 
15627 static int
15628 assign_in_cond(struct parser_params *parser, NODE *node)
15629 {
15630     switch (nd_type(node)) {
15631       case NODE_MASGN:
15632         yyerror("multiple assignment in conditional");
15633         return 1;
15634 
15635       case NODE_LASGN:
15636       case NODE_DASGN:
15637       case NODE_DASGN_CURR:
15638       case NODE_GASGN:
15639       case NODE_IASGN:
15640         break;
15641 
15642       default:
15643         return 0;
15644     }
15645 
15646     if (!node->nd_value) return 1;
15647     if (is_static_content(node->nd_value)) {
15648         /* reports always */
15649         parser_warn(node->nd_value, "found = in conditional, should be ==");
15650     }
15651     return 1;
15652 }
15653 
15654 static void
15655 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15656 {
15657     if (!e_option_supplied(parser)) parser_warn(node, str);
15658 }
15659 
15660 static void
15661 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15662 {
15663     if (!e_option_supplied(parser)) parser_warning(node, str);
15664 }
15665 
15666 static void
15667 fixup_nodes(NODE **rootnode)
15668 {
15669     NODE *node, *next, *head;
15670 
15671     for (node = *rootnode; node; node = next) {
15672         enum node_type type;
15673         VALUE val;
15674 
15675         next = node->nd_next;
15676         head = node->nd_head;
15677         rb_gc_force_recycle((VALUE)node);
15678         *rootnode = next;
15679         switch (type = nd_type(head)) {
15680           case NODE_DOT2:
15681           case NODE_DOT3:
15682             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15683                                type == NODE_DOT3);
15684             rb_gc_force_recycle((VALUE)head->nd_beg);
15685             rb_gc_force_recycle((VALUE)head->nd_end);
15686             nd_set_type(head, NODE_LIT);
15687             head->nd_lit = val;
15688             break;
15689           default:
15690             break;
15691         }
15692     }
15693 }
15694 
15695 static NODE *cond0(struct parser_params*,NODE*);
15696 
15697 static NODE*
15698 range_op(struct parser_params *parser, NODE *node)
15699 {
15700     enum node_type type;
15701 
15702     if (node == 0) return 0;
15703 
15704     type = nd_type(node);
15705     value_expr(node);
15706     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15707         warn_unless_e_option(parser, node, "integer literal in conditional range");
15708         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15709     }
15710     return cond0(parser, node);
15711 }
15712 
15713 static int
15714 literal_node(NODE *node)
15715 {
15716     if (!node) return 1;        /* same as NODE_NIL */
15717     switch (nd_type(node)) {
15718       case NODE_LIT:
15719       case NODE_STR:
15720       case NODE_DSTR:
15721       case NODE_EVSTR:
15722       case NODE_DREGX:
15723       case NODE_DREGX_ONCE:
15724       case NODE_DSYM:
15725         return 2;
15726       case NODE_TRUE:
15727       case NODE_FALSE:
15728       case NODE_NIL:
15729         return 1;
15730     }
15731     return 0;
15732 }
15733 
15734 static NODE*
15735 cond0(struct parser_params *parser, NODE *node)
15736 {
15737     if (node == 0) return 0;
15738     assign_in_cond(parser, node);
15739 
15740     switch (nd_type(node)) {
15741       case NODE_DSTR:
15742       case NODE_EVSTR:
15743       case NODE_STR:
15744         rb_warn0("string literal in condition");
15745         break;
15746 
15747       case NODE_DREGX:
15748       case NODE_DREGX_ONCE:
15749         warning_unless_e_option(parser, node, "regex literal in condition");
15750         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15751 
15752       case NODE_AND:
15753       case NODE_OR:
15754         node->nd_1st = cond0(parser, node->nd_1st);
15755         node->nd_2nd = cond0(parser, node->nd_2nd);
15756         break;
15757 
15758       case NODE_DOT2:
15759       case NODE_DOT3:
15760         node->nd_beg = range_op(parser, node->nd_beg);
15761         node->nd_end = range_op(parser, node->nd_end);
15762         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15763         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15764         if (!e_option_supplied(parser)) {
15765             int b = literal_node(node->nd_beg);
15766             int e = literal_node(node->nd_end);
15767             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15768                 parser_warn(node, "range literal in condition");
15769             }
15770         }
15771         break;
15772 
15773       case NODE_DSYM:
15774         parser_warning(node, "literal in condition");
15775         break;
15776 
15777       case NODE_LIT:
15778         if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15779             warn_unless_e_option(parser, node, "regex literal in condition");
15780             nd_set_type(node, NODE_MATCH);
15781         }
15782         else {
15783             parser_warning(node, "literal in condition");
15784         }
15785       default:
15786         break;
15787     }
15788     return node;
15789 }
15790 
15791 static NODE*
15792 cond_gen(struct parser_params *parser, NODE *node)
15793 {
15794     if (node == 0) return 0;
15795     return cond0(parser, node);
15796 }
15797 
15798 static NODE*
15799 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15800 {
15801     value_expr(left);
15802     if (left && (enum node_type)nd_type(left) == type) {
15803         NODE *node = left, *second;
15804         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15805             node = second;
15806         }
15807         node->nd_2nd = NEW_NODE(type, second, right, 0);
15808         return left;
15809     }
15810     return NEW_NODE(type, left, right, 0);
15811 }
15812 
15813 static void
15814 no_blockarg(struct parser_params *parser, NODE *node)
15815 {
15816     if (node && nd_type(node) == NODE_BLOCK_PASS) {
15817         compile_error(PARSER_ARG "block argument should not be given");
15818     }
15819 }
15820 
15821 static NODE *
15822 ret_args_gen(struct parser_params *parser, NODE *node)
15823 {
15824     if (node) {
15825         no_blockarg(parser, node);
15826         if (nd_type(node) == NODE_ARRAY) {
15827             if (node->nd_next == 0) {
15828                 node = node->nd_head;
15829             }
15830             else {
15831                 nd_set_type(node, NODE_VALUES);
15832             }
15833         }
15834     }
15835     return node;
15836 }
15837 
15838 static NODE *
15839 new_yield_gen(struct parser_params *parser, NODE *node)
15840 {
15841     if (node) no_blockarg(parser, node);
15842 
15843     return NEW_YIELD(node);
15844 }
15845 
15846 static NODE*
15847 negate_lit(NODE *node)
15848 {
15849     switch (TYPE(node->nd_lit)) {
15850       case T_FIXNUM:
15851         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15852         break;
15853       case T_BIGNUM:
15854         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15855         break;
15856       case T_FLOAT:
15857 #if USE_FLONUM
15858         if (FLONUM_P(node->nd_lit)) {
15859             node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15860         }
15861         else {
15862             RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15863         }
15864 #else
15865         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15866 #endif
15867         break;
15868       default:
15869         break;
15870     }
15871     return node;
15872 }
15873 
15874 static NODE *
15875 arg_blk_pass(NODE *node1, NODE *node2)
15876 {
15877     if (node2) {
15878         node2->nd_head = node1;
15879         return node2;
15880     }
15881     return node1;
15882 }
15883 
15884 
15885 static NODE*
15886 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15887 {
15888     int saved_line = ruby_sourceline;
15889     struct rb_args_info *args = tail->nd_ainfo;
15890 
15891     args->pre_args_num   = m ? rb_long2int(m->nd_plen) : 0;
15892     args->pre_init       = m ? m->nd_next : 0;
15893 
15894     args->post_args_num  = p ? rb_long2int(p->nd_plen) : 0;
15895     args->post_init      = p ? p->nd_next : 0;
15896     args->first_post_arg = p ? p->nd_pid : 0;
15897 
15898     args->rest_arg       = r;
15899 
15900     args->opt_args       = o;
15901 
15902     ruby_sourceline = saved_line;
15903 
15904     return tail;
15905 }
15906 
15907 static NODE*
15908 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15909 {
15910     int saved_line = ruby_sourceline;
15911     struct rb_args_info *args;
15912     NODE *kw_rest_arg = 0;
15913     NODE *node;
15914 
15915     args = ALLOC(struct rb_args_info);
15916     MEMZERO(args, struct rb_args_info, 1);
15917     node = NEW_NODE(NODE_ARGS, 0, 0, args);
15918 
15919     args->block_arg      = b;
15920     args->kw_args        = k;
15921     if (k && !kr) kr = internal_id();
15922     if (kr) {
15923         arg_var(kr);
15924         kw_rest_arg  = NEW_DVAR(kr);
15925     }
15926     args->kw_rest_arg    = kw_rest_arg;
15927 
15928     ruby_sourceline = saved_line;
15929     return node;
15930 }
15931 
15932 static NODE*
15933 dsym_node_gen(struct parser_params *parser, NODE *node)
15934 {
15935     VALUE lit;
15936 
15937     if (!node) {
15938         return NEW_LIT(ID2SYM(idNULL));
15939     }
15940 
15941     switch (nd_type(node)) {
15942       case NODE_DSTR:
15943         nd_set_type(node, NODE_DSYM);
15944         break;
15945       case NODE_STR:
15946         lit = node->nd_lit;
15947         node->nd_lit = ID2SYM(rb_intern_str(lit));
15948         nd_set_type(node, NODE_LIT);
15949         break;
15950       default:
15951         node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15952         break;
15953     }
15954     return node;
15955 }
15956 #endif /* !RIPPER */
15957 
15958 #ifndef RIPPER
15959 static NODE *
15960 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15961 {
15962     NODE *asgn;
15963 
15964     if (lhs) {
15965         ID vid = lhs->nd_vid;
15966         if (op == tOROP) {
15967             lhs->nd_value = rhs;
15968             asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15969             if (is_asgn_or_id(vid)) {
15970                 asgn->nd_aid = vid;
15971             }
15972         }
15973         else if (op == tANDOP) {
15974             lhs->nd_value = rhs;
15975             asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15976         }
15977         else {
15978             asgn = lhs;
15979             asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15980         }
15981     }
15982     else {
15983         asgn = NEW_BEGIN(0);
15984     }
15985     return asgn;
15986 }
15987 
15988 static NODE *
15989 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15990 {
15991     NODE *asgn;
15992 
15993     if (op == tOROP) {
15994         op = 0;
15995     }
15996     else if (op == tANDOP) {
15997         op = 1;
15998     }
15999     asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16000     fixpos(asgn, lhs);
16001     return asgn;
16002 }
16003 
16004 static NODE *
16005 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16006 {
16007     NODE *asgn;
16008 
16009     if (op == tOROP) {
16010         op = 0;
16011     }
16012     else if (op == tANDOP) {
16013         op = 1;
16014     }
16015     if (lhs) {
16016         asgn = NEW_OP_CDECL(lhs, op, rhs);
16017     }
16018     else {
16019         asgn = NEW_BEGIN(0);
16020     }
16021     fixpos(asgn, lhs);
16022     return asgn;
16023 }
16024 #else
16025 static VALUE
16026 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16027 {
16028     return dispatch3(opassign, lhs, op, rhs);
16029 }
16030 
16031 static VALUE
16032 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16033 {
16034     VALUE recv = dispatch3(field, lhs, type, attr);
16035     return dispatch3(opassign, recv, op, rhs);
16036 }
16037 #endif
16038 
16039 static void
16040 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16041 {
16042     int i, cnt;
16043     ID *v, *u;
16044 
16045     if (!local->used) return;
16046     v = local->vars->tbl;
16047     u = local->used->tbl;
16048     cnt = local->used->pos;
16049     if (cnt != local->vars->pos) {
16050         rb_bug("local->used->pos != local->vars->pos");
16051     }
16052     for (i = 0; i < cnt; ++i) {
16053         if (!v[i] || (u[i] & LVAR_USED)) continue;
16054         if (is_private_local_id(v[i])) continue;
16055         rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16056     }
16057 }
16058 
16059 static void
16060 local_push_gen(struct parser_params *parser, int inherit_dvars)
16061 {
16062     struct local_vars *local;
16063 
16064     local = ALLOC(struct local_vars);
16065     local->prev = lvtbl;
16066     local->args = vtable_alloc(0);
16067     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16068     local->used = !(inherit_dvars &&
16069                     (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
16070         RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16071     local->cmdargs = cmdarg_stack;
16072     cmdarg_stack = 0;
16073     lvtbl = local;
16074 }
16075 
16076 static void
16077 local_pop_gen(struct parser_params *parser)
16078 {
16079     struct local_vars *local = lvtbl->prev;
16080     if (lvtbl->used) {
16081         warn_unused_var(parser, lvtbl);
16082         vtable_free(lvtbl->used);
16083     }
16084     vtable_free(lvtbl->args);
16085     vtable_free(lvtbl->vars);
16086     cmdarg_stack = lvtbl->cmdargs;
16087     xfree(lvtbl);
16088     lvtbl = local;
16089 }
16090 
16091 #ifndef RIPPER
16092 static ID*
16093 local_tbl_gen(struct parser_params *parser)
16094 {
16095     int cnt_args = vtable_size(lvtbl->args);
16096     int cnt_vars = vtable_size(lvtbl->vars);
16097     int cnt = cnt_args + cnt_vars;
16098     int i, j;
16099     ID *buf;
16100 
16101     if (cnt <= 0) return 0;
16102     buf = ALLOC_N(ID, cnt + 1);
16103     MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16104     /* remove IDs duplicated to warn shadowing */
16105     for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16106         ID id = lvtbl->vars->tbl[i];
16107         if (!vtable_included(lvtbl->args, id)) {
16108             buf[j++] = id;
16109         }
16110     }
16111     if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16112     buf[0] = cnt;
16113     return buf;
16114 }
16115 #endif
16116 
16117 static int
16118 arg_var_gen(struct parser_params *parser, ID id)
16119 {
16120     vtable_add(lvtbl->args, id);
16121     return vtable_size(lvtbl->args) - 1;
16122 }
16123 
16124 static int
16125 local_var_gen(struct parser_params *parser, ID id)
16126 {
16127     vtable_add(lvtbl->vars, id);
16128     if (lvtbl->used) {
16129         vtable_add(lvtbl->used, (ID)ruby_sourceline);
16130     }
16131     return vtable_size(lvtbl->vars) - 1;
16132 }
16133 
16134 static int
16135 local_id_gen(struct parser_params *parser, ID id)
16136 {
16137     struct vtable *vars, *args, *used;
16138 
16139     vars = lvtbl->vars;
16140     args = lvtbl->args;
16141     used = lvtbl->used;
16142 
16143     while (vars && POINTER_P(vars->prev)) {
16144         vars = vars->prev;
16145         args = args->prev;
16146         if (used) used = used->prev;
16147     }
16148 
16149     if (vars && vars->prev == DVARS_INHERIT) {
16150         return rb_local_defined(id);
16151     }
16152     else if (vtable_included(args, id)) {
16153         return 1;
16154     }
16155     else {
16156         int i = vtable_included(vars, id);
16157         if (i && used) used->tbl[i-1] |= LVAR_USED;
16158         return i != 0;
16159     }
16160 }
16161 
16162 static const struct vtable *
16163 dyna_push_gen(struct parser_params *parser)
16164 {
16165     lvtbl->args = vtable_alloc(lvtbl->args);
16166     lvtbl->vars = vtable_alloc(lvtbl->vars);
16167     if (lvtbl->used) {
16168         lvtbl->used = vtable_alloc(lvtbl->used);
16169     }
16170     return lvtbl->args;
16171 }
16172 
16173 static void
16174 dyna_pop_1(struct parser_params *parser)
16175 {
16176     struct vtable *tmp;
16177 
16178     if ((tmp = lvtbl->used) != 0) {
16179         warn_unused_var(parser, lvtbl);
16180         lvtbl->used = lvtbl->used->prev;
16181         vtable_free(tmp);
16182     }
16183     tmp = lvtbl->args;
16184     lvtbl->args = lvtbl->args->prev;
16185     vtable_free(tmp);
16186     tmp = lvtbl->vars;
16187     lvtbl->vars = lvtbl->vars->prev;
16188     vtable_free(tmp);
16189 }
16190 
16191 static void
16192 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16193 {
16194     while (lvtbl->args != lvargs) {
16195         dyna_pop_1(parser);
16196         if (!lvtbl->args) {
16197             struct local_vars *local = lvtbl->prev;
16198             xfree(lvtbl);
16199             lvtbl = local;
16200         }
16201     }
16202     dyna_pop_1(parser);
16203 }
16204 
16205 static int
16206 dyna_in_block_gen(struct parser_params *parser)
16207 {
16208     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16209 }
16210 
16211 static int
16212 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16213 {
16214     struct vtable *vars, *args, *used;
16215     int i;
16216 
16217     args = lvtbl->args;
16218     vars = lvtbl->vars;
16219     used = lvtbl->used;
16220 
16221     while (POINTER_P(vars)) {
16222         if (vtable_included(args, id)) {
16223             return 1;
16224         }
16225         if ((i = vtable_included(vars, id)) != 0) {
16226             if (used) used->tbl[i-1] |= LVAR_USED;
16227             return 1;
16228         }
16229         args = args->prev;
16230         vars = vars->prev;
16231         if (get) used = 0;
16232         if (used) used = used->prev;
16233     }
16234 
16235     if (vars == DVARS_INHERIT) {
16236         return rb_dvar_defined(id);
16237     }
16238 
16239     return 0;
16240 }
16241 
16242 static int
16243 dvar_curr_gen(struct parser_params *parser, ID id)
16244 {
16245     return (vtable_included(lvtbl->args, id) ||
16246             vtable_included(lvtbl->vars, id));
16247 }
16248 
16249 #ifndef RIPPER
16250 static void
16251 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
16252 {
16253     int c = RE_OPTION_ENCODING_IDX(options);
16254 
16255     if (c) {
16256         int opt, idx;
16257         rb_char_to_option_kcode(c, &opt, &idx);
16258         if (idx != ENCODING_GET(str) &&
16259             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16260             goto error;
16261         }
16262         ENCODING_SET(str, idx);
16263     }
16264     else if (RE_OPTION_ENCODING_NONE(options)) {
16265         if (!ENCODING_IS_ASCII8BIT(str) &&
16266             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16267             c = 'n';
16268             goto error;
16269         }
16270         rb_enc_associate(str, rb_ascii8bit_encoding());
16271     }
16272     else if (current_enc == rb_usascii_encoding()) {
16273         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16274             /* raise in re.c */
16275             rb_enc_associate(str, rb_usascii_encoding());
16276         }
16277         else {
16278             rb_enc_associate(str, rb_ascii8bit_encoding());
16279         }
16280     }
16281     return;
16282 
16283   error:
16284     compile_error(PARSER_ARG
16285         "regexp encoding option '%c' differs from source encoding '%s'",
16286         c, rb_enc_name(rb_enc_get(str)));
16287 }
16288 
16289 static int
16290 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
16291 {
16292     VALUE err;
16293     reg_fragment_setenc(str, options);
16294     err = rb_reg_check_preprocess(str);
16295     if (err != Qnil) {
16296         err = rb_obj_as_string(err);
16297         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16298         RB_GC_GUARD(err);
16299         return 0;
16300     }
16301     return 1;
16302 }
16303 
16304 typedef struct {
16305     struct parser_params* parser;
16306     rb_encoding *enc;
16307     NODE *succ_block;
16308     NODE *fail_block;
16309     int num;
16310 } reg_named_capture_assign_t;
16311 
16312 static int
16313 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
16314           int back_num, int *back_refs, OnigRegex regex, void *arg0)
16315 {
16316     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
16317     struct parser_params* parser = arg->parser;
16318     rb_encoding *enc = arg->enc;
16319     long len = name_end - name;
16320     const char *s = (const char *)name;
16321     ID var;
16322 
16323     arg->num++;
16324 
16325     if (arg->succ_block == 0) {
16326         arg->succ_block = NEW_BEGIN(0);
16327         arg->fail_block = NEW_BEGIN(0);
16328     }
16329 
16330     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16331         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16332         !rb_enc_symname2_p(s, len, enc)) {
16333         return ST_CONTINUE;
16334     }
16335     var = rb_intern3(s, len, enc);
16336     if (dvar_defined(var) || local_id(var)) {
16337         rb_warningS("named capture conflicts a local variable - %s",
16338                     rb_id2name(var));
16339     }
16340     arg->succ_block = block_append(arg->succ_block,
16341         newline_node(node_assign(assignable(var,0),
16342             NEW_CALL(
16343               gettable(rb_intern("$~")),
16344               idAREF,
16345               NEW_LIST(NEW_LIT(ID2SYM(var))))
16346             )));
16347     arg->fail_block = block_append(arg->fail_block,
16348         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
16349     return ST_CONTINUE;
16350 }
16351 
16352 static NODE *
16353 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
16354 {
16355     reg_named_capture_assign_t arg;
16356 
16357     arg.parser = parser;
16358     arg.enc = rb_enc_get(regexp);
16359     arg.succ_block = 0;
16360     arg.fail_block = 0;
16361     arg.num = 0;
16362     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16363 
16364     if (arg.num == 0)
16365         return match;
16366 
16367     return
16368         block_append(
16369             newline_node(match),
16370             NEW_IF(gettable(rb_intern("$~")),
16371                 block_append(
16372                     newline_node(arg.succ_block),
16373                     newline_node(
16374                         NEW_CALL(
16375                           gettable(rb_intern("$~")),
16376                           rb_intern("begin"),
16377                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16378                 block_append(
16379                     newline_node(arg.fail_block),
16380                     newline_node(
16381                         NEW_LIT(Qnil)))));
16382 }
16383 
16384 static VALUE
16385 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16386 {
16387     VALUE re;
16388     VALUE err;
16389 
16390     reg_fragment_setenc(str, options);
16391     err = rb_errinfo();
16392     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
16393     if (NIL_P(re)) {
16394         ID mesg = rb_intern("mesg");
16395         VALUE m = rb_attr_get(rb_errinfo(), mesg);
16396         rb_set_errinfo(err);
16397         if (!NIL_P(err)) {
16398             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16399         }
16400         else {
16401             compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
16402         }
16403         return Qnil;
16404     }
16405     return re;
16406 }
16407 
16408 void
16409 rb_gc_mark_parser(void)
16410 {
16411 }
16412 
16413 NODE*
16414 rb_parser_append_print(VALUE vparser, NODE *node)
16415 {
16416     NODE *prelude = 0;
16417     NODE *scope = node;
16418     struct parser_params *parser;
16419 
16420     if (!node) return node;
16421 
16422     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16423 
16424     node = node->nd_body;
16425 
16426     if (nd_type(node) == NODE_PRELUDE) {
16427         prelude = node;
16428         node = node->nd_body;
16429     }
16430 
16431     node = block_append(node,
16432                         NEW_FCALL(rb_intern("print"),
16433                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16434     if (prelude) {
16435         prelude->nd_body = node;
16436         scope->nd_body = prelude;
16437     }
16438     else {
16439         scope->nd_body = node;
16440     }
16441 
16442     return scope;
16443 }
16444 
16445 NODE *
16446 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16447 {
16448     NODE *prelude = 0;
16449     NODE *scope = node;
16450     struct parser_params *parser;
16451 
16452     if (!node) return node;
16453 
16454     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16455 
16456     node = node->nd_body;
16457 
16458     if (nd_type(node) == NODE_PRELUDE) {
16459         prelude = node;
16460         node = node->nd_body;
16461     }
16462     if (split) {
16463         node = block_append(NEW_GASGN(rb_intern("$F"),
16464                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
16465                                                rb_intern("split"), 0)),
16466                             node);
16467     }
16468     if (chop) {
16469         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16470                                      rb_intern("chop!"), 0), node);
16471     }
16472 
16473     node = NEW_OPT_N(node);
16474 
16475     if (prelude) {
16476         prelude->nd_body = node;
16477         scope->nd_body = prelude;
16478     }
16479     else {
16480         scope->nd_body = node;
16481     }
16482 
16483     return scope;
16484 }
16485 
16486 static const struct {
16487     ID token;
16488     const char *name;
16489 } op_tbl[] = {
16490     {tDOT2,     ".."},
16491     {tDOT3,     "..."},
16492     {tPOW,      "**"},
16493     {tDSTAR,    "**"},
16494     {tUPLUS,    "+@"},
16495     {tUMINUS,   "-@"},
16496     {tCMP,      "<=>"},
16497     {tGEQ,      ">="},
16498     {tLEQ,      "<="},
16499     {tEQ,       "=="},
16500     {tEQQ,      "==="},
16501     {tNEQ,      "!="},
16502     {tMATCH,    "=~"},
16503     {tNMATCH,   "!~"},
16504     {tAREF,     "[]"},
16505     {tASET,     "[]="},
16506     {tLSHFT,    "<<"},
16507     {tRSHFT,    ">>"},
16508     {tCOLON2,   "::"},
16509 };
16510 
16511 #define op_tbl_count numberof(op_tbl)
16512 
16513 #ifndef ENABLE_SELECTOR_NAMESPACE
16514 #define ENABLE_SELECTOR_NAMESPACE 0
16515 #endif
16516 
16517 static struct symbols {
16518     ID last_id;
16519     st_table *sym_id;
16520     st_table *id_str;
16521 #if ENABLE_SELECTOR_NAMESPACE
16522     st_table *ivar2_id;
16523     st_table *id_ivar2;
16524 #endif
16525     VALUE op_sym[tLAST_OP_ID];
16526 } global_symbols = {tLAST_TOKEN};
16527 
16528 static const struct st_hash_type symhash = {
16529     rb_str_hash_cmp,
16530     rb_str_hash,
16531 };
16532 
16533 #if ENABLE_SELECTOR_NAMESPACE
16534 struct ivar2_key {
16535     ID id;
16536     VALUE klass;
16537 };
16538 
16539 static int
16540 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16541 {
16542     if (key1->id == key2->id && key1->klass == key2->klass) {
16543         return 0;
16544     }
16545     return 1;
16546 }
16547 
16548 static int
16549 ivar2_hash(struct ivar2_key *key)
16550 {
16551     return (key->id << 8) ^ (key->klass >> 2);
16552 }
16553 
16554 static const struct st_hash_type ivar2_hash_type = {
16555     ivar2_cmp,
16556     ivar2_hash,
16557 };
16558 #endif
16559 
16560 void
16561 Init_sym(void)
16562 {
16563     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16564     global_symbols.id_str = st_init_numtable_with_size(1000);
16565 #if ENABLE_SELECTOR_NAMESPACE
16566     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16567     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16568 #endif
16569 
16570     (void)nodetype;
16571     (void)nodeline;
16572 #if PARSER_DEBUG
16573     (void)lex_state_name(-1);
16574 #endif
16575 
16576     Init_id();
16577 }
16578 
16579 void
16580 rb_gc_mark_symbols(void)
16581 {
16582     rb_mark_tbl(global_symbols.id_str);
16583     rb_gc_mark_locations(global_symbols.op_sym,
16584                          global_symbols.op_sym + numberof(global_symbols.op_sym));
16585 }
16586 #endif /* !RIPPER */
16587 
16588 static ID
16589 internal_id_gen(struct parser_params *parser)
16590 {
16591     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16592     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16593     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16594 }
16595 
16596 #ifndef RIPPER
16597 static int
16598 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16599 {
16600     int mb = 0;
16601 
16602     if (m >= e) return 0;
16603     if (is_global_name_punct(*m)) {
16604         ++m;
16605     }
16606     else if (*m == '-') {
16607         ++m;
16608         if (m < e && is_identchar(m, e, enc)) {
16609             if (!ISASCII(*m)) mb = 1;
16610             m += rb_enc_mbclen(m, e, enc);
16611         }
16612     }
16613     else {
16614         if (!rb_enc_isdigit(*m, enc)) return 0;
16615         do {
16616             if (!ISASCII(*m)) mb = 1;
16617             ++m;
16618         } while (m < e && rb_enc_isdigit(*m, enc));
16619     }
16620     return m == e ? mb + 1 : 0;
16621 }
16622 
16623 int
16624 rb_symname_p(const char *name)
16625 {
16626     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16627 }
16628 
16629 int
16630 rb_enc_symname_p(const char *name, rb_encoding *enc)
16631 {
16632     return rb_enc_symname2_p(name, strlen(name), enc);
16633 }
16634 
16635 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16636 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
16637 
16638 static int
16639 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
16640 {
16641     const char *m = name;
16642     const char *e = m + len;
16643     int type = ID_JUNK;
16644 
16645     if (!m || len <= 0) return -1;
16646     switch (*m) {
16647       case '\0':
16648         return -1;
16649 
16650       case '$':
16651         type = ID_GLOBAL;
16652         if (is_special_global_name(++m, e, enc)) return type;
16653         goto id;
16654 
16655       case '@':
16656         type = ID_INSTANCE;
16657         if (*++m == '@') {
16658             ++m;
16659             type = ID_CLASS;
16660         }
16661         goto id;
16662 
16663       case '<':
16664         switch (*++m) {
16665           case '<': ++m; break;
16666           case '=': if (*++m == '>') ++m; break;
16667           default: break;
16668         }
16669         break;
16670 
16671       case '>':
16672         switch (*++m) {
16673           case '>': case '=': ++m; break;
16674         }
16675         break;
16676 
16677       case '=':
16678         switch (*++m) {
16679           case '~': ++m; break;
16680           case '=': if (*++m == '=') ++m; break;
16681           default: return -1;
16682         }
16683         break;
16684 
16685       case '*':
16686         if (*++m == '*') ++m;
16687         break;
16688 
16689       case '+': case '-':
16690         if (*++m == '@') ++m;
16691         break;
16692 
16693       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16694         ++m;
16695         break;
16696 
16697       case '[':
16698         if (*++m != ']') return -1;
16699         if (*++m == '=') ++m;
16700         break;
16701 
16702       case '!':
16703         if (len == 1) return ID_JUNK;
16704         switch (*++m) {
16705           case '=': case '~': ++m; break;
16706           default: return -1;
16707         }
16708         break;
16709 
16710       default:
16711         type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16712       id:
16713         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16714             return -1;
16715         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16716         if (m >= e) break;
16717         switch (*m) {
16718           case '!': case '?':
16719             if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16720             type = ID_JUNK;
16721             ++m;
16722             if (m + 1 < e || *m != '=') break;
16723             /* fall through */
16724           case '=':
16725             if (!(allowed_atttset & (1U << type))) return -1;
16726             type = ID_ATTRSET;
16727             ++m;
16728             break;
16729         }
16730         break;
16731     }
16732     return m == e ? type : -1;
16733 }
16734 
16735 int
16736 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16737 {
16738     return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16739 }
16740 
16741 static int
16742 rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
16743 {
16744     const char *ptr = StringValuePtr(name);
16745     long len = RSTRING_LEN(name);
16746     int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset);
16747     RB_GC_GUARD(name);
16748     return type;
16749 }
16750 
16751 static ID
16752 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16753 {
16754     VALUE str = rb_enc_str_new(name, len, enc);
16755     return register_symid_str(id, str);
16756 }
16757 
16758 static ID
16759 register_symid_str(ID id, VALUE str)
16760 {
16761     OBJ_FREEZE(str);
16762     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
16763     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
16764     return id;
16765 }
16766 
16767 static int
16768 sym_check_asciionly(VALUE str)
16769 {
16770     if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16771     switch (rb_enc_str_coderange(str)) {
16772       case ENC_CODERANGE_BROKEN:
16773         rb_raise(rb_eEncodingError, "invalid encoding symbol");
16774       case ENC_CODERANGE_7BIT:
16775         return TRUE;
16776     }
16777     return FALSE;
16778 }
16779 
16780 /*
16781  * _str_ itself will be registered at the global symbol table.  _str_
16782  * can be modified before the registration, since the encoding will be
16783  * set to ASCII-8BIT if it is a special global name.
16784  */
16785 static ID intern_str(VALUE str);
16786 
16787 ID
16788 rb_intern3(const char *name, long len, rb_encoding *enc)
16789 {
16790     VALUE str;
16791     st_data_t data;
16792     struct RString fake_str;
16793     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16794     fake_str.basic.klass = rb_cString;
16795     fake_str.as.heap.len = len;
16796     fake_str.as.heap.ptr = (char *)name;
16797     fake_str.as.heap.aux.capa = len;
16798     str = (VALUE)&fake_str;
16799     rb_enc_associate(str, enc);
16800     OBJ_FREEZE(str);
16801 
16802     if (st_lookup(global_symbols.sym_id, str, &data))
16803         return (ID)data;
16804 
16805     str = rb_enc_str_new(name, len, enc); /* make true string */
16806     return intern_str(str);
16807 }
16808 
16809 static ID
16810 intern_str(VALUE str)
16811 {
16812     const char *name, *m, *e;
16813     long len, last;
16814     rb_encoding *enc, *symenc;
16815     unsigned char c;
16816     ID id;
16817     int mb;
16818 
16819     RSTRING_GETMEM(str, name, len);
16820     m = name;
16821     e = m + len;
16822     enc = rb_enc_get(str);
16823     symenc = enc;
16824 
16825     if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16826       junk:
16827         id = ID_JUNK;
16828         goto new_id;
16829     }
16830     last = len-1;
16831     id = 0;
16832     switch (*m) {
16833       case '$':
16834         if (len < 2) goto junk;
16835         id |= ID_GLOBAL;
16836         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16837             if (!--mb) symenc = rb_usascii_encoding();
16838             goto new_id;
16839         }
16840         break;
16841       case '@':
16842         if (m[1] == '@') {
16843             if (len < 3) goto junk;
16844             m++;
16845             id |= ID_CLASS;
16846         }
16847         else {
16848             if (len < 2) goto junk;
16849             id |= ID_INSTANCE;
16850         }
16851         m++;
16852         break;
16853       default:
16854         c = m[0];
16855         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16856             /* operators */
16857             int i;
16858 
16859             if (len == 1) {
16860                 id = c;
16861                 goto id_register;
16862             }
16863             for (i = 0; i < op_tbl_count; i++) {
16864                 if (*op_tbl[i].name == *m &&
16865                     strcmp(op_tbl[i].name, m) == 0) {
16866                     id = op_tbl[i].token;
16867                     goto id_register;
16868                 }
16869             }
16870         }
16871         break;
16872     }
16873     if (name[last] == '=') {
16874         /* attribute assignment */
16875         if (last > 1 && name[last-1] == '=')
16876             goto junk;
16877         id = rb_intern3(name, last, enc);
16878         if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16879             enc = rb_enc_get(rb_id2str(id));
16880             id = rb_id_attrset(id);
16881             goto id_register;
16882         }
16883         id = ID_ATTRSET;
16884     }
16885     else if (id == 0) {
16886         if (rb_enc_isupper(m[0], enc)) {
16887             id = ID_CONST;
16888         }
16889         else {
16890             id = ID_LOCAL;
16891         }
16892     }
16893     if (!rb_enc_isdigit(*m, enc)) {
16894         while (m <= name + last && is_identchar(m, e, enc)) {
16895             if (ISASCII(*m)) {
16896                 m++;
16897             }
16898             else {
16899                 m += rb_enc_mbclen(m, e, enc);
16900             }
16901         }
16902     }
16903     if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
16904     if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16905   new_id:
16906     if (symenc != enc) rb_enc_associate(str, symenc);
16907     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
16908         if (len > 20) {
16909             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16910                      name);
16911         }
16912         else {
16913             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16914                      (int)len, name);
16915         }
16916     }
16917     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
16918   id_register:
16919     return register_symid_str(id, str);
16920 }
16921 
16922 ID
16923 rb_intern2(const char *name, long len)
16924 {
16925     return rb_intern3(name, len, rb_usascii_encoding());
16926 }
16927 
16928 #undef rb_intern
16929 ID
16930 rb_intern(const char *name)
16931 {
16932     return rb_intern2(name, strlen(name));
16933 }
16934 
16935 ID
16936 rb_intern_str(VALUE str)
16937 {
16938     st_data_t id;
16939 
16940     if (st_lookup(global_symbols.sym_id, str, &id))
16941         return (ID)id;
16942     return intern_str(rb_str_dup(str));
16943 }
16944 
16945 VALUE
16946 rb_id2str(ID id)
16947 {
16948     st_data_t data;
16949 
16950     if (id < tLAST_TOKEN) {
16951         int i = 0;
16952 
16953         if (id < INT_MAX && rb_ispunct((int)id)) {
16954             VALUE str = global_symbols.op_sym[i = (int)id];
16955             if (!str) {
16956                 char name[2];
16957                 name[0] = (char)id;
16958                 name[1] = 0;
16959                 str = rb_usascii_str_new(name, 1);
16960                 OBJ_FREEZE(str);
16961                 global_symbols.op_sym[i] = str;
16962             }
16963             return str;
16964         }
16965         for (i = 0; i < op_tbl_count; i++) {
16966             if (op_tbl[i].token == id) {
16967                 VALUE str = global_symbols.op_sym[i];
16968                 if (!str) {
16969                     str = rb_usascii_str_new2(op_tbl[i].name);
16970                     OBJ_FREEZE(str);
16971                     global_symbols.op_sym[i] = str;
16972                 }
16973                 return str;
16974             }
16975         }
16976     }
16977 
16978     if (st_lookup(global_symbols.id_str, id, &data)) {
16979         VALUE str = (VALUE)data;
16980         if (RBASIC(str)->klass == 0)
16981             RBASIC(str)->klass = rb_cString;
16982         return str;
16983     }
16984 
16985     if (is_attrset_id(id)) {
16986         ID id_stem = (id & ~ID_SCOPE_MASK);
16987         VALUE str;
16988 
16989         do {
16990             if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
16991             if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
16992             if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
16993             if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
16994             if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
16995             if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
16996             return 0;
16997         } while (0);
16998         str = rb_str_dup(str);
16999         rb_str_cat(str, "=", 1);
17000         register_symid_str(id, str);
17001         if (st_lookup(global_symbols.id_str, id, &data)) {
17002             VALUE str = (VALUE)data;
17003             if (RBASIC(str)->klass == 0)
17004                 RBASIC(str)->klass = rb_cString;
17005             return str;
17006         }
17007     }
17008     return 0;
17009 }
17010 
17011 const char *
17012 rb_id2name(ID id)
17013 {
17014     VALUE str = rb_id2str(id);
17015 
17016     if (!str) return 0;
17017     return RSTRING_PTR(str);
17018 }
17019 
17020 static int
17021 symbols_i(VALUE sym, ID value, VALUE ary)
17022 {
17023     rb_ary_push(ary, ID2SYM(value));
17024     return ST_CONTINUE;
17025 }
17026 
17027 /*
17028  *  call-seq:
17029  *     Symbol.all_symbols    => array
17030  *
17031  *  Returns an array of all the symbols currently in Ruby's symbol
17032  *  table.
17033  *
17034  *     Symbol.all_symbols.size    #=> 903
17035  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
17036  *                                     :chown, :EOFError, :$;, :String,
17037  *                                     :LOCK_SH, :"setuid?", :$<,
17038  *                                     :default_proc, :compact, :extend,
17039  *                                     :Tms, :getwd, :$=, :ThreadGroup,
17040  *                                     :wait2, :$>]
17041  */
17042 
17043 VALUE
17044 rb_sym_all_symbols(void)
17045 {
17046     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
17047 
17048     st_foreach(global_symbols.sym_id, symbols_i, ary);
17049     return ary;
17050 }
17051 
17052 int
17053 rb_is_const_id(ID id)
17054 {
17055     return is_const_id(id);
17056 }
17057 
17058 int
17059 rb_is_class_id(ID id)
17060 {
17061     return is_class_id(id);
17062 }
17063 
17064 int
17065 rb_is_global_id(ID id)
17066 {
17067     return is_global_id(id);
17068 }
17069 
17070 int
17071 rb_is_instance_id(ID id)
17072 {
17073     return is_instance_id(id);
17074 }
17075 
17076 int
17077 rb_is_attrset_id(ID id)
17078 {
17079     return is_attrset_id(id);
17080 }
17081 
17082 int
17083 rb_is_local_id(ID id)
17084 {
17085     return is_local_id(id);
17086 }
17087 
17088 int
17089 rb_is_junk_id(ID id)
17090 {
17091     return is_junk_id(id);
17092 }
17093 
17105 ID
17106 rb_check_id(volatile VALUE *namep)
17107 {
17108     st_data_t id;
17109     VALUE tmp;
17110     VALUE name = *namep;
17111 
17112     if (SYMBOL_P(name)) {
17113         return SYM2ID(name);
17114     }
17115     else if (!RB_TYPE_P(name, T_STRING)) {
17116         tmp = rb_check_string_type(name);
17117         if (NIL_P(tmp)) {
17118             tmp = rb_inspect(name);
17119             rb_raise(rb_eTypeError, "%s is not a symbol",
17120                      RSTRING_PTR(tmp));
17121         }
17122         name = tmp;
17123         *namep = name;
17124     }
17125 
17126     sym_check_asciionly(name);
17127 
17128     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17129         return (ID)id;
17130 
17131     if (rb_is_attrset_name(name)) {
17132         struct RString fake_str;
17133         const VALUE localname = (VALUE)&fake_str;
17134         /* make local name by chopping '=' */
17135         fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17136         fake_str.basic.klass = rb_cString;
17137         fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17138         fake_str.as.heap.ptr = RSTRING_PTR(name);
17139         fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17140         rb_enc_copy(localname, name);
17141         OBJ_FREEZE(localname);
17142 
17143         if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17144             return rb_id_attrset((ID)id);
17145         }
17146         RB_GC_GUARD(name);
17147     }
17148 
17149     return (ID)0;
17150 }
17151 
17152 ID
17153 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17154 {
17155     st_data_t id;
17156     struct RString fake_str;
17157     const VALUE name = (VALUE)&fake_str;
17158     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17159     fake_str.basic.klass = rb_cString;
17160     fake_str.as.heap.len = len;
17161     fake_str.as.heap.ptr = (char *)ptr;
17162     fake_str.as.heap.aux.capa = len;
17163     rb_enc_associate(name, enc);
17164 
17165     sym_check_asciionly(name);
17166 
17167     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17168         return (ID)id;
17169 
17170     if (rb_is_attrset_name(name)) {
17171         fake_str.as.heap.len = len - 1;
17172         if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17173             return rb_id_attrset((ID)id);
17174         }
17175     }
17176 
17177     return (ID)0;
17178 }
17179 
17180 int
17181 rb_is_const_name(VALUE name)
17182 {
17183     return rb_str_symname_type(name, 0) == ID_CONST;
17184 }
17185 
17186 int
17187 rb_is_class_name(VALUE name)
17188 {
17189     return rb_str_symname_type(name, 0) == ID_CLASS;
17190 }
17191 
17192 int
17193 rb_is_global_name(VALUE name)
17194 {
17195     return rb_str_symname_type(name, 0) == ID_GLOBAL;
17196 }
17197 
17198 int
17199 rb_is_instance_name(VALUE name)
17200 {
17201     return rb_str_symname_type(name, 0) == ID_INSTANCE;
17202 }
17203 
17204 int
17205 rb_is_attrset_name(VALUE name)
17206 {
17207     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
17208 }
17209 
17210 int
17211 rb_is_local_name(VALUE name)
17212 {
17213     return rb_str_symname_type(name, 0) == ID_LOCAL;
17214 }
17215 
17216 int
17217 rb_is_method_name(VALUE name)
17218 {
17219     switch (rb_str_symname_type(name, 0)) {
17220       case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17221         return TRUE;
17222     }
17223     return FALSE;
17224 }
17225 
17226 int
17227 rb_is_junk_name(VALUE name)
17228 {
17229     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17230 }
17231 
17232 #endif /* !RIPPER */
17233 
17234 static void
17235 parser_initialize(struct parser_params *parser)
17236 {
17237     parser->eofp = Qfalse;
17238 
17239     parser->parser_lex_strterm = 0;
17240     parser->parser_cond_stack = 0;
17241     parser->parser_cmdarg_stack = 0;
17242     parser->parser_class_nest = 0;
17243     parser->parser_paren_nest = 0;
17244     parser->parser_lpar_beg = 0;
17245     parser->parser_brace_nest = 0;
17246     parser->parser_in_single = 0;
17247     parser->parser_in_def = 0;
17248     parser->parser_in_defined = 0;
17249     parser->parser_compile_for_eval = 0;
17250     parser->parser_cur_mid = 0;
17251     parser->parser_tokenbuf = NULL;
17252     parser->parser_tokidx = 0;
17253     parser->parser_toksiz = 0;
17254     parser->parser_heredoc_end = 0;
17255     parser->parser_command_start = TRUE;
17256     parser->parser_deferred_nodes = 0;
17257     parser->parser_lex_pbeg = 0;
17258     parser->parser_lex_p = 0;
17259     parser->parser_lex_pend = 0;
17260     parser->parser_lvtbl = 0;
17261     parser->parser_ruby__end__seen = 0;
17262     parser->parser_ruby_sourcefile = 0;
17263     parser->parser_ruby_sourcefile_string = Qnil;
17264 #ifndef RIPPER
17265     parser->is_ripper = 0;
17266     parser->parser_eval_tree_begin = 0;
17267     parser->parser_eval_tree = 0;
17268 #else
17269     parser->is_ripper = 1;
17270     parser->delayed = Qnil;
17271 
17272     parser->result = Qnil;
17273     parser->parsing_thread = Qnil;
17274     parser->toplevel_p = TRUE;
17275 #endif
17276 #ifdef YYMALLOC
17277     parser->heap = NULL;
17278 #endif
17279     parser->enc = rb_utf8_encoding();
17280 }
17281 
17282 #ifdef RIPPER
17283 #define parser_mark ripper_parser_mark
17284 #define parser_free ripper_parser_free
17285 #endif
17286 
17287 static void
17288 parser_mark(void *ptr)
17289 {
17290     struct parser_params *p = (struct parser_params*)ptr;
17291 
17292     rb_gc_mark((VALUE)p->parser_lex_strterm);
17293     rb_gc_mark((VALUE)p->parser_deferred_nodes);
17294     rb_gc_mark(p->parser_lex_input);
17295     rb_gc_mark(p->parser_lex_lastline);
17296     rb_gc_mark(p->parser_lex_nextline);
17297     rb_gc_mark(p->parser_ruby_sourcefile_string);
17298 #ifndef RIPPER
17299     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
17300     rb_gc_mark((VALUE)p->parser_eval_tree) ;
17301     rb_gc_mark(p->debug_lines);
17302 #else
17303     rb_gc_mark(p->delayed);
17304     rb_gc_mark(p->value);
17305     rb_gc_mark(p->result);
17306     rb_gc_mark(p->parsing_thread);
17307 #endif
17308 #ifdef YYMALLOC
17309     rb_gc_mark((VALUE)p->heap);
17310 #endif
17311 }
17312 
17313 static void
17314 parser_free(void *ptr)
17315 {
17316     struct parser_params *p = (struct parser_params*)ptr;
17317     struct local_vars *local, *prev;
17318 
17319     if (p->parser_tokenbuf) {
17320         xfree(p->parser_tokenbuf);
17321     }
17322     for (local = p->parser_lvtbl; local; local = prev) {
17323         if (local->vars) xfree(local->vars);
17324         prev = local->prev;
17325         xfree(local);
17326     }
17327     xfree(p);
17328 }
17329 
17330 static size_t
17331 parser_memsize(const void *ptr)
17332 {
17333     struct parser_params *p = (struct parser_params*)ptr;
17334     struct local_vars *local;
17335     size_t size = sizeof(*p);
17336 
17337     if (!ptr) return 0;
17338     size += p->parser_toksiz;
17339     for (local = p->parser_lvtbl; local; local = local->prev) {
17340         size += sizeof(*local);
17341         if (local->vars) size += local->vars->capa * sizeof(ID);
17342     }
17343     return size;
17344 }
17345 
17346 static
17347 #ifndef RIPPER
17348 const
17349 #endif
17350 rb_data_type_t parser_data_type = {
17351     "parser",
17352     {
17353         parser_mark,
17354         parser_free,
17355         parser_memsize,
17356     },
17357 };
17358 
17359 #ifndef RIPPER
17360 #undef rb_reserved_word
17361 
17362 const struct kwtable *
17363 rb_reserved_word(const char *str, unsigned int len)
17364 {
17365     return reserved_word(str, len);
17366 }
17367 
17368 static struct parser_params *
17369 parser_new(void)
17370 {
17371     struct parser_params *p;
17372 
17373     p = ALLOC_N(struct parser_params, 1);
17374     MEMZERO(p, struct parser_params, 1);
17375     parser_initialize(p);
17376     return p;
17377 }
17378 
17379 VALUE
17380 rb_parser_new(void)
17381 {
17382     struct parser_params *p = parser_new();
17383 
17384     return TypedData_Wrap_Struct(0, &parser_data_type, p);
17385 }
17386 
17387 /*
17388  *  call-seq:
17389  *    ripper#end_seen?   -> Boolean
17390  *
17391  *  Return true if parsed source ended by +\_\_END\_\_+.
17392  */
17393 VALUE
17394 rb_parser_end_seen_p(VALUE vparser)
17395 {
17396     struct parser_params *parser;
17397 
17398     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17399     return ruby__end__seen ? Qtrue : Qfalse;
17400 }
17401 
17402 /*
17403  *  call-seq:
17404  *    ripper#encoding   -> encoding
17405  *
17406  *  Return encoding of the source.
17407  */
17408 VALUE
17409 rb_parser_encoding(VALUE vparser)
17410 {
17411     struct parser_params *parser;
17412 
17413     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17414     return rb_enc_from_encoding(current_enc);
17415 }
17416 
17417 /*
17418  *  call-seq:
17419  *    ripper.yydebug   -> true or false
17420  *
17421  *  Get yydebug.
17422  */
17423 VALUE
17424 rb_parser_get_yydebug(VALUE self)
17425 {
17426     struct parser_params *parser;
17427 
17428     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17429     return yydebug ? Qtrue : Qfalse;
17430 }
17431 
17432 /*
17433  *  call-seq:
17434  *    ripper.yydebug = flag
17435  *
17436  *  Set yydebug.
17437  */
17438 VALUE
17439 rb_parser_set_yydebug(VALUE self, VALUE flag)
17440 {
17441     struct parser_params *parser;
17442 
17443     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17444     yydebug = RTEST(flag);
17445     return flag;
17446 }
17447 
17448 #ifdef YYMALLOC
17449 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17450 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17451 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17452                            (n)->u3.cnt = (c), (p))
17453 
17454 void *
17455 rb_parser_malloc(struct parser_params *parser, size_t size)
17456 {
17457     size_t cnt = HEAPCNT(1, size);
17458     NODE *n = NEWHEAP();
17459     void *ptr = xmalloc(size);
17460 
17461     return ADD2HEAP(n, cnt, ptr);
17462 }
17463 
17464 void *
17465 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17466 {
17467     size_t cnt = HEAPCNT(nelem, size);
17468     NODE *n = NEWHEAP();
17469     void *ptr = xcalloc(nelem, size);
17470 
17471     return ADD2HEAP(n, cnt, ptr);
17472 }
17473 
17474 void *
17475 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17476 {
17477     NODE *n;
17478     size_t cnt = HEAPCNT(1, size);
17479 
17480     if (ptr && (n = parser->heap) != NULL) {
17481         do {
17482             if (n->u1.node == ptr) {
17483                 n->u1.node = ptr = xrealloc(ptr, size);
17484                 if (n->u3.cnt) n->u3.cnt = cnt;
17485                 return ptr;
17486             }
17487         } while ((n = n->u2.node) != NULL);
17488     }
17489     n = NEWHEAP();
17490     ptr = xrealloc(ptr, size);
17491     return ADD2HEAP(n, cnt, ptr);
17492 }
17493 
17494 void
17495 rb_parser_free(struct parser_params *parser, void *ptr)
17496 {
17497     NODE **prev = &parser->heap, *n;
17498 
17499     while ((n = *prev) != NULL) {
17500         if (n->u1.node == ptr) {
17501             *prev = n->u2.node;
17502             rb_gc_force_recycle((VALUE)n);
17503             break;
17504         }
17505         prev = &n->u2.node;
17506     }
17507     xfree(ptr);
17508 }
17509 #endif
17510 #endif
17511 
17512 #ifdef RIPPER
17513 #ifdef RIPPER_DEBUG
17514 extern int rb_is_pointer_to_heap(VALUE);
17515 
17516 /* :nodoc: */
17517 static VALUE
17518 ripper_validate_object(VALUE self, VALUE x)
17519 {
17520     if (x == Qfalse) return x;
17521     if (x == Qtrue) return x;
17522     if (x == Qnil) return x;
17523     if (x == Qundef)
17524         rb_raise(rb_eArgError, "Qundef given");
17525     if (FIXNUM_P(x)) return x;
17526     if (SYMBOL_P(x)) return x;
17527     if (!rb_is_pointer_to_heap(x))
17528         rb_raise(rb_eArgError, "invalid pointer: %p", x);
17529     switch (TYPE(x)) {
17530       case T_STRING:
17531       case T_OBJECT:
17532       case T_ARRAY:
17533       case T_BIGNUM:
17534       case T_FLOAT:
17535         return x;
17536       case T_NODE:
17537         if (nd_type(x) != NODE_LASGN) {
17538             rb_raise(rb_eArgError, "NODE given: %p", x);
17539         }
17540         return ((NODE *)x)->nd_rval;
17541       default:
17542         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17543                  x, rb_obj_classname(x));
17544     }
17545     return x;
17546 }
17547 #endif
17548 
17549 #define validate(x) ((x) = get_value(x))
17550 
17551 static VALUE
17552 ripper_dispatch0(struct parser_params *parser, ID mid)
17553 {
17554     return rb_funcall(parser->value, mid, 0);
17555 }
17556 
17557 static VALUE
17558 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17559 {
17560     validate(a);
17561     return rb_funcall(parser->value, mid, 1, a);
17562 }
17563 
17564 static VALUE
17565 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17566 {
17567     validate(a);
17568     validate(b);
17569     return rb_funcall(parser->value, mid, 2, a, b);
17570 }
17571 
17572 static VALUE
17573 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17574 {
17575     validate(a);
17576     validate(b);
17577     validate(c);
17578     return rb_funcall(parser->value, mid, 3, a, b, c);
17579 }
17580 
17581 static VALUE
17582 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17583 {
17584     validate(a);
17585     validate(b);
17586     validate(c);
17587     validate(d);
17588     return rb_funcall(parser->value, mid, 4, a, b, c, d);
17589 }
17590 
17591 static VALUE
17592 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17593 {
17594     validate(a);
17595     validate(b);
17596     validate(c);
17597     validate(d);
17598     validate(e);
17599     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17600 }
17601 
17602 static VALUE
17603 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17604 {
17605     validate(a);
17606     validate(b);
17607     validate(c);
17608     validate(d);
17609     validate(e);
17610     validate(f);
17611     validate(g);
17612     return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17613 }
17614 
17615 static const struct kw_assoc {
17616     ID id;
17617     const char *name;
17618 } keyword_to_name[] = {
17619     {keyword_class,     "class"},
17620     {keyword_module,    "module"},
17621     {keyword_def,       "def"},
17622     {keyword_undef,     "undef"},
17623     {keyword_begin,     "begin"},
17624     {keyword_rescue,    "rescue"},
17625     {keyword_ensure,    "ensure"},
17626     {keyword_end,       "end"},
17627     {keyword_if,        "if"},
17628     {keyword_unless,    "unless"},
17629     {keyword_then,      "then"},
17630     {keyword_elsif,     "elsif"},
17631     {keyword_else,      "else"},
17632     {keyword_case,      "case"},
17633     {keyword_when,      "when"},
17634     {keyword_while,     "while"},
17635     {keyword_until,     "until"},
17636     {keyword_for,       "for"},
17637     {keyword_break,     "break"},
17638     {keyword_next,      "next"},
17639     {keyword_redo,      "redo"},
17640     {keyword_retry,     "retry"},
17641     {keyword_in,        "in"},
17642     {keyword_do,        "do"},
17643     {keyword_do_cond,   "do"},
17644     {keyword_do_block,  "do"},
17645     {keyword_return,    "return"},
17646     {keyword_yield,     "yield"},
17647     {keyword_super,     "super"},
17648     {keyword_self,      "self"},
17649     {keyword_nil,       "nil"},
17650     {keyword_true,      "true"},
17651     {keyword_false,     "false"},
17652     {keyword_and,       "and"},
17653     {keyword_or,        "or"},
17654     {keyword_not,       "not"},
17655     {modifier_if,       "if"},
17656     {modifier_unless,   "unless"},
17657     {modifier_while,    "while"},
17658     {modifier_until,    "until"},
17659     {modifier_rescue,   "rescue"},
17660     {keyword_alias,     "alias"},
17661     {keyword_defined,   "defined?"},
17662     {keyword_BEGIN,     "BEGIN"},
17663     {keyword_END,       "END"},
17664     {keyword__LINE__,   "__LINE__"},
17665     {keyword__FILE__,   "__FILE__"},
17666     {keyword__ENCODING__, "__ENCODING__"},
17667     {0, NULL}
17668 };
17669 
17670 static const char*
17671 keyword_id_to_str(ID id)
17672 {
17673     const struct kw_assoc *a;
17674 
17675     for (a = keyword_to_name; a->id; a++) {
17676         if (a->id == id)
17677             return a->name;
17678     }
17679     return NULL;
17680 }
17681 
17682 #undef ripper_id2sym
17683 static VALUE
17684 ripper_id2sym(ID id)
17685 {
17686     const char *name;
17687     char buf[8];
17688 
17689     if (id <= 256) {
17690         buf[0] = (char)id;
17691         buf[1] = '\0';
17692         return ID2SYM(rb_intern2(buf, 1));
17693     }
17694     if ((name = keyword_id_to_str(id))) {
17695         return ID2SYM(rb_intern(name));
17696     }
17697     switch (id) {
17698       case tOROP:
17699         name = "||";
17700         break;
17701       case tANDOP:
17702         name = "&&";
17703         break;
17704       default:
17705         name = rb_id2name(id);
17706         if (!name) {
17707             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17708         }
17709         return ID2SYM(id);
17710     }
17711     return ID2SYM(rb_intern(name));
17712 }
17713 
17714 static ID
17715 ripper_get_id(VALUE v)
17716 {
17717     NODE *nd;
17718     if (!RB_TYPE_P(v, T_NODE)) return 0;
17719     nd = (NODE *)v;
17720     if (nd_type(nd) != NODE_LASGN) return 0;
17721     return nd->nd_vid;
17722 }
17723 
17724 static VALUE
17725 ripper_get_value(VALUE v)
17726 {
17727     NODE *nd;
17728     if (v == Qundef) return Qnil;
17729     if (!RB_TYPE_P(v, T_NODE)) return v;
17730     nd = (NODE *)v;
17731     if (nd_type(nd) != NODE_LASGN) return Qnil;
17732     return nd->nd_rval;
17733 }
17734 
17735 static void
17736 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17737 {
17738     VALUE str;
17739     va_list args;
17740 
17741     va_start(args, fmt);
17742     str = rb_vsprintf(fmt, args);
17743     va_end(args);
17744     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17745 }
17746 
17747 static void
17748 ripper_warn0(struct parser_params *parser, const char *fmt)
17749 {
17750     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17751 }
17752 
17753 static void
17754 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17755 {
17756     rb_funcall(parser->value, rb_intern("warn"), 2,
17757                STR_NEW2(fmt), INT2NUM(a));
17758 }
17759 
17760 static void
17761 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17762 {
17763     rb_funcall(parser->value, rb_intern("warn"), 2,
17764                STR_NEW2(fmt), STR_NEW2(str));
17765 }
17766 
17767 static void
17768 ripper_warning0(struct parser_params *parser, const char *fmt)
17769 {
17770     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17771 }
17772 
17773 static void
17774 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17775 {
17776     rb_funcall(parser->value, rb_intern("warning"), 2,
17777                STR_NEW2(fmt), STR_NEW2(str));
17778 }
17779 
17780 static VALUE
17781 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17782 {
17783     return rb_io_gets(src);
17784 }
17785 
17786 static VALUE
17787 ripper_s_allocate(VALUE klass)
17788 {
17789     struct parser_params *p;
17790     VALUE self;
17791 
17792     p = ALLOC_N(struct parser_params, 1);
17793     MEMZERO(p, struct parser_params, 1);
17794     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17795     p->value = self;
17796     return self;
17797 }
17798 
17799 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17800 
17801 /*
17802  *  call-seq:
17803  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17804  *
17805  *  Create a new Ripper object.
17806  *  _src_ must be a String, an IO, or an Object which has #gets method.
17807  *
17808  *  This method does not starts parsing.
17809  *  See also Ripper#parse and Ripper.parse.
17810  */
17811 static VALUE
17812 ripper_initialize(int argc, VALUE *argv, VALUE self)
17813 {
17814     struct parser_params *parser;
17815     VALUE src, fname, lineno;
17816 
17817     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17818     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17819     if (RB_TYPE_P(src, T_FILE)) {
17820         parser->parser_lex_gets = ripper_lex_get_generic;
17821     }
17822     else {
17823         StringValue(src);
17824         parser->parser_lex_gets = lex_get_str;
17825     }
17826     parser->parser_lex_input = src;
17827     parser->eofp = Qfalse;
17828     if (NIL_P(fname)) {
17829         fname = STR_NEW2("(ripper)");
17830     }
17831     else {
17832         StringValue(fname);
17833     }
17834     parser_initialize(parser);
17835 
17836     parser->parser_ruby_sourcefile_string = fname;
17837     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17838     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17839 
17840     return Qnil;
17841 }
17842 
17843 struct ripper_args {
17844     struct parser_params *parser;
17845     int argc;
17846     VALUE *argv;
17847 };
17848 
17849 static VALUE
17850 ripper_parse0(VALUE parser_v)
17851 {
17852     struct parser_params *parser;
17853 
17854     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17855     parser_prepare(parser);
17856     ripper_yyparse((void*)parser);
17857     return parser->result;
17858 }
17859 
17860 static VALUE
17861 ripper_ensure(VALUE parser_v)
17862 {
17863     struct parser_params *parser;
17864 
17865     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17866     parser->parsing_thread = Qnil;
17867     return Qnil;
17868 }
17869 
17870 /*
17871  *  call-seq:
17872  *    ripper#parse
17873  *
17874  *  Start parsing and returns the value of the root action.
17875  */
17876 static VALUE
17877 ripper_parse(VALUE self)
17878 {
17879     struct parser_params *parser;
17880 
17881     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17882     if (!ripper_initialized_p(parser)) {
17883         rb_raise(rb_eArgError, "method called for uninitialized object");
17884     }
17885     if (!NIL_P(parser->parsing_thread)) {
17886         if (parser->parsing_thread == rb_thread_current())
17887             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17888         else
17889             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17890     }
17891     parser->parsing_thread = rb_thread_current();
17892     rb_ensure(ripper_parse0, self, ripper_ensure, self);
17893 
17894     return parser->result;
17895 }
17896 
17897 /*
17898  *  call-seq:
17899  *    ripper#column   -> Integer
17900  *
17901  *  Return column number of current parsing line.
17902  *  This number starts from 0.
17903  */
17904 static VALUE
17905 ripper_column(VALUE self)
17906 {
17907     struct parser_params *parser;
17908     long col;
17909 
17910     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17911     if (!ripper_initialized_p(parser)) {
17912         rb_raise(rb_eArgError, "method called for uninitialized object");
17913     }
17914     if (NIL_P(parser->parsing_thread)) return Qnil;
17915     col = parser->tokp - parser->parser_lex_pbeg;
17916     return LONG2NUM(col);
17917 }
17918 
17919 /*
17920  *  call-seq:
17921  *    ripper#filename   -> String
17922  *
17923  *  Return current parsing filename.
17924  */
17925 static VALUE
17926 ripper_filename(VALUE self)
17927 {
17928     struct parser_params *parser;
17929 
17930     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17931     if (!ripper_initialized_p(parser)) {
17932         rb_raise(rb_eArgError, "method called for uninitialized object");
17933     }
17934     return parser->parser_ruby_sourcefile_string;
17935 }
17936 
17937 /*
17938  *  call-seq:
17939  *    ripper#lineno   -> Integer
17940  *
17941  *  Return line number of current parsing line.
17942  *  This number starts from 1.
17943  */
17944 static VALUE
17945 ripper_lineno(VALUE self)
17946 {
17947     struct parser_params *parser;
17948 
17949     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17950     if (!ripper_initialized_p(parser)) {
17951         rb_raise(rb_eArgError, "method called for uninitialized object");
17952     }
17953     if (NIL_P(parser->parsing_thread)) return Qnil;
17954     return INT2NUM(parser->parser_ruby_sourceline);
17955 }
17956 
17957 #ifdef RIPPER_DEBUG
17958 /* :nodoc: */
17959 static VALUE
17960 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17961 {
17962     StringValue(msg);
17963     if (obj == Qundef) {
17964         rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17965     }
17966     return Qnil;
17967 }
17968 
17969 /* :nodoc: */
17970 static VALUE
17971 ripper_value(VALUE self, VALUE obj)
17972 {
17973     return ULONG2NUM(obj);
17974 }
17975 #endif
17976 
17977 
17978 void
17979 Init_ripper(void)
17980 {
17981     parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17982 
17983     ripper_init_eventids1();
17984     ripper_init_eventids2();
17985     /* ensure existing in symbol table */
17986     (void)rb_intern("||");
17987     (void)rb_intern("&&");
17988 
17989     InitVM(ripper);
17990 }
17991 
17992 void
17993 InitVM_ripper(void)
17994 {
17995     VALUE Ripper;
17996 
17997     Ripper = rb_define_class("Ripper", rb_cObject);
17998     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17999     rb_define_alloc_func(Ripper, ripper_s_allocate);
18000     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18001     rb_define_method(Ripper, "parse", ripper_parse, 0);
18002     rb_define_method(Ripper, "column", ripper_column, 0);
18003     rb_define_method(Ripper, "filename", ripper_filename, 0);
18004     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18005     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18006     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18007     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18008     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18009 #ifdef RIPPER_DEBUG
18010     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18011     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18012     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18013 #endif
18014 
18015     ripper_init_eventids1_table(Ripper);
18016     ripper_init_eventids2_table(Ripper);
18017 
18018 # if 0
18019     /* Hack to let RDoc document SCRIPT_LINES__ */
18020 
18021     /*
18022      * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18023      * after the assignment will be added as an Array of lines with the file
18024      * name as the key.
18025      */
18026     rb_define_global_const("SCRIPT_LINES__", Qnil);
18027 #endif
18028 
18029 }
18030 #endif /* RIPPER */
18031 
18032