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 YYMALLOC(size)          rb_parser_malloc(parser, (size))
00093 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, (ptr), (size))
00094 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, (nelem), (size))
00095 #define YYFREE(ptr)             rb_parser_free(parser, (ptr))
00096 #define malloc  YYMALLOC
00097 #define realloc YYREALLOC
00098 #define calloc  YYCALLOC
00099 #define free    YYFREE
00100 
00101 #ifndef RIPPER
00102 static ID register_symid(ID, const char *, long, rb_encoding *);
00103 static ID register_symid_str(ID, VALUE);
00104 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
00105 #include "id.c"
00106 #endif
00107 
00108 #define is_notop_id(id) ((id)>tLAST_OP_ID)
00109 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00110 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00111 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00112 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00113 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00114 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00115 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00116 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
00117 
00118 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00119         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00120          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00121          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00122 
00123 enum lex_state_bits {
00124     EXPR_BEG_bit,               /* ignore newline, +/- is a sign. */
00125     EXPR_END_bit,               /* newline significant, +/- is an operator. */
00126     EXPR_ENDARG_bit,            /* ditto, and unbound braces. */
00127     EXPR_ENDFN_bit,             /* ditto, and unbound braces. */
00128     EXPR_ARG_bit,               /* newline significant, +/- is an operator. */
00129     EXPR_CMDARG_bit,            /* newline significant, +/- is an operator. */
00130     EXPR_MID_bit,               /* newline significant, +/- is an operator. */
00131     EXPR_FNAME_bit,             /* ignore newline, no reserved words. */
00132     EXPR_DOT_bit,               /* right after `.' or `::', no reserved words. */
00133     EXPR_CLASS_bit,             /* immediate after `class', no here document. */
00134     EXPR_VALUE_bit,             /* alike EXPR_BEG but label is disallowed. */
00135     EXPR_LABELARG_bit,          /* ignore significant, +/- is a sign. */
00136     EXPR_MAX_STATE
00137 };
00138 /* examine combinations */
00139 enum lex_state_e {
00140 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
00141     DEF_EXPR(BEG),
00142     DEF_EXPR(END),
00143     DEF_EXPR(ENDARG),
00144     DEF_EXPR(ENDFN),
00145     DEF_EXPR(ARG),
00146     DEF_EXPR(CMDARG),
00147     DEF_EXPR(MID),
00148     DEF_EXPR(FNAME),
00149     DEF_EXPR(DOT),
00150     DEF_EXPR(CLASS),
00151     DEF_EXPR(VALUE),
00152     DEF_EXPR(LABELARG),
00153     EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG),
00154     EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG),
00155     EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
00156 };
00157 #define IS_lex_state_for(x, ls) ((x) & (ls))
00158 #define IS_lex_state(ls)        IS_lex_state_for(lex_state, (ls))
00159 
00160 #if PARSER_DEBUG
00161 static const char *lex_state_name(enum lex_state_e state);
00162 #endif
00163 
00164 typedef VALUE stack_type;
00165 
00166 # define BITSTACK_PUSH(stack, n)        ((stack) = ((stack)<<1)|((n)&1))
00167 # define BITSTACK_POP(stack)    ((stack) = (stack) >> 1)
00168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
00169 # define BITSTACK_SET_P(stack)  ((stack)&1)
00170 
00171 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, (n))
00172 #define COND_POP()      BITSTACK_POP(cond_stack)
00173 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00174 #define COND_P()        BITSTACK_SET_P(cond_stack)
00175 
00176 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, (n))
00177 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00179 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00180 
00181 struct vtable {
00182     ID *tbl;
00183     int pos;
00184     int capa;
00185     struct vtable *prev;
00186 };
00187 
00188 struct local_vars {
00189     struct vtable *args;
00190     struct vtable *vars;
00191     struct vtable *used;
00192     struct local_vars *prev;
00193     stack_type cmdargs;
00194 };
00195 
00196 #define DVARS_INHERIT ((void*)1)
00197 #define DVARS_TOPSCOPE NULL
00198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00200 
00201 static int
00202 vtable_size(const struct vtable *tbl)
00203 {
00204     if (POINTER_P(tbl)) {
00205         return tbl->pos;
00206     }
00207     else {
00208         return 0;
00209     }
00210 }
00211 
00212 #define VTBL_DEBUG 0
00213 
00214 static struct vtable *
00215 vtable_alloc(struct vtable *prev)
00216 {
00217     struct vtable *tbl = ALLOC(struct vtable);
00218     tbl->pos = 0;
00219     tbl->capa = 8;
00220     tbl->tbl = ALLOC_N(ID, tbl->capa);
00221     tbl->prev = prev;
00222     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00223     return tbl;
00224 }
00225 
00226 static void
00227 vtable_free(struct vtable *tbl)
00228 {
00229     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00230     if (POINTER_P(tbl)) {
00231         if (tbl->tbl) {
00232             xfree(tbl->tbl);
00233         }
00234         xfree(tbl);
00235     }
00236 }
00237 
00238 static void
00239 vtable_add(struct vtable *tbl, ID id)
00240 {
00241     if (!POINTER_P(tbl)) {
00242         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00243     }
00244     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00245 
00246     if (tbl->pos == tbl->capa) {
00247         tbl->capa = tbl->capa * 2;
00248         REALLOC_N(tbl->tbl, ID, tbl->capa);
00249     }
00250     tbl->tbl[tbl->pos++] = id;
00251 }
00252 
00253 static int
00254 vtable_included(const struct vtable * tbl, ID id)
00255 {
00256     int i;
00257 
00258     if (POINTER_P(tbl)) {
00259         for (i = 0; i < tbl->pos; i++) {
00260             if (tbl->tbl[i] == id) {
00261                 return i+1;
00262             }
00263         }
00264     }
00265     return 0;
00266 }
00267 
00268 
00269 #ifndef RIPPER
00270 typedef struct token_info {
00271     const char *token;
00272     int linenum;
00273     int column;
00274     int nonspc;
00275     struct token_info *next;
00276 } token_info;
00277 #endif
00278 
00279 /*
00280     Structure of Lexer Buffer:
00281 
00282  lex_pbeg      tokp         lex_p        lex_pend
00283     |           |              |            |
00284     |-----------+--------------+------------|
00285                 |<------------>|
00286                      token
00287 */
00288 struct parser_params {
00289     int is_ripper;
00290     NODE *heap;
00291 
00292     YYSTYPE *parser_yylval;
00293     VALUE eofp;
00294 
00295     NODE *parser_lex_strterm;
00296     enum lex_state_e parser_lex_state;
00297     stack_type parser_cond_stack;
00298     stack_type parser_cmdarg_stack;
00299     int parser_class_nest;
00300     int parser_paren_nest;
00301     int parser_lpar_beg;
00302     int parser_in_single;
00303     int parser_in_def;
00304     int parser_brace_nest;
00305     int parser_compile_for_eval;
00306     VALUE parser_cur_mid;
00307     int parser_in_kwarg;
00308     int parser_in_defined;
00309     char *parser_tokenbuf;
00310     int parser_tokidx;
00311     int parser_toksiz;
00312     int parser_tokline;
00313     VALUE parser_lex_input;
00314     VALUE parser_lex_lastline;
00315     VALUE parser_lex_nextline;
00316     const char *parser_lex_pbeg;
00317     const char *parser_lex_p;
00318     const char *parser_lex_pend;
00319     int parser_heredoc_end;
00320     int parser_command_start;
00321     NODE *parser_deferred_nodes;
00322     long parser_lex_gets_ptr;
00323     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00324     struct local_vars *parser_lvtbl;
00325     int parser_ruby__end__seen;
00326     int line_count;
00327     int has_shebang;
00328     char *parser_ruby_sourcefile; /* current source file */
00329     int parser_ruby_sourceline; /* current line no. */
00330     VALUE parser_ruby_sourcefile_string;
00331     rb_encoding *enc;
00332 
00333     int parser_yydebug;
00334 
00335     int last_cr_line;
00336 
00337 #ifndef RIPPER
00338     /* Ruby core only */
00339     NODE *parser_eval_tree_begin;
00340     NODE *parser_eval_tree;
00341     VALUE debug_lines;
00342     VALUE coverage;
00343     int nerr;
00344 
00345     int parser_token_info_enabled;
00346     token_info *parser_token_info;
00347 #else
00348     /* Ripper only */
00349     const char *tokp;
00350     VALUE delayed;
00351     int delayed_line;
00352     int delayed_col;
00353 
00354     VALUE value;
00355     VALUE result;
00356     VALUE parsing_thread;
00357     int toplevel_p;
00358 #endif
00359 };
00360 
00361 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
00362 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
00363 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
00364 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
00365 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00366 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
00367 
00368 static int parser_yyerror(struct parser_params*, const char*);
00369 #define yyerror(msg) parser_yyerror(parser, (msg))
00370 
00371 #define lex_strterm             (parser->parser_lex_strterm)
00372 #define lex_state               (parser->parser_lex_state)
00373 #define cond_stack              (parser->parser_cond_stack)
00374 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00375 #define class_nest              (parser->parser_class_nest)
00376 #define paren_nest              (parser->parser_paren_nest)
00377 #define lpar_beg                (parser->parser_lpar_beg)
00378 #define brace_nest              (parser->parser_brace_nest)
00379 #define in_single               (parser->parser_in_single)
00380 #define in_def                  (parser->parser_in_def)
00381 #define compile_for_eval        (parser->parser_compile_for_eval)
00382 #define cur_mid                 (parser->parser_cur_mid)
00383 #define in_defined              (parser->parser_in_defined)
00384 #define tokenbuf                (parser->parser_tokenbuf)
00385 #define tokidx                  (parser->parser_tokidx)
00386 #define toksiz                  (parser->parser_toksiz)
00387 #define tokline                 (parser->parser_tokline)
00388 #define lex_input               (parser->parser_lex_input)
00389 #define lex_lastline            (parser->parser_lex_lastline)
00390 #define lex_nextline            (parser->parser_lex_nextline)
00391 #define lex_pbeg                (parser->parser_lex_pbeg)
00392 #define lex_p                   (parser->parser_lex_p)
00393 #define lex_pend                (parser->parser_lex_pend)
00394 #define heredoc_end             (parser->parser_heredoc_end)
00395 #define command_start           (parser->parser_command_start)
00396 #define deferred_nodes          (parser->parser_deferred_nodes)
00397 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00398 #define lex_gets                (parser->parser_lex_gets)
00399 #define lvtbl                   (parser->parser_lvtbl)
00400 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00401 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00402 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00403 #define ruby_sourcefile_string  (parser->parser_ruby_sourcefile_string)
00404 #define current_enc             (parser->enc)
00405 #define yydebug                 (parser->parser_yydebug)
00406 #ifdef RIPPER
00407 #else
00408 #define ruby_eval_tree          (parser->parser_eval_tree)
00409 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00410 #define ruby_debug_lines        (parser->debug_lines)
00411 #define ruby_coverage           (parser->coverage)
00412 #endif
00413 
00414 #if YYPURE
00415 static int yylex(void*, void*);
00416 #else
00417 static int yylex(void*);
00418 #endif
00419 
00420 #ifndef RIPPER
00421 #define yyparse ruby_yyparse
00422 
00423 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00424 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
00425 
00426 static NODE *cond_gen(struct parser_params*,NODE*);
00427 #define cond(node) cond_gen(parser, (node))
00428 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00429 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
00430 
00431 static NODE *newline_node(NODE*);
00432 static void fixpos(NODE*,NODE*);
00433 
00434 static int value_expr_gen(struct parser_params*,NODE*);
00435 static void void_expr_gen(struct parser_params*,NODE*);
00436 static NODE *remove_begin(NODE*);
00437 static NODE *remove_begin_all(NODE*);
00438 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00439 #define void_expr0(node) void_expr_gen(parser, (node))
00440 #define void_expr(node) void_expr0((node) = remove_begin(node))
00441 static void void_stmts_gen(struct parser_params*,NODE*);
00442 #define void_stmts(node) void_stmts_gen(parser, (node))
00443 static void reduce_nodes_gen(struct parser_params*,NODE**);
00444 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
00445 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00446 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
00447 
00448 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00449 #define block_append(h,t) block_append_gen(parser,(h),(t))
00450 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00451 #define list_append(l,i) list_append_gen(parser,(l),(i))
00452 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00453 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
00454 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00455 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
00456 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00457 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
00458 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00459 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
00460 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00461 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00462 #define new_evstr(n) new_evstr_gen(parser,(n))
00463 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00464 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
00465 static NODE *splat_array(NODE*);
00466 
00467 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00468 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
00469 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00470 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
00471 
00472 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
00473 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00474 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
00475 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00476 
00477 static NODE *negate_lit(NODE*);
00478 static NODE *ret_args_gen(struct parser_params*,NODE*);
00479 #define ret_args(node) ret_args_gen(parser, (node))
00480 static NODE *arg_blk_pass(NODE*,NODE*);
00481 static NODE *new_yield_gen(struct parser_params*,NODE*);
00482 #define new_yield(node) new_yield_gen(parser, (node))
00483 static NODE *dsym_node_gen(struct parser_params*,NODE*);
00484 #define dsym_node(node) dsym_node_gen(parser, (node))
00485 
00486 static NODE *gettable_gen(struct parser_params*,ID);
00487 #define gettable(id) gettable_gen(parser,(id))
00488 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00489 #define assignable(id,node) assignable_gen(parser, (id), (node))
00490 
00491 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00492 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
00493 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00494 #define attrset(node,id) attrset_gen(parser, (node), (id))
00495 
00496 static void rb_backref_error_gen(struct parser_params*,NODE*);
00497 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
00498 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00499 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
00500 
00501 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00502 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
00503 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
00504 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00505 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
00506 
00507 #define new_defined(expr) NEW_DEFINED(remove_begin_all(expr))
00508 
00509 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00510 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
00511 
00512 static ID  *local_tbl_gen(struct parser_params*);
00513 #define local_tbl() local_tbl_gen(parser)
00514 
00515 static void fixup_nodes(NODE **);
00516 
00517 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00518 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
00519 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00520 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
00521 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00522 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
00523 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00524 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
00525 
00526 #define get_id(id) (id)
00527 #define get_value(val) (val)
00528 #else
00529 #define value_expr(node) ((void)(node))
00530 #define remove_begin(node) (node)
00531 #define rb_dvar_defined(id) 0
00532 #define rb_local_defined(id) 0
00533 static ID ripper_get_id(VALUE);
00534 #define get_id(id) ripper_get_id(id)
00535 static VALUE ripper_get_value(VALUE);
00536 #define get_value(val) ripper_get_value(val)
00537 static VALUE assignable_gen(struct parser_params*,VALUE);
00538 #define assignable(lhs,node) assignable_gen(parser, (lhs))
00539 static int id_is_var_gen(struct parser_params *parser, ID id);
00540 #define id_is_var(id) id_is_var_gen(parser, (id))
00541 
00542 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
00543 
00544 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
00545 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
00546 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
00547 
00548 #endif /* !RIPPER */
00549 
00550 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
00551 
00552 static ID formal_argument_gen(struct parser_params*, ID);
00553 #define formal_argument(id) formal_argument_gen(parser, (id))
00554 static ID shadowing_lvar_gen(struct parser_params*,ID);
00555 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
00556 static void new_bv_gen(struct parser_params*,ID);
00557 #define new_bv(id) new_bv_gen(parser, (id))
00558 
00559 static void local_push_gen(struct parser_params*,int);
00560 #define local_push(top) local_push_gen(parser,(top))
00561 static void local_pop_gen(struct parser_params*);
00562 #define local_pop() local_pop_gen(parser)
00563 static int local_var_gen(struct parser_params*, ID);
00564 #define local_var(id) local_var_gen(parser, (id))
00565 static int arg_var_gen(struct parser_params*, ID);
00566 #define arg_var(id) arg_var_gen(parser, (id))
00567 static int  local_id_gen(struct parser_params*, ID);
00568 #define local_id(id) local_id_gen(parser, (id))
00569 static ID   internal_id_gen(struct parser_params*);
00570 #define internal_id() internal_id_gen(parser)
00571 
00572 static const struct vtable *dyna_push_gen(struct parser_params *);
00573 #define dyna_push() dyna_push_gen(parser)
00574 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00575 #define dyna_pop(node) dyna_pop_gen(parser, (node))
00576 static int dyna_in_block_gen(struct parser_params*);
00577 #define dyna_in_block() dyna_in_block_gen(parser)
00578 #define dyna_var(id) local_var(id)
00579 static int dvar_defined_gen(struct parser_params*,ID,int);
00580 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
00581 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
00582 static int dvar_curr_gen(struct parser_params*,ID);
00583 #define dvar_curr(id) dvar_curr_gen(parser, (id))
00584 
00585 static int lvar_defined_gen(struct parser_params*, ID);
00586 #define lvar_defined(id) lvar_defined_gen(parser, (id))
00587 
00588 #define RE_OPTION_ONCE (1<<16)
00589 #define RE_OPTION_ENCODING_SHIFT 8
00590 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00591 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00592 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00593 #define RE_OPTION_MASK  0xff
00594 #define RE_OPTION_ARG_ENCODING_NONE 32
00595 
00596 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00597 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00598 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00599 #define nd_func u1.id
00600 #if SIZEOF_SHORT == 2
00601 #define nd_term(node) ((signed short)(node)->u2.id)
00602 #else
00603 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00604 #endif
00605 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00606 #define nd_nest u3.cnt
00607 
00608 /****** Ripper *******/
00609 
00610 #ifdef RIPPER
00611 #define RIPPER_VERSION "0.1.0"
00612 
00613 #include "eventids1.c"
00614 #include "eventids2.c"
00615 
00616 static VALUE ripper_dispatch0(struct parser_params*,ID);
00617 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00618 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00619 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00620 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00621 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00622 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
00623 
00624 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00625 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
00626 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
00627 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
00628 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
00629 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
00630 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
00631 
00632 #define yyparse ripper_yyparse
00633 
00634 #define ripper_intern(s) ID2SYM(rb_intern(s))
00635 static VALUE ripper_id2sym(ID);
00636 #ifdef __GNUC__
00637 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00638                            ID2SYM(id) : ripper_id2sym(id))
00639 #endif
00640 
00641 #define arg_new() dispatch0(args_new)
00642 #define arg_add(l,a) dispatch2(args_add, (l), (a))
00643 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
00644 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
00645 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
00646 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
00647 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
00648 
00649 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
00650 #define mrhs_new() dispatch0(mrhs_new)
00651 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
00652 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
00653 
00654 #define mlhs_new() dispatch0(mlhs_new)
00655 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
00656 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
00657 
00658 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
00659         dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
00660 
00661 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
00662 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
00663 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
00664 
00665 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
00666 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
00667 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
00668 
00669 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00670 
00671 static inline VALUE
00672 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
00673 {
00674     NODE *t = (NODE *)tail;
00675     VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
00676     return params_new(f, o, r, p, k, kr, escape_Qundef(b));
00677 }
00678 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00679 
00680 static inline VALUE
00681 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
00682 {
00683     return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
00684 }
00685 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00686 
00687 #define new_defined(expr) dispatch1(defined, (expr))
00688 
00689 #define FIXME 0
00690 
00691 #endif /* RIPPER */
00692 
00693 #ifndef RIPPER
00694 # define Qnone 0
00695 # define ifndef_ripper(x) (x)
00696 #else
00697 # define Qnone Qnil
00698 # define ifndef_ripper(x)
00699 #endif
00700 
00701 #ifndef RIPPER
00702 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
00703 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00704 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00705 # define rb_warn4S(file,line,fmt,a)  rb_compile_warn((file), (line), (fmt), (a))
00706 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
00707 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00708 #else
00709 # define rb_warn0(fmt)    ripper_warn0(parser, (fmt))
00710 # define rb_warnI(fmt,a)  ripper_warnI(parser, (fmt), (a))
00711 # define rb_warnS(fmt,a)  ripper_warnS(parser, (fmt), (a))
00712 # define rb_warn4S(file,line,fmt,a)  ripper_warnS(parser, (fmt), (a))
00713 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
00714 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
00715 static void ripper_warn0(struct parser_params*, const char*);
00716 static void ripper_warnI(struct parser_params*, const char*, int);
00717 static void ripper_warnS(struct parser_params*, const char*, const char*);
00718 static void ripper_warning0(struct parser_params*, const char*);
00719 static void ripper_warningS(struct parser_params*, const char*, const char*);
00720 #endif
00721 
00722 #ifdef RIPPER
00723 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00724 # define rb_compile_error ripper_compile_error
00725 # define compile_error ripper_compile_error
00726 # define PARSER_ARG parser,
00727 #else
00728 # define rb_compile_error rb_compile_error_with_enc
00729 # define compile_error parser->nerr++,rb_compile_error_with_enc
00730 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
00731 #endif
00732 
00733 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00734    for instance).  This is too low for Ruby to parse some files, such as
00735    date/format.rb, therefore bump the value up to at least Bison's default. */
00736 #ifdef OLD_YACC
00737 #ifndef YYMAXDEPTH
00738 #define YYMAXDEPTH 10000
00739 #endif
00740 #endif
00741 
00742 #ifndef RIPPER
00743 static void token_info_push(struct parser_params*, const char *token);
00744 static void token_info_pop(struct parser_params*, const char *token);
00745 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
00746 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
00747 #else
00748 #define token_info_push(token) /* nothing */
00749 #define token_info_pop(token) /* nothing */
00750 #endif
00751 
00752 
00753 /* Line 268 of yacc.c  */
00754 #line 755 "parse.c"
00755 
00756 /* Enabling traces.  */
00757 #ifndef YYDEBUG
00758 # define YYDEBUG 1
00759 #endif
00760 
00761 /* Enabling verbose error messages.  */
00762 #ifdef YYERROR_VERBOSE
00763 # undef YYERROR_VERBOSE
00764 # define YYERROR_VERBOSE 1
00765 #else
00766 # define YYERROR_VERBOSE 0
00767 #endif
00768 
00769 /* Enabling the token table.  */
00770 #ifndef YYTOKEN_TABLE
00771 # define YYTOKEN_TABLE 0
00772 #endif
00773 
00774 
00775 /* Tokens.  */
00776 #ifndef YYTOKENTYPE
00777 # define YYTOKENTYPE
00778    /* Put the tokens into the symbol table, so that GDB and other debuggers
00779       know about them.  */
00780    enum yytokentype {
00781      END_OF_INPUT = 0,
00782      keyword_class = 258,
00783      keyword_module = 259,
00784      keyword_def = 260,
00785      keyword_undef = 261,
00786      keyword_begin = 262,
00787      keyword_rescue = 263,
00788      keyword_ensure = 264,
00789      keyword_end = 265,
00790      keyword_if = 266,
00791      keyword_unless = 267,
00792      keyword_then = 268,
00793      keyword_elsif = 269,
00794      keyword_else = 270,
00795      keyword_case = 271,
00796      keyword_when = 272,
00797      keyword_while = 273,
00798      keyword_until = 274,
00799      keyword_for = 275,
00800      keyword_break = 276,
00801      keyword_next = 277,
00802      keyword_redo = 278,
00803      keyword_retry = 279,
00804      keyword_in = 280,
00805      keyword_do = 281,
00806      keyword_do_cond = 282,
00807      keyword_do_block = 283,
00808      keyword_do_LAMBDA = 284,
00809      keyword_return = 285,
00810      keyword_yield = 286,
00811      keyword_super = 287,
00812      keyword_self = 288,
00813      keyword_nil = 289,
00814      keyword_true = 290,
00815      keyword_false = 291,
00816      keyword_and = 292,
00817      keyword_or = 293,
00818      keyword_not = 294,
00819      modifier_if = 295,
00820      modifier_unless = 296,
00821      modifier_while = 297,
00822      modifier_until = 298,
00823      modifier_rescue = 299,
00824      keyword_alias = 300,
00825      keyword_defined = 301,
00826      keyword_BEGIN = 302,
00827      keyword_END = 303,
00828      keyword__LINE__ = 304,
00829      keyword__FILE__ = 305,
00830      keyword__ENCODING__ = 306,
00831      tIDENTIFIER = 307,
00832      tFID = 308,
00833      tGVAR = 309,
00834      tIVAR = 310,
00835      tCONSTANT = 311,
00836      tCVAR = 312,
00837      tLABEL = 313,
00838      tINTEGER = 314,
00839      tFLOAT = 315,
00840      tRATIONAL = 316,
00841      tIMAGINARY = 317,
00842      tSTRING_CONTENT = 318,
00843      tCHAR = 319,
00844      tNTH_REF = 320,
00845      tBACK_REF = 321,
00846      tREGEXP_END = 322,
00847      tUPLUS = 130,
00848      tUMINUS = 131,
00849      tPOW = 132,
00850      tCMP = 134,
00851      tEQ = 139,
00852      tEQQ = 140,
00853      tNEQ = 141,
00854      tGEQ = 138,
00855      tLEQ = 137,
00856      tANDOP = 323,
00857      tOROP = 324,
00858      tMATCH = 142,
00859      tNMATCH = 143,
00860      tDOT2 = 128,
00861      tDOT3 = 129,
00862      tAREF = 144,
00863      tASET = 145,
00864      tLSHFT = 135,
00865      tRSHFT = 136,
00866      tCOLON2 = 325,
00867      tCOLON3 = 326,
00868      tOP_ASGN = 327,
00869      tASSOC = 328,
00870      tLPAREN = 329,
00871      tLPAREN_ARG = 330,
00872      tRPAREN = 331,
00873      tLBRACK = 332,
00874      tLBRACE = 333,
00875      tLBRACE_ARG = 334,
00876      tSTAR = 335,
00877      tDSTAR = 336,
00878      tAMPER = 337,
00879      tLAMBDA = 338,
00880      tSYMBEG = 339,
00881      tSTRING_BEG = 340,
00882      tXSTRING_BEG = 341,
00883      tREGEXP_BEG = 342,
00884      tWORDS_BEG = 343,
00885      tQWORDS_BEG = 344,
00886      tSYMBOLS_BEG = 345,
00887      tQSYMBOLS_BEG = 346,
00888      tSTRING_DBEG = 347,
00889      tSTRING_DEND = 348,
00890      tSTRING_DVAR = 349,
00891      tSTRING_END = 350,
00892      tLAMBEG = 351,
00893      tLOWEST = 352,
00894      tUMINUS_NUM = 353,
00895      tLAST_TOKEN = 354
00896    };
00897 #endif
00898 
00899 
00900 
00901 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00902 typedef union YYSTYPE
00903 {
00904 
00905 /* Line 293 of yacc.c  */
00906 #line 699 "ripper.y"
00907 
00908     VALUE val;
00909     NODE *node;
00910     ID id;
00911     int num;
00912     const struct vtable *vars;
00913 
00914 
00915 
00916 /* Line 293 of yacc.c  */
00917 #line 918 "parse.c"
00918 } YYSTYPE;
00919 # define YYSTYPE_IS_TRIVIAL 1
00920 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00921 # define YYSTYPE_IS_DECLARED 1
00922 #endif
00923 
00924 
00925 /* Copy the second part of user declarations.  */
00926 
00927 
00928 /* Line 343 of yacc.c  */
00929 #line 930 "parse.c"
00930 
00931 #ifdef short
00932 # undef short
00933 #endif
00934 
00935 #ifdef YYTYPE_UINT8
00936 typedef YYTYPE_UINT8 yytype_uint8;
00937 #else
00938 typedef unsigned char yytype_uint8;
00939 #endif
00940 
00941 #ifdef YYTYPE_INT8
00942 typedef YYTYPE_INT8 yytype_int8;
00943 #elif (defined __STDC__ || defined __C99__FUNC__ \
00944      || defined __cplusplus || defined _MSC_VER)
00945 typedef signed char yytype_int8;
00946 #else
00947 typedef short int yytype_int8;
00948 #endif
00949 
00950 #ifdef YYTYPE_UINT16
00951 typedef YYTYPE_UINT16 yytype_uint16;
00952 #else
00953 typedef unsigned short int yytype_uint16;
00954 #endif
00955 
00956 #ifdef YYTYPE_INT16
00957 typedef YYTYPE_INT16 yytype_int16;
00958 #else
00959 typedef short int yytype_int16;
00960 #endif
00961 
00962 #ifndef YYSIZE_T
00963 # ifdef __SIZE_TYPE__
00964 #  define YYSIZE_T __SIZE_TYPE__
00965 # elif defined size_t
00966 #  define YYSIZE_T size_t
00967 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00968      || defined __cplusplus || defined _MSC_VER)
00969 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00970 #  define YYSIZE_T size_t
00971 # else
00972 #  define YYSIZE_T unsigned int
00973 # endif
00974 #endif
00975 
00976 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00977 
00978 #ifndef YY_
00979 # if defined YYENABLE_NLS && YYENABLE_NLS
00980 #  if ENABLE_NLS
00981 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00982 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00983 #  endif
00984 # endif
00985 # ifndef YY_
00986 #  define YY_(msgid) msgid
00987 # endif
00988 #endif
00989 
00990 /* Suppress unused-variable warnings by "using" E.  */
00991 #if ! defined lint || defined __GNUC__
00992 # define YYUSE(e) ((void) (e))
00993 #else
00994 # define YYUSE(e) /* empty */
00995 #endif
00996 
00997 /* Identity function, used to suppress warnings about constant conditions.  */
00998 #ifndef lint
00999 # define YYID(n) (n)
01000 #else
01001 #if (defined __STDC__ || defined __C99__FUNC__ \
01002      || defined __cplusplus || defined _MSC_VER)
01003 static int
01004 YYID (int yyi)
01005 #else
01006 static int
01007 YYID (yyi)
01008     int yyi;
01009 #endif
01010 {
01011   return yyi;
01012 }
01013 #endif
01014 
01015 #if ! defined yyoverflow || YYERROR_VERBOSE
01016 
01017 /* The parser invokes alloca or malloc; define the necessary symbols.  */
01018 
01019 # ifdef YYSTACK_USE_ALLOCA
01020 #  if YYSTACK_USE_ALLOCA
01021 #   ifdef __GNUC__
01022 #    define YYSTACK_ALLOC __builtin_alloca
01023 #   elif defined __BUILTIN_VA_ARG_INCR
01024 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
01025 #   elif defined _AIX
01026 #    define YYSTACK_ALLOC __alloca
01027 #   elif defined _MSC_VER
01028 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
01029 #    define alloca _alloca
01030 #   else
01031 #    define YYSTACK_ALLOC alloca
01032 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01033      || defined __cplusplus || defined _MSC_VER)
01034 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01035 #     ifndef EXIT_SUCCESS
01036 #      define EXIT_SUCCESS 0
01037 #     endif
01038 #    endif
01039 #   endif
01040 #  endif
01041 # endif
01042 
01043 # ifdef YYSTACK_ALLOC
01044    /* Pacify GCC's `empty if-body' warning.  */
01045 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
01046 #  ifndef YYSTACK_ALLOC_MAXIMUM
01047     /* The OS might guarantee only one guard page at the bottom of the stack,
01048        and a page size can be as small as 4096 bytes.  So we cannot safely
01049        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01050        to allow for a few compiler-allocated temporary stack slots.  */
01051 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01052 #  endif
01053 # else
01054 #  define YYSTACK_ALLOC YYMALLOC
01055 #  define YYSTACK_FREE YYFREE
01056 #  ifndef YYSTACK_ALLOC_MAXIMUM
01057 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01058 #  endif
01059 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
01060        && ! ((defined YYMALLOC || defined malloc) \
01061              && (defined YYFREE || defined free)))
01062 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01063 #   ifndef EXIT_SUCCESS
01064 #    define EXIT_SUCCESS 0
01065 #   endif
01066 #  endif
01067 #  ifndef YYMALLOC
01068 #   define YYMALLOC malloc
01069 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01070      || defined __cplusplus || defined _MSC_VER)
01071 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01072 #   endif
01073 #  endif
01074 #  ifndef YYFREE
01075 #   define YYFREE free
01076 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01077      || defined __cplusplus || defined _MSC_VER)
01078 void free (void *); /* INFRINGES ON USER NAME SPACE */
01079 #   endif
01080 #  endif
01081 # endif
01082 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01083 
01084 
01085 #if (! defined yyoverflow \
01086      && (! defined __cplusplus \
01087          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01088 
01089 /* A type that is properly aligned for any stack member.  */
01090 union yyalloc
01091 {
01092   yytype_int16 yyss_alloc;
01093   YYSTYPE yyvs_alloc;
01094 };
01095 
01096 /* The size of the maximum gap between one aligned stack and the next.  */
01097 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01098 
01099 /* The size of an array large to enough to hold all stacks, each with
01100    N elements.  */
01101 # define YYSTACK_BYTES(N) \
01102      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01103       + YYSTACK_GAP_MAXIMUM)
01104 
01105 # define YYCOPY_NEEDED 1
01106 
01107 /* Relocate STACK from its old location to the new one.  The
01108    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01109    elements in the stack, and YYPTR gives the new location of the
01110    stack.  Advance YYPTR to a properly aligned location for the next
01111    stack.  */
01112 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01113     do                                                                  \
01114       {                                                                 \
01115         YYSIZE_T yynewbytes;                                            \
01116         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01117         Stack = &yyptr->Stack_alloc;                                    \
01118         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01119         yyptr += yynewbytes / sizeof (*yyptr);                          \
01120       }                                                                 \
01121     while (YYID (0))
01122 
01123 #endif
01124 
01125 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
01126 /* Copy COUNT objects from FROM to TO.  The source and destination do
01127    not overlap.  */
01128 # ifndef YYCOPY
01129 #  if defined __GNUC__ && 1 < __GNUC__
01130 #   define YYCOPY(To, From, Count) \
01131       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01132 #  else
01133 #   define YYCOPY(To, From, Count)              \
01134       do                                        \
01135         {                                       \
01136           YYSIZE_T yyi;                         \
01137           for (yyi = 0; yyi < (Count); yyi++)   \
01138             (To)[yyi] = (From)[yyi];            \
01139         }                                       \
01140       while (YYID (0))
01141 #  endif
01142 # endif
01143 #endif /* !YYCOPY_NEEDED */
01144 
01145 /* YYFINAL -- State number of the termination state.  */
01146 #define YYFINAL  3
01147 /* YYLAST -- Last index in YYTABLE.  */
01148 #define YYLAST   11083
01149 
01150 /* YYNTOKENS -- Number of terminals.  */
01151 #define YYNTOKENS  144
01152 /* YYNNTS -- Number of nonterminals.  */
01153 #define YYNNTS  204
01154 /* YYNRULES -- Number of rules.  */
01155 #define YYNRULES  627
01156 /* YYNRULES -- Number of states.  */
01157 #define YYNSTATES  1060
01158 
01159 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01160 #define YYUNDEFTOK  2
01161 #define YYMAXUTOK   354
01162 
01163 #define YYTRANSLATE(YYX)                                                \
01164   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01165 
01166 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01167 static const yytype_uint8 yytranslate[] =
01168 {
01169        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01170      143,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01171        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01172        2,     2,   142,   129,     2,     2,     2,   127,   122,     2,
01173      138,   139,   125,   123,   136,   124,   135,   126,     2,     2,
01174        2,     2,     2,     2,     2,     2,     2,     2,   117,   141,
01175      119,   115,   118,   116,     2,     2,     2,     2,     2,     2,
01176        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01177        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01178        2,   134,     2,   140,   121,     2,   137,     2,     2,     2,
01179        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01180        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01181        2,     2,     2,   132,   120,   133,   130,     2,    81,    82,
01182       68,    69,    70,     2,    71,    85,    86,    76,    75,    72,
01183       73,    74,    79,    80,    83,    84,     2,     2,     2,     2,
01184        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01185        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01186        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01187        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01188        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01189        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01190        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01191        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01192        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01193        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01194        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01195        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01196       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01197       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01198       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01199       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01200       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01201       65,    66,    67,    77,    78,    87,    88,    89,    90,    91,
01202       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
01203      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
01204      112,   113,   114,   128,   131
01205 };
01206 
01207 #if YYDEBUG
01208 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01209    YYRHS.  */
01210 static const yytype_uint16 yyprhs[] =
01211 {
01212        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01213       23,    24,    30,    35,    38,    40,    42,    46,    49,    51,
01214       52,    58,    59,    64,    68,    72,    76,    79,    83,    87,
01215       91,    95,    99,   104,   106,   110,   114,   121,   127,   133,
01216      139,   145,   149,   153,   157,   159,   163,   167,   169,   173,
01217      177,   181,   184,   186,   188,   190,   192,   194,   199,   200,
01218      206,   208,   211,   215,   220,   226,   231,   237,   240,   243,
01219      246,   249,   252,   254,   258,   260,   264,   266,   269,   273,
01220      279,   282,   287,   290,   295,   297,   301,   303,   307,   310,
01221      314,   316,   320,   322,   324,   329,   333,   337,   341,   345,
01222      348,   350,   352,   354,   359,   363,   367,   371,   375,   378,
01223      380,   382,   384,   387,   389,   393,   395,   397,   399,   401,
01224      403,   405,   407,   409,   411,   413,   414,   419,   421,   423,
01225      425,   427,   429,   431,   433,   435,   437,   439,   441,   443,
01226      445,   447,   449,   451,   453,   455,   457,   459,   461,   463,
01227      465,   467,   469,   471,   473,   475,   477,   479,   481,   483,
01228      485,   487,   489,   491,   493,   495,   497,   499,   501,   503,
01229      505,   507,   509,   511,   513,   515,   517,   519,   521,   523,
01230      525,   527,   529,   531,   533,   535,   537,   539,   541,   543,
01231      545,   547,   549,   551,   553,   555,   557,   559,   561,   565,
01232      571,   575,   581,   588,   594,   600,   606,   612,   617,   621,
01233      625,   629,   633,   637,   641,   645,   649,   653,   658,   661,
01234      664,   668,   672,   676,   680,   684,   688,   692,   696,   700,
01235      704,   708,   712,   716,   719,   722,   726,   730,   734,   738,
01236      739,   744,   751,   753,   755,   757,   760,   765,   768,   772,
01237      774,   776,   778,   780,   783,   788,   791,   793,   796,   799,
01238      804,   806,   807,   810,   813,   816,   818,   820,   823,   827,
01239      832,   834,   836,   840,   845,   848,   850,   852,   854,   856,
01240      858,   860,   862,   864,   866,   868,   870,   871,   876,   877,
01241      881,   882,   883,   889,   893,   897,   900,   904,   908,   910,
01242      915,   919,   921,   922,   929,   934,   938,   941,   943,   946,
01243      949,   956,   963,   964,   965,   973,   974,   975,   983,   989,
01244      994,   995,   996,  1006,  1007,  1014,  1015,  1016,  1025,  1026,
01245     1032,  1033,  1040,  1041,  1042,  1052,  1054,  1056,  1058,  1060,
01246     1062,  1064,  1066,  1068,  1070,  1072,  1074,  1076,  1078,  1080,
01247     1082,  1084,  1086,  1088,  1091,  1093,  1095,  1097,  1103,  1105,
01248     1108,  1110,  1112,  1114,  1118,  1120,  1124,  1126,  1131,  1138,
01249     1142,  1148,  1151,  1156,  1158,  1162,  1167,  1170,  1173,  1175,
01250     1178,  1179,  1186,  1195,  1200,  1207,  1212,  1215,  1222,  1225,
01251     1230,  1237,  1240,  1245,  1248,  1253,  1255,  1257,  1259,  1263,
01252     1265,  1270,  1272,  1277,  1279,  1283,  1285,  1287,  1288,  1289,
01253     1290,  1291,  1298,  1303,  1305,  1309,  1313,  1314,  1320,  1323,
01254     1328,  1334,  1340,  1343,  1344,  1350,  1351,  1357,  1361,  1362,
01255     1367,  1368,  1373,  1376,  1378,  1383,  1384,  1390,  1391,  1397,
01256     1403,  1405,  1407,  1414,  1416,  1418,  1420,  1422,  1425,  1427,
01257     1430,  1432,  1434,  1436,  1438,  1440,  1442,  1444,  1447,  1451,
01258     1455,  1459,  1463,  1467,  1468,  1472,  1474,  1477,  1481,  1485,
01259     1486,  1490,  1494,  1498,  1502,  1506,  1507,  1511,  1512,  1516,
01260     1517,  1520,  1521,  1524,  1525,  1528,  1530,  1531,  1535,  1536,
01261     1537,  1538,  1545,  1547,  1549,  1551,  1553,  1556,  1558,  1560,
01262     1562,  1564,  1568,  1570,  1573,  1575,  1577,  1579,  1581,  1583,
01263     1585,  1587,  1589,  1591,  1593,  1595,  1597,  1599,  1601,  1603,
01264     1605,  1607,  1609,  1611,  1613,  1615,  1617,  1619,  1620,  1625,
01265     1628,  1632,  1633,  1637,  1642,  1645,  1648,  1650,  1653,  1654,
01266     1661,  1670,  1675,  1682,  1687,  1694,  1697,  1702,  1709,  1712,
01267     1717,  1720,  1725,  1727,  1728,  1730,  1732,  1734,  1736,  1738,
01268     1740,  1742,  1746,  1748,  1752,  1754,  1757,  1759,  1762,  1764,
01269     1766,  1770,  1772,  1776,  1778,  1780,  1783,  1785,  1789,  1793,
01270     1795,  1799,  1801,  1805,  1807,  1809,  1812,  1814,  1816,  1818,
01271     1821,  1824,  1826,  1828,  1829,  1834,  1836,  1839,  1841,  1845,
01272     1849,  1852,  1855,  1857,  1859,  1861,  1863,  1865,  1867,  1869,
01273     1871,  1873,  1875,  1877,  1879,  1880,  1882,  1883,  1885,  1888,
01274     1891,  1892,  1894,  1896,  1898,  1900,  1902,  1905
01275 };
01276 
01277 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01278 static const yytype_int16 yyrhs[] =
01279 {
01280      145,     0,    -1,    -1,   146,   147,    -1,   148,   340,    -1,
01281      347,    -1,   149,    -1,   148,   346,   149,    -1,     1,   149,
01282       -1,   156,    -1,    -1,    47,   150,   132,   147,   133,    -1,
01283      152,   266,   233,   269,    -1,   153,   340,    -1,   347,    -1,
01284      154,    -1,   153,   346,   154,    -1,     1,   156,    -1,   156,
01285       -1,    -1,    47,   155,   132,   147,   133,    -1,    -1,    45,
01286      179,   157,   179,    -1,    45,    54,    54,    -1,    45,    54,
01287       66,    -1,    45,    54,    65,    -1,     6,   180,    -1,   156,
01288       40,   160,    -1,   156,    41,   160,    -1,   156,    42,   160,
01289       -1,   156,    43,   160,    -1,   156,    44,   156,    -1,    48,
01290      132,   152,   133,    -1,   158,    -1,   167,   115,   161,    -1,
01291      302,    89,   161,    -1,   218,   134,   190,   343,    89,   161,
01292       -1,   218,   135,    52,    89,   161,    -1,   218,   135,    56,
01293       89,   161,    -1,   218,    87,    56,    89,   161,    -1,   218,
01294       87,    52,    89,   161,    -1,   303,    89,   161,    -1,   174,
01295      115,   198,    -1,   167,   115,   197,    -1,   159,    -1,   174,
01296      115,   161,    -1,   174,   115,   158,    -1,   161,    -1,   159,
01297       37,   159,    -1,   159,    38,   159,    -1,    39,   341,   159,
01298       -1,   129,   161,    -1,   184,    -1,   159,    -1,   166,    -1,
01299      162,    -1,   255,    -1,   255,   339,   337,   192,    -1,    -1,
01300       96,   164,   241,   152,   133,    -1,   336,    -1,   165,   192,
01301       -1,   165,   192,   163,    -1,   218,   135,   337,   192,    -1,
01302      218,   135,   337,   192,   163,    -1,   218,    87,   337,   192,
01303       -1,   218,    87,   337,   192,   163,    -1,    32,   192,    -1,
01304       31,   192,    -1,    30,   191,    -1,    21,   191,    -1,    22,
01305      191,    -1,   169,    -1,    91,   168,   342,    -1,   169,    -1,
01306       91,   168,   342,    -1,   171,    -1,   171,   170,    -1,   171,
01307       97,   173,    -1,   171,    97,   173,   136,   172,    -1,   171,
01308       97,    -1,   171,    97,   136,   172,    -1,    97,   173,    -1,
01309       97,   173,   136,   172,    -1,    97,    -1,    97,   136,   172,
01310       -1,   173,    -1,    91,   168,   342,    -1,   170,   136,    -1,
01311      171,   170,   136,    -1,   170,    -1,   172,   136,   170,    -1,
01312      299,    -1,   300,    -1,   218,   134,   190,   343,    -1,   218,
01313      135,    52,    -1,   218,    87,    52,    -1,   218,   135,    56,
01314       -1,   218,    87,    56,    -1,    88,    56,    -1,   303,    -1,
01315      299,    -1,   300,    -1,   218,   134,   190,   343,    -1,   218,
01316      135,    52,    -1,   218,    87,    52,    -1,   218,   135,    56,
01317       -1,   218,    87,    56,    -1,    88,    56,    -1,   303,    -1,
01318       52,    -1,    56,    -1,    88,   175,    -1,   175,    -1,   218,
01319       87,   175,    -1,    52,    -1,    56,    -1,    53,    -1,   182,
01320       -1,   183,    -1,   177,    -1,   294,    -1,   178,    -1,   296,
01321       -1,   179,    -1,    -1,   180,   136,   181,   179,    -1,   120,
01322       -1,   121,    -1,   122,    -1,    71,    -1,    72,    -1,    73,
01323       -1,    79,    -1,    80,    -1,   118,    -1,    75,    -1,   119,
01324       -1,    76,    -1,    74,    -1,    85,    -1,    86,    -1,   123,
01325       -1,   124,    -1,   125,    -1,    97,    -1,   126,    -1,   127,
01326       -1,    70,    -1,    98,    -1,   129,    -1,   130,    -1,    68,
01327       -1,    69,    -1,    83,    -1,    84,    -1,   137,    -1,    49,
01328       -1,    50,    -1,    51,    -1,    47,    -1,    48,    -1,    45,
01329       -1,    37,    -1,     7,    -1,    21,    -1,    16,    -1,     3,
01330       -1,     5,    -1,    46,    -1,    26,    -1,    15,    -1,    14,
01331       -1,    10,    -1,     9,    -1,    36,    -1,    20,    -1,    25,
01332       -1,     4,    -1,    22,    -1,    34,    -1,    39,    -1,    38,
01333       -1,    23,    -1,     8,    -1,    24,    -1,    30,    -1,    33,
01334       -1,    32,    -1,    13,    -1,    35,    -1,     6,    -1,    17,
01335       -1,    31,    -1,    11,    -1,    12,    -1,    18,    -1,    19,
01336       -1,   174,   115,   184,    -1,   174,   115,   184,    44,   184,
01337       -1,   302,    89,   184,    -1,   302,    89,   184,    44,   184,
01338       -1,   218,   134,   190,   343,    89,   184,    -1,   218,   135,
01339       52,    89,   184,    -1,   218,   135,    56,    89,   184,    -1,
01340      218,    87,    52,    89,   184,    -1,   218,    87,    56,    89,
01341      184,    -1,    88,    56,    89,   184,    -1,   303,    89,   184,
01342       -1,   184,    81,   184,    -1,   184,    82,   184,    -1,   184,
01343      123,   184,    -1,   184,   124,   184,    -1,   184,   125,   184,
01344       -1,   184,   126,   184,    -1,   184,   127,   184,    -1,   184,
01345       70,   184,    -1,   128,   298,    70,   184,    -1,    68,   184,
01346       -1,    69,   184,    -1,   184,   120,   184,    -1,   184,   121,
01347      184,    -1,   184,   122,   184,    -1,   184,    71,   184,    -1,
01348      184,   118,   184,    -1,   184,    75,   184,    -1,   184,   119,
01349      184,    -1,   184,    76,   184,    -1,   184,    72,   184,    -1,
01350      184,    73,   184,    -1,   184,    74,   184,    -1,   184,    79,
01351      184,    -1,   184,    80,   184,    -1,   129,   184,    -1,   130,
01352      184,    -1,   184,    85,   184,    -1,   184,    86,   184,    -1,
01353      184,    77,   184,    -1,   184,    78,   184,    -1,    -1,    46,
01354      341,   185,   184,    -1,   184,   116,   184,   341,   117,   184,
01355       -1,   199,    -1,   184,    -1,   347,    -1,   196,   344,    -1,
01356      196,   136,   334,   344,    -1,   334,   344,    -1,   138,   190,
01357      342,    -1,   347,    -1,   188,    -1,   347,    -1,   191,    -1,
01358      196,   136,    -1,   196,   136,   334,   136,    -1,   334,   136,
01359       -1,   166,    -1,   196,   195,    -1,   334,   195,    -1,   196,
01360      136,   334,   195,    -1,   194,    -1,    -1,   193,   191,    -1,
01361       99,   186,    -1,   136,   194,    -1,   347,    -1,   186,    -1,
01362       97,   186,    -1,   196,   136,   186,    -1,   196,   136,    97,
01363      186,    -1,   198,    -1,   186,    -1,   196,   136,   186,    -1,
01364      196,   136,    97,   186,    -1,    97,   186,    -1,   270,    -1,
01365      271,    -1,   274,    -1,   275,    -1,   276,    -1,   281,    -1,
01366      279,    -1,   282,    -1,   301,    -1,   303,    -1,    53,    -1,
01367       -1,   219,   200,   151,   229,    -1,    -1,    92,   201,   342,
01368       -1,    -1,    -1,    92,   202,   159,   203,   342,    -1,    91,
01369      152,   139,    -1,   218,    87,    56,    -1,    88,    56,    -1,
01370       94,   187,   140,    -1,    95,   333,   133,    -1,    30,    -1,
01371       31,   138,   191,   342,    -1,    31,   138,   342,    -1,    31,
01372       -1,    -1,    46,   341,   138,   204,   159,   342,    -1,    39,
01373      138,   159,   342,    -1,    39,   138,   342,    -1,   165,   261,
01374       -1,   256,    -1,   256,   261,    -1,   100,   246,    -1,   220,
01375      160,   230,   152,   232,   229,    -1,   221,   160,   230,   152,
01376      233,   229,    -1,    -1,    -1,   222,   205,   160,   231,   206,
01377      152,   229,    -1,    -1,    -1,   223,   207,   160,   231,   208,
01378      152,   229,    -1,   224,   160,   340,   264,   229,    -1,   224,
01379      340,   264,   229,    -1,    -1,    -1,   225,   234,    25,   209,
01380      160,   231,   210,   152,   229,    -1,    -1,   226,   176,   304,
01381      211,   151,   229,    -1,    -1,    -1,   226,    85,   159,   212,
01382      345,   213,   151,   229,    -1,    -1,   227,   176,   214,   151,
01383      229,    -1,    -1,   228,   177,   215,   306,   151,   229,    -1,
01384       -1,    -1,   228,   331,   339,   216,   177,   217,   306,   151,
01385      229,    -1,    21,    -1,    22,    -1,    23,    -1,    24,    -1,
01386      199,    -1,     7,    -1,    11,    -1,    12,    -1,    18,    -1,
01387       19,    -1,    16,    -1,    20,    -1,     3,    -1,     4,    -1,
01388        5,    -1,    10,    -1,   345,    -1,    13,    -1,   345,    13,
01389       -1,   345,    -1,    27,    -1,   233,    -1,    14,   160,   230,
01390      152,   232,    -1,   347,    -1,    15,   152,    -1,   174,    -1,
01391      167,    -1,   312,    -1,    91,   237,   342,    -1,   235,    -1,
01392      236,   136,   235,    -1,   236,    -1,   236,   136,    97,   312,
01393       -1,   236,   136,    97,   312,   136,   236,    -1,   236,   136,
01394       97,    -1,   236,   136,    97,   136,   236,    -1,    97,   312,
01395       -1,    97,   312,   136,   236,    -1,    97,    -1,    97,   136,
01396      236,    -1,   318,   136,   321,   330,    -1,   318,   330,    -1,
01397      321,   330,    -1,   329,    -1,   136,   238,    -1,    -1,   314,
01398      136,   324,   136,   327,   239,    -1,   314,   136,   324,   136,
01399      327,   136,   314,   239,    -1,   314,   136,   324,   239,    -1,
01400      314,   136,   324,   136,   314,   239,    -1,   314,   136,   327,
01401      239,    -1,   314,   136,    -1,   314,   136,   327,   136,   314,
01402      239,    -1,   314,   239,    -1,   324,   136,   327,   239,    -1,
01403      324,   136,   327,   136,   314,   239,    -1,   324,   239,    -1,
01404      324,   136,   314,   239,    -1,   327,   239,    -1,   327,   136,
01405      314,   239,    -1,   238,    -1,   347,    -1,   242,    -1,   120,
01406      243,   120,    -1,    78,    -1,   120,   240,   243,   120,    -1,
01407      341,    -1,   341,   141,   244,   341,    -1,   245,    -1,   244,
01408      136,   245,    -1,    52,    -1,   311,    -1,    -1,    -1,    -1,
01409       -1,   247,   248,   251,   249,   250,   252,    -1,   138,   310,
01410      243,   139,    -1,   310,    -1,   113,   152,   133,    -1,    29,
01411      152,    10,    -1,    -1,    28,   254,   241,   152,    10,    -1,
01412      166,   253,    -1,   255,   339,   337,   189,    -1,   255,   339,
01413      337,   189,   261,    -1,   255,   339,   337,   192,   253,    -1,
01414      165,   188,    -1,    -1,   218,   135,   337,   257,   189,    -1,
01415       -1,   218,    87,   337,   258,   188,    -1,   218,    87,   338,
01416       -1,    -1,   218,   135,   259,   188,    -1,    -1,   218,    87,
01417      260,   188,    -1,    32,   188,    -1,    32,    -1,   218,   134,
01418      190,   343,    -1,    -1,   132,   262,   241,   152,   133,    -1,
01419       -1,    26,   263,   241,   152,    10,    -1,    17,   196,   230,
01420      152,   265,    -1,   233,    -1,   264,    -1,     8,   267,   268,
01421      230,   152,   266,    -1,   347,    -1,   186,    -1,   198,    -1,
01422      347,    -1,    90,   174,    -1,   347,    -1,     9,   152,    -1,
01423      347,    -1,   297,    -1,   294,    -1,   296,    -1,   272,    -1,
01424       64,    -1,   273,    -1,   272,   273,    -1,   102,   285,   112,
01425       -1,   103,   286,   112,    -1,   104,   287,    67,    -1,   105,
01426      142,   112,    -1,   105,   277,   112,    -1,    -1,   277,   278,
01427      142,    -1,   288,    -1,   278,   288,    -1,   107,   142,   112,
01428       -1,   107,   280,   112,    -1,    -1,   280,   278,   142,    -1,
01429      106,   142,   112,    -1,   106,   283,   112,    -1,   108,   142,
01430      112,    -1,   108,   284,   112,    -1,    -1,   283,    63,   142,
01431       -1,    -1,   284,    63,   142,    -1,    -1,   285,   288,    -1,
01432       -1,   286,   288,    -1,    -1,   287,   288,    -1,    63,    -1,
01433       -1,   111,   289,   293,    -1,    -1,    -1,    -1,   109,   290,
01434      291,   292,   152,   110,    -1,    54,    -1,    55,    -1,    57,
01435       -1,   303,    -1,   101,   295,    -1,   177,    -1,    55,    -1,
01436       54,    -1,    57,    -1,   101,   286,   112,    -1,   298,    -1,
01437      128,   298,    -1,    59,    -1,    60,    -1,    61,    -1,    62,
01438       -1,    52,    -1,    55,    -1,    54,    -1,    56,    -1,    57,
01439       -1,    34,    -1,    33,    -1,    35,    -1,    36,    -1,    50,
01440       -1,    49,    -1,    51,    -1,   299,    -1,   300,    -1,   299,
01441       -1,   300,    -1,    65,    -1,    66,    -1,   345,    -1,    -1,
01442      119,   305,   160,   345,    -1,     1,   345,    -1,   138,   310,
01443      342,    -1,    -1,   307,   310,   345,    -1,   319,   136,   321,
01444      330,    -1,   319,   330,    -1,   321,   330,    -1,   329,    -1,
01445      136,   308,    -1,    -1,   314,   136,   325,   136,   327,   309,
01446       -1,   314,   136,   325,   136,   327,   136,   314,   309,    -1,
01447      314,   136,   325,   309,    -1,   314,   136,   325,   136,   314,
01448      309,    -1,   314,   136,   327,   309,    -1,   314,   136,   327,
01449      136,   314,   309,    -1,   314,   309,    -1,   325,   136,   327,
01450      309,    -1,   325,   136,   327,   136,   314,   309,    -1,   325,
01451      309,    -1,   325,   136,   314,   309,    -1,   327,   309,    -1,
01452      327,   136,   314,   309,    -1,   308,    -1,    -1,    56,    -1,
01453       55,    -1,    54,    -1,    57,    -1,   311,    -1,    52,    -1,
01454      312,    -1,    91,   237,   342,    -1,   313,    -1,   314,   136,
01455      313,    -1,    58,    -1,   315,   186,    -1,   315,    -1,   315,
01456      218,    -1,   315,    -1,   317,    -1,   318,   136,   317,    -1,
01457      316,    -1,   319,   136,   316,    -1,    70,    -1,    98,    -1,
01458      320,    52,    -1,   320,    -1,   312,   115,   186,    -1,   312,
01459      115,   218,    -1,   323,    -1,   324,   136,   323,    -1,   322,
01460       -1,   325,   136,   322,    -1,   125,    -1,    97,    -1,   326,
01461       52,    -1,   326,    -1,   122,    -1,    99,    -1,   328,    52,
01462       -1,   136,   329,    -1,   347,    -1,   301,    -1,    -1,   138,
01463      332,   159,   342,    -1,   347,    -1,   334,   344,    -1,   335,
01464       -1,   334,   136,   335,    -1,   186,    90,   186,    -1,    58,
01465      186,    -1,    98,   186,    -1,    52,    -1,    56,    -1,    53,
01466       -1,    52,    -1,    56,    -1,    53,    -1,   182,    -1,    52,
01467       -1,    53,    -1,   182,    -1,   135,    -1,    87,    -1,    -1,
01468      346,    -1,    -1,   143,    -1,   341,   139,    -1,   341,   140,
01469       -1,    -1,   143,    -1,   136,    -1,   141,    -1,   143,    -1,
01470      345,    -1,   346,   141,    -1,    -1
01471 };
01472 
01473 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01474 static const yytype_uint16 yyrline[] =
01475 {
01476        0,   863,   863,   863,   894,   905,   914,   922,   930,   936,
01477      938,   937,   958,   991,  1002,  1011,  1019,  1027,  1033,  1038,
01478     1037,  1058,  1058,  1066,  1074,  1085,  1095,  1103,  1112,  1121,
01479     1134,  1147,  1156,  1168,  1169,  1179,  1184,  1205,  1210,  1215,
01480     1225,  1230,  1240,  1249,  1258,  1261,  1270,  1282,  1283,  1291,
01481     1299,  1307,  1315,  1318,  1330,  1331,  1334,  1335,  1347,  1346,
01482     1368,  1378,  1387,  1400,  1409,  1421,  1430,  1442,  1451,  1460,
01483     1468,  1476,  1486,  1487,  1497,  1498,  1508,  1516,  1524,  1532,
01484     1541,  1549,  1558,  1566,  1575,  1583,  1594,  1595,  1605,  1613,
01485     1623,  1631,  1641,  1645,  1649,  1657,  1665,  1673,  1681,  1693,
01486     1703,  1715,  1724,  1733,  1741,  1749,  1757,  1765,  1778,  1791,
01487     1802,  1810,  1813,  1821,  1829,  1839,  1840,  1841,  1842,  1847,
01488     1858,  1859,  1862,  1870,  1873,  1881,  1881,  1891,  1892,  1893,
01489     1894,  1895,  1896,  1897,  1898,  1899,  1900,  1901,  1902,  1903,
01490     1904,  1905,  1906,  1907,  1908,  1909,  1910,  1911,  1912,  1913,
01491     1914,  1915,  1916,  1917,  1918,  1919,  1920,  1923,  1923,  1923,
01492     1924,  1924,  1925,  1925,  1925,  1926,  1926,  1926,  1926,  1927,
01493     1927,  1927,  1927,  1928,  1928,  1928,  1929,  1929,  1929,  1929,
01494     1930,  1930,  1930,  1930,  1931,  1931,  1931,  1931,  1932,  1932,
01495     1932,  1932,  1933,  1933,  1933,  1933,  1934,  1934,  1937,  1946,
01496     1956,  1961,  1971,  1997,  2002,  2007,  2012,  2022,  2032,  2043,
01497     2057,  2071,  2079,  2087,  2095,  2103,  2111,  2119,  2128,  2136,
01498     2144,  2152,  2160,  2168,  2176,  2184,  2192,  2200,  2208,  2216,
01499     2224,  2232,  2243,  2251,  2259,  2267,  2275,  2283,  2291,  2299,
01500     2299,  2309,  2319,  2325,  2337,  2338,  2342,  2350,  2360,  2370,
01501     2371,  2374,  2375,  2376,  2380,  2388,  2398,  2407,  2415,  2425,
01502     2434,  2443,  2443,  2455,  2465,  2469,  2475,  2483,  2491,  2505,
01503     2521,  2522,  2525,  2539,  2554,  2564,  2565,  2566,  2567,  2568,
01504     2569,  2570,  2571,  2572,  2573,  2574,  2583,  2582,  2610,  2610,
01505     2619,  2623,  2618,  2632,  2640,  2648,  2656,  2669,  2677,  2685,
01506     2693,  2701,  2709,  2709,  2719,  2727,  2735,  2745,  2746,  2756,
01507     2760,  2772,  2784,  2784,  2784,  2795,  2795,  2795,  2806,  2817,
01508     2826,  2828,  2825,  2892,  2891,  2913,  2918,  2912,  2937,  2936,
01509     2958,  2957,  2980,  2981,  2980,  3001,  3009,  3017,  3025,  3035,
01510     3047,  3053,  3059,  3065,  3071,  3077,  3083,  3089,  3095,  3101,
01511     3111,  3117,  3122,  3123,  3130,  3135,  3138,  3139,  3152,  3153,
01512     3163,  3164,  3167,  3175,  3185,  3193,  3203,  3211,  3220,  3229,
01513     3237,  3245,  3254,  3266,  3274,  3285,  3289,  3293,  3297,  3303,
01514     3308,  3313,  3317,  3321,  3325,  3329,  3333,  3341,  3345,  3349,
01515     3353,  3357,  3361,  3365,  3369,  3373,  3379,  3380,  3386,  3395,
01516     3404,  3415,  3419,  3429,  3436,  3445,  3453,  3459,  3462,  3467,
01517     3470,  3459,  3489,  3497,  3503,  3507,  3514,  3513,  3534,  3550,
01518     3559,  3571,  3585,  3595,  3594,  3611,  3610,  3626,  3635,  3634,
01519     3652,  3651,  3668,  3676,  3684,  3699,  3698,  3718,  3717,  3738,
01520     3750,  3751,  3754,  3773,  3776,  3784,  3792,  3795,  3799,  3802,
01521     3810,  3813,  3814,  3822,  3825,  3842,  3843,  3844,  3854,  3864,
01522     3891,  3956,  3965,  3976,  3983,  3993,  4001,  4011,  4020,  4031,
01523     4038,  4056,  4065,  4075,  4084,  4095,  4102,  4113,  4120,  4135,
01524     4142,  4153,  4160,  4171,  4178,  4207,  4209,  4208,  4225,  4231,
01525     4236,  4224,  4255,  4263,  4271,  4279,  4282,  4293,  4294,  4295,
01526     4296,  4299,  4310,  4311,  4321,  4322,  4323,  4324,  4327,  4328,
01527     4329,  4330,  4331,  4334,  4335,  4336,  4337,  4338,  4339,  4340,
01528     4343,  4356,  4366,  4374,  4384,  4385,  4388,  4397,  4396,  4405,
01529     4417,  4427,  4427,  4440,  4444,  4448,  4452,  4458,  4463,  4468,
01530     4472,  4476,  4480,  4484,  4488,  4492,  4496,  4500,  4504,  4508,
01531     4512,  4516,  4520,  4525,  4531,  4540,  4549,  4558,  4569,  4570,
01532     4577,  4586,  4605,  4612,  4626,  4633,  4642,  4653,  4662,  4673,
01533     4681,  4698,  4706,  4722,  4723,  4726,  4731,  4737,  4749,  4761,
01534     4769,  4785,  4793,  4809,  4810,  4813,  4826,  4837,  4838,  4841,
01535     4858,  4862,  4872,  4882,  4882,  4911,  4912,  4922,  4929,  4939,
01536     4951,  4959,  4971,  4972,  4973,  4976,  4977,  4978,  4979,  4982,
01537     4983,  4984,  4987,  4992,  4999,  5000,  5003,  5004,  5007,  5010,
01538     5013,  5014,  5015,  5018,  5019,  5022,  5023,  5027
01539 };
01540 #endif
01541 
01542 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01543 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01544    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01545 static const char *const yytname[] =
01546 {
01547   "\"end-of-input\"", "error", "$undefined", "keyword_class",
01548   "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
01549   "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
01550   "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
01551   "keyword_case", "keyword_when", "keyword_while", "keyword_until",
01552   "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
01553   "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
01554   "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
01555   "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
01556   "keyword_true", "keyword_false", "keyword_and", "keyword_or",
01557   "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
01558   "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
01559   "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
01560   "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
01561   "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tRATIONAL",
01562   "tIMAGINARY", "tSTRING_CONTENT", "tCHAR", "tNTH_REF", "tBACK_REF",
01563   "tREGEXP_END", "\"unary+\"", "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"",
01564   "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"",
01565   "\"!~\"", "\"..\"", "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"",
01566   "\"::\"", "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"",
01567   "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"",
01568   "\"**arg\"", "\"&\"", "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG",
01569   "tREGEXP_BEG", "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG",
01570   "tQSYMBOLS_BEG", "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR",
01571   "tSTRING_END", "tLAMBEG", "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'",
01572   "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM",
01573   "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','", "'`'",
01574   "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program", "$@1",
01575   "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt", "compstmt",
01576   "stmts", "stmt_or_begin", "$@3", "stmt", "$@4", "command_asgn", "expr",
01577   "expr_value", "command_call", "block_command", "cmd_brace_block", "@5",
01578   "fcall", "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item",
01579   "mlhs_head", "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname",
01580   "fsym", "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
01581   "arg_value", "aref_args", "paren_args", "opt_paren_args",
01582   "opt_call_args", "call_args", "command_args", "@8", "block_arg",
01583   "opt_block_arg", "args", "mrhs_arg", "mrhs", "primary", "@9", "$@10",
01584   "$@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19",
01585   "@20", "@21", "@22", "@23", "@24", "$@25", "$@26", "primary_value",
01586   "k_begin", "k_if", "k_unless", "k_while", "k_until", "k_case", "k_for",
01587   "k_class", "k_module", "k_def", "k_end", "then", "do", "if_tail",
01588   "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
01589   "block_args_tail", "opt_block_args_tail", "block_param",
01590   "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar",
01591   "lambda", "@27", "@28", "@29", "@30", "f_larglist", "lambda_body",
01592   "do_block", "@31", "block_call", "method_call", "@32", "@33", "@34",
01593   "@35", "brace_block", "@36", "@37", "case_body", "cases", "opt_rescue",
01594   "exc_list", "exc_var", "opt_ensure", "literal", "strings", "string",
01595   "string1", "xstring", "regexp", "words", "word_list", "word", "symbols",
01596   "symbol_list", "qwords", "qsymbols", "qword_list", "qsym_list",
01597   "string_contents", "xstring_contents", "regexp_contents",
01598   "string_content", "@38", "@39", "@40", "@41", "string_dvar", "symbol",
01599   "sym", "dsym", "numeric", "simple_numeric", "user_variable",
01600   "keyword_variable", "var_ref", "var_lhs", "backref", "superclass",
01601   "$@42", "f_arglist", "@43", "args_tail", "opt_args_tail", "f_args",
01602   "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_label", "f_kw",
01603   "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
01604   "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
01605   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
01606   "singleton", "$@44", "assoc_list", "assocs", "assoc", "operation",
01607   "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
01608   "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01609 };
01610 #endif
01611 
01612 # ifdef YYPRINT
01613 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01614    token YYLEX-NUM.  */
01615 static const yytype_uint16 yytoknum[] =
01616 {
01617        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01618      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01619      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01620      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01621      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01622      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01623      315,   316,   317,   318,   319,   320,   321,   322,   130,   131,
01624      132,   134,   139,   140,   141,   138,   137,   323,   324,   142,
01625      143,   128,   129,   144,   145,   135,   136,   325,   326,   327,
01626      328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
01627      338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
01628      348,   349,   350,   351,   352,    61,    63,    58,    62,    60,
01629      124,    94,    38,    43,    45,    42,    47,    37,   353,    33,
01630      126,   354,   123,   125,    91,    46,    44,    96,    40,    41,
01631       93,    59,    32,    10
01632 };
01633 # endif
01634 
01635 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01636 static const yytype_uint16 yyr1[] =
01637 {
01638        0,   144,   146,   145,   147,   148,   148,   148,   148,   149,
01639      150,   149,   151,   152,   153,   153,   153,   153,   154,   155,
01640      154,   157,   156,   156,   156,   156,   156,   156,   156,   156,
01641      156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
01642      156,   156,   156,   156,   156,   158,   158,   159,   159,   159,
01643      159,   159,   159,   160,   161,   161,   162,   162,   164,   163,
01644      165,   166,   166,   166,   166,   166,   166,   166,   166,   166,
01645      166,   166,   167,   167,   168,   168,   169,   169,   169,   169,
01646      169,   169,   169,   169,   169,   169,   170,   170,   171,   171,
01647      172,   172,   173,   173,   173,   173,   173,   173,   173,   173,
01648      173,   174,   174,   174,   174,   174,   174,   174,   174,   174,
01649      175,   175,   176,   176,   176,   177,   177,   177,   177,   177,
01650      178,   178,   179,   179,   180,   181,   180,   182,   182,   182,
01651      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01652      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01653      182,   182,   182,   182,   182,   182,   182,   183,   183,   183,
01654      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01655      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01656      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01657      183,   183,   183,   183,   183,   183,   183,   183,   184,   184,
01658      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01659      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01660      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01661      184,   184,   184,   184,   184,   184,   184,   184,   184,   185,
01662      184,   184,   184,   186,   187,   187,   187,   187,   188,   189,
01663      189,   190,   190,   190,   190,   190,   191,   191,   191,   191,
01664      191,   193,   192,   194,   195,   195,   196,   196,   196,   196,
01665      197,   197,   198,   198,   198,   199,   199,   199,   199,   199,
01666      199,   199,   199,   199,   199,   199,   200,   199,   201,   199,
01667      202,   203,   199,   199,   199,   199,   199,   199,   199,   199,
01668      199,   199,   204,   199,   199,   199,   199,   199,   199,   199,
01669      199,   199,   205,   206,   199,   207,   208,   199,   199,   199,
01670      209,   210,   199,   211,   199,   212,   213,   199,   214,   199,
01671      215,   199,   216,   217,   199,   199,   199,   199,   199,   218,
01672      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
01673      229,   230,   230,   230,   231,   231,   232,   232,   233,   233,
01674      234,   234,   235,   235,   236,   236,   237,   237,   237,   237,
01675      237,   237,   237,   237,   237,   238,   238,   238,   238,   239,
01676      239,   240,   240,   240,   240,   240,   240,   240,   240,   240,
01677      240,   240,   240,   240,   240,   240,   241,   241,   242,   242,
01678      242,   243,   243,   244,   244,   245,   245,   247,   248,   249,
01679      250,   246,   251,   251,   252,   252,   254,   253,   255,   255,
01680      255,   255,   256,   257,   256,   258,   256,   256,   259,   256,
01681      260,   256,   256,   256,   256,   262,   261,   263,   261,   264,
01682      265,   265,   266,   266,   267,   267,   267,   268,   268,   269,
01683      269,   270,   270,   270,   271,   272,   272,   272,   273,   274,
01684      275,   276,   276,   277,   277,   278,   278,   279,   279,   280,
01685      280,   281,   281,   282,   282,   283,   283,   284,   284,   285,
01686      285,   286,   286,   287,   287,   288,   289,   288,   290,   291,
01687      292,   288,   293,   293,   293,   293,   294,   295,   295,   295,
01688      295,   296,   297,   297,   298,   298,   298,   298,   299,   299,
01689      299,   299,   299,   300,   300,   300,   300,   300,   300,   300,
01690      301,   301,   302,   302,   303,   303,   304,   305,   304,   304,
01691      306,   307,   306,   308,   308,   308,   308,   309,   309,   310,
01692      310,   310,   310,   310,   310,   310,   310,   310,   310,   310,
01693      310,   310,   310,   310,   311,   311,   311,   311,   312,   312,
01694      313,   313,   314,   314,   315,   316,   316,   317,   317,   318,
01695      318,   319,   319,   320,   320,   321,   321,   322,   323,   324,
01696      324,   325,   325,   326,   326,   327,   327,   328,   328,   329,
01697      330,   330,   331,   332,   331,   333,   333,   334,   334,   335,
01698      335,   335,   336,   336,   336,   337,   337,   337,   337,   338,
01699      338,   338,   339,   339,   340,   340,   341,   341,   342,   343,
01700      344,   344,   344,   345,   345,   346,   346,   347
01701 };
01702 
01703 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01704 static const yytype_uint8 yyr2[] =
01705 {
01706        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01707        0,     5,     4,     2,     1,     1,     3,     2,     1,     0,
01708        5,     0,     4,     3,     3,     3,     2,     3,     3,     3,
01709        3,     3,     4,     1,     3,     3,     6,     5,     5,     5,
01710        5,     3,     3,     3,     1,     3,     3,     1,     3,     3,
01711        3,     2,     1,     1,     1,     1,     1,     4,     0,     5,
01712        1,     2,     3,     4,     5,     4,     5,     2,     2,     2,
01713        2,     2,     1,     3,     1,     3,     1,     2,     3,     5,
01714        2,     4,     2,     4,     1,     3,     1,     3,     2,     3,
01715        1,     3,     1,     1,     4,     3,     3,     3,     3,     2,
01716        1,     1,     1,     4,     3,     3,     3,     3,     2,     1,
01717        1,     1,     2,     1,     3,     1,     1,     1,     1,     1,
01718        1,     1,     1,     1,     1,     0,     4,     1,     1,     1,
01719        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01720        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01721        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01722        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01723        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01724        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01725        1,     1,     1,     1,     1,     1,     1,     1,     3,     5,
01726        3,     5,     6,     5,     5,     5,     5,     4,     3,     3,
01727        3,     3,     3,     3,     3,     3,     3,     4,     2,     2,
01728        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
01729        3,     3,     3,     2,     2,     3,     3,     3,     3,     0,
01730        4,     6,     1,     1,     1,     2,     4,     2,     3,     1,
01731        1,     1,     1,     2,     4,     2,     1,     2,     2,     4,
01732        1,     0,     2,     2,     2,     1,     1,     2,     3,     4,
01733        1,     1,     3,     4,     2,     1,     1,     1,     1,     1,
01734        1,     1,     1,     1,     1,     1,     0,     4,     0,     3,
01735        0,     0,     5,     3,     3,     2,     3,     3,     1,     4,
01736        3,     1,     0,     6,     4,     3,     2,     1,     2,     2,
01737        6,     6,     0,     0,     7,     0,     0,     7,     5,     4,
01738        0,     0,     9,     0,     6,     0,     0,     8,     0,     5,
01739        0,     6,     0,     0,     9,     1,     1,     1,     1,     1,
01740        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01741        1,     1,     1,     2,     1,     1,     1,     5,     1,     2,
01742        1,     1,     1,     3,     1,     3,     1,     4,     6,     3,
01743        5,     2,     4,     1,     3,     4,     2,     2,     1,     2,
01744        0,     6,     8,     4,     6,     4,     2,     6,     2,     4,
01745        6,     2,     4,     2,     4,     1,     1,     1,     3,     1,
01746        4,     1,     4,     1,     3,     1,     1,     0,     0,     0,
01747        0,     6,     4,     1,     3,     3,     0,     5,     2,     4,
01748        5,     5,     2,     0,     5,     0,     5,     3,     0,     4,
01749        0,     4,     2,     1,     4,     0,     5,     0,     5,     5,
01750        1,     1,     6,     1,     1,     1,     1,     2,     1,     2,
01751        1,     1,     1,     1,     1,     1,     1,     2,     3,     3,
01752        3,     3,     3,     0,     3,     1,     2,     3,     3,     0,
01753        3,     3,     3,     3,     3,     0,     3,     0,     3,     0,
01754        2,     0,     2,     0,     2,     1,     0,     3,     0,     0,
01755        0,     6,     1,     1,     1,     1,     2,     1,     1,     1,
01756        1,     3,     1,     2,     1,     1,     1,     1,     1,     1,
01757        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01758        1,     1,     1,     1,     1,     1,     1,     0,     4,     2,
01759        3,     0,     3,     4,     2,     2,     1,     2,     0,     6,
01760        8,     4,     6,     4,     6,     2,     4,     6,     2,     4,
01761        2,     4,     1,     0,     1,     1,     1,     1,     1,     1,
01762        1,     3,     1,     3,     1,     2,     1,     2,     1,     1,
01763        3,     1,     3,     1,     1,     2,     1,     3,     3,     1,
01764        3,     1,     3,     1,     1,     2,     1,     1,     1,     2,
01765        2,     1,     1,     0,     4,     1,     2,     1,     3,     3,
01766        2,     2,     1,     1,     1,     1,     1,     1,     1,     1,
01767        1,     1,     1,     1,     0,     1,     0,     1,     2,     2,
01768        0,     1,     1,     1,     1,     1,     2,     0
01769 };
01770 
01771 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
01772    Performed when YYTABLE doesn't specify something else to do.  Zero
01773    means the default is an error.  */
01774 static const yytype_uint16 yydefact[] =
01775 {
01776        2,     0,     0,     1,     0,   347,   348,   349,     0,   340,
01777      341,   342,   345,   343,   344,   346,   335,   336,   337,   338,
01778      298,   261,   261,   514,   513,   515,   516,   616,     0,   616,
01779       10,     0,   518,   517,   519,   602,   604,   510,   509,   603,
01780      512,   504,   505,   506,   507,   455,   524,   525,     0,     0,
01781        0,     0,   290,   627,   627,    84,   407,   481,   479,   481,
01782      483,   463,   475,   469,   477,     0,     0,     0,     3,   614,
01783        6,     9,    33,    44,    47,    55,   261,    54,     0,    72,
01784        0,    76,    86,     0,    52,   242,     0,   286,     0,     0,
01785      312,   315,   614,     0,     0,     0,     0,    56,   307,   275,
01786      276,   454,   456,   277,   278,   279,   281,   280,   282,   452,
01787      453,   451,   502,   520,   521,   283,     0,   284,    60,     5,
01788        8,   167,   178,   168,   191,   164,   184,   174,   173,   194,
01789      195,   189,   172,   171,   166,   192,   196,   197,   176,   165,
01790      179,   183,   185,   177,   170,   186,   193,   188,   187,   180,
01791      190,   175,   163,   182,   181,   162,   169,   160,   161,   157,
01792      158,   159,   115,   117,   116,   152,   153,   148,   130,   131,
01793      132,   139,   136,   138,   133,   134,   154,   155,   140,   141,
01794      145,   149,   135,   137,   127,   128,   129,   142,   143,   144,
01795      146,   147,   150,   151,   156,   120,   122,   124,    26,   118,
01796      119,   121,   123,     0,     0,     0,     0,     0,     0,     0,
01797        0,   256,     0,   243,   266,    70,   260,   627,     0,   520,
01798      521,     0,   284,   627,   597,    71,    69,   616,    68,     0,
01799      627,   432,    67,   616,   617,     0,     0,    21,   239,     0,
01800        0,   335,   336,   298,   301,   433,     0,   218,     0,   219,
01801      295,     0,    19,     0,     0,   614,    15,    18,   616,    74,
01802       14,   616,     0,     0,   620,   620,   244,     0,     0,   620,
01803      595,   616,     0,     0,     0,    82,   339,     0,    92,    93,
01804      100,   309,   408,   499,   498,   500,   497,     0,   496,     0,
01805        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01806      503,    51,   233,   234,   623,   624,     4,   625,   615,     0,
01807        0,     0,     0,     0,     0,     0,   437,   435,   422,    61,
01808      306,   416,   418,     0,    88,     0,    80,    77,     0,     0,
01809        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01810        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01811        0,     0,     0,     0,     0,   430,   627,   428,     0,    53,
01812        0,     0,     0,     0,   614,     0,   615,     0,   361,   360,
01813        0,     0,   520,   521,   284,   110,   111,     0,     0,   113,
01814        0,     0,   520,   521,   284,   328,   187,   180,   190,   175,
01815      157,   158,   159,   115,   116,   593,   330,   592,     0,   613,
01816      612,     0,   308,   457,     0,     0,   125,   600,   295,   267,
01817      601,   263,     0,     0,     0,   257,   265,   430,   627,   428,
01818        0,     0,     0,   258,   616,     0,   300,   262,   616,   252,
01819      627,   627,   251,   616,   305,    50,    23,    25,    24,     0,
01820      302,     0,     0,     0,   430,   428,     0,    17,     0,   616,
01821      293,    13,   615,    73,   289,   291,   296,   622,   621,   245,
01822      622,   247,   297,   596,     0,    99,   503,    90,    85,     0,
01823      430,   627,   428,   553,   485,   488,   486,   501,   482,   458,
01824      480,   459,   460,   484,   461,   462,     0,   465,   471,     0,
01825      472,   467,   468,     0,   473,     0,   474,     0,   626,     7,
01826       27,    28,    29,    30,    31,    48,    49,   627,   627,    58,
01827       62,   627,     0,    34,   271,     0,    43,   270,   616,     0,
01828       78,    89,    46,    45,     0,   198,   266,    42,   216,   223,
01829      228,   229,   230,   225,   227,   237,   238,   231,   232,   209,
01830      210,   235,   236,   616,   224,   226,   220,   221,   222,   211,
01831      212,   213,   214,   215,   605,   607,   606,   608,     0,   261,
01832      427,   616,   605,   607,   606,   608,     0,   261,     0,   627,
01833      352,     0,   351,     0,     0,     0,     0,     0,     0,   295,
01834      430,   627,   428,   320,   325,   110,   111,   112,     0,   527,
01835      323,   526,   430,   627,   428,     0,     0,   531,   332,   605,
01836      606,   261,    35,   200,    41,   208,     0,   198,   599,     0,
01837      268,   264,   627,   605,   606,   616,   605,   606,   598,   299,
01838      618,   248,   253,   255,   304,    22,     0,   240,     0,    32,
01839      425,   423,   207,     0,    75,    16,   616,   620,     0,    83,
01840       96,    98,   616,   605,   606,   559,   556,   555,   554,   557,
01841      564,   573,     0,   584,   574,   588,   587,   583,   553,   409,
01842      552,   413,   558,   560,   562,   538,   566,   571,   627,   576,
01843      627,   581,   538,   586,   538,     0,   536,   489,     0,   464,
01844      466,   476,   470,   478,   217,   399,   616,     0,   397,   396,
01845        0,   627,     0,   274,     0,    87,    81,     0,     0,     0,
01846        0,     0,     0,   431,    65,     0,     0,   434,     0,     0,
01847      429,    63,   627,   350,   287,   627,   627,   443,   627,   353,
01848      627,   355,   313,   354,   316,     0,     0,   319,   609,   294,
01849      616,   605,   606,     0,     0,   529,     0,     0,   110,   111,
01850      114,   616,     0,   616,   553,     0,   553,     0,   250,   419,
01851       57,   249,     0,   126,   269,   259,     0,     0,   434,     0,
01852        0,   627,   616,    11,     0,   292,   246,    91,    94,     0,
01853      373,   364,   366,   616,   362,   616,   410,     0,     0,   545,
01854      565,     0,   534,   591,   575,     0,   535,     0,   548,   585,
01855        0,   550,   589,   490,   492,   493,   494,   487,   495,   395,
01856      616,     0,   560,   380,   568,   569,   627,   627,   579,   380,
01857      380,   378,   401,     0,     0,     0,     0,     0,   272,    79,
01858      199,     0,    40,   205,    39,   206,    66,   426,   619,     0,
01859       37,   203,    38,   204,    64,   424,   444,   445,   627,   446,
01860        0,   627,   358,     0,     0,   356,     0,     0,     0,   318,
01861        0,     0,   434,     0,   326,     0,     0,   434,   329,   594,
01862      616,     0,     0,   333,   420,   421,   201,     0,   254,   303,
01863       20,   616,     0,   371,     0,   561,     0,     0,   577,   537,
01864      563,   538,   538,   572,   627,   590,   538,   582,   538,   560,
01865      538,     0,     0,   398,     0,   386,   388,     0,   567,     0,
01866      376,   377,     0,   391,     0,   393,     0,   438,   436,     0,
01867      417,   273,   241,    36,   202,     0,     0,   448,   359,     0,
01868       12,   450,     0,   310,   311,     0,     0,   268,   627,   321,
01869        0,   528,   324,   530,   331,   532,   531,   363,   374,     0,
01870      369,   365,   412,     0,     0,   411,     0,   541,     0,   543,
01871      533,     0,   549,     0,   546,   551,     0,   400,   578,   379,
01872      380,   380,   295,   430,   570,   627,   380,   580,   380,   380,
01873      405,   616,   403,   406,    59,     0,   447,     0,   101,   102,
01874      109,     0,   449,     0,   314,   317,   440,   441,   439,     0,
01875        0,     0,     0,   372,     0,   367,     0,     0,   538,   538,
01876      538,   538,   491,     0,   383,     0,   385,   609,   294,   375,
01877        0,   392,     0,   389,   394,     0,   402,   108,   430,   627,
01878      428,   627,   627,     0,   327,     0,   370,     0,   415,   414,
01879      542,     0,   539,   544,   547,   380,   380,   380,   380,   404,
01880      609,   107,   616,   605,   606,   442,   357,   322,   334,   368,
01881      538,   384,     0,   381,   387,   390,   434,   540,   380,   382
01882 };
01883 
01884 /* YYDEFGOTO[NTERM-NUM].  */
01885 static const yytype_int16 yydefgoto[] =
01886 {
01887       -1,     1,     2,    68,    69,    70,   239,   568,   569,   255,
01888      256,   448,   257,   439,    72,    73,   360,    74,    75,   510,
01889      691,   246,    77,    78,   258,    79,    80,    81,   468,    82,
01890      212,   379,   380,   195,   196,   197,   198,   606,   557,   200,
01891       84,   441,   214,   263,   231,   749,   428,   429,   228,   229,
01892      216,   415,   430,   516,   517,    85,   358,   261,   262,   636,
01893      626,   362,   847,   363,   848,   733,   989,   737,   734,   930,
01894      595,   597,   747,   936,   248,    87,    88,    89,    90,    91,
01895       92,    93,    94,    95,    96,   714,   571,   722,   844,   845,
01896      371,   771,   772,   773,   959,   896,   800,   687,   688,   801,
01897      971,   972,   281,   282,   473,   776,   877,   659,   945,   322,
01898      511,    97,    98,   712,   705,   566,   558,   320,   508,   507,
01899      578,   988,   716,   838,   916,   920,    99,   100,   101,   102,
01900      103,   104,   105,   293,   486,   106,   297,   107,   108,   295,
01901      299,   289,   287,   291,   478,   678,   677,   793,   891,   797,
01902      109,   288,   110,   111,   112,   219,   220,   115,   221,   222,
01903      590,   736,   745,   746,   879,   779,   661,   662,   889,   664,
01904      665,   666,   667,   805,   806,   668,   669,   670,   671,   808,
01905      809,   672,   673,   674,   675,   676,   782,   398,   596,   268,
01906      431,   224,   118,   630,   560,   401,   306,   425,   426,   707,
01907      459,   572,   366,   260
01908 };
01909 
01910 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01911    STATE-NUM.  */
01912 #define YYPACT_NINF -813
01913 static const yytype_int16 yypact[] =
01914 {
01915     -813,   111,  2847,  -813,  7396,  -813,  -813,  -813,  6911,  -813,
01916     -813,  -813,  -813,  -813,  -813,  -813,  7511,  7511,  -813,  -813,
01917     7511,  4052,  3641,  -813,  -813,  -813,  -813,   -21,  6776,   -35,
01918     -813,   -12,  -813,  -813,  -813,  2956,  3778,  -813,  -813,  3093,
01919     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  8891,  8891,
01920       72,  5120,    30,  7856,  8201,  7174,  -813,  6641,  -813,  -813,
01921     -813,    41,    84,    95,   136,  1005,  9006,  8891,  -813,   230,
01922     -813,  1060,  -813,   324,  -813,  -813,   142,   104,   168,  -813,
01923      192,  9236,  -813,   201,  3209,    40,   271,  -813,  9121,  9121,
01924     -813,  -813,  6021,  9347,  9458,  9569,  6505,    22,    97,  -813,
01925     -813,    56,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01926     -813,  -813,  -813,    27,   472,  -813,   243,   651,  -813,  -813,
01927     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01928     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01929     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01930     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01931     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01932     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01933     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01934     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,   207,  -813,
01935     -813,  -813,  -813,   219,  8891,   330,  5261,  8891,  8891,  8891,
01936     8891,  -813,   285,  3209,   343,  -813,  -813,   278,   301,    14,
01937      233,   348,   244,   284,  -813,  -813,  -813,  5906,  -813,  7511,
01938     7511,  -813,  -813,  6136,  -813,  9121,   775,  -813,   314,   354,
01939     5402,  -813,  -813,  -813,   342,   364,   142,  -813,   435,   422,
01940      687,  7626,  -813,  5120,   369,   230,  -813,  1060,   -35,   408,
01941     -813,   -35,  9121,   403,   329,   331,  -813,   343,   420,   331,
01942     -813,   -35,   510,  1005,  9680,   432,  -813,   520,   565,   590,
01943      604,  -813,  -813,  -813,  -813,  -813,  -813,   502,  -813,   513,
01944      523,   416,   465,   658,   469,    33,   476,   685,   488,    44,
01945      514,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  6251,  9121,
01946     9121,  9121,  9121,  7626,  9121,  9121,  -813,  -813,  -813,   522,
01947     -813,  -813,  -813,  8316,  -813,  5120,  7285,   528,  8316,  8891,
01948     8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,
01949     8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,  8891,
01950     8891,  8891,  8891,  8891,  8891,  9963,  7511, 10042,  4467,   324,
01951      112,   112,  9121,  9121,   230,   642,   530,   618,  -813,  -813,
01952      620,   655,    94,   108,   121,   312,   495,  9121,   139,  -813,
01953      212,   644,  -813,  -813,  -813,  -813,    26,   292,   384,   458,
01954      467,   532,   562,   570,   582,  -813,  -813,  -813,    22,  -813,
01955     -813, 10121,  -813,  -813,  9006,  9006,  -813,  -813,   286,  -813,
01956     -813,  -813,  8891,  8891,  7741,  -813,  -813, 10200,  7511, 10279,
01957     8891,  8891,  7971,  -813,   -35,   544,  -813,  -813,   -35,  -813,
01958      550,   551,  -813,    93,  -813,  -813,  -813,  -813,  -813,  6911,
01959     -813,  8891,  5535,   576, 10200, 10279,  8891,  1060,   558,   -35,
01960     -813,  -813,  6366,   559,  -813,   324,  -813,  8086,  -813,  -813,
01961     8201,  -813,  -813,  -813,   314,   648,  -813,  -813,   597,  9680,
01962    10358,  7511, 10437,  1164,  -813,  -813,  -813,  -813,  -813,  -813,
01963     -813,  -813,  -813,  -813,  -813,  -813,   346,  -813,  -813,   556,
01964     -813,  -813,  -813,   347,  -813,   584,  -813,  8891,  -813,  -813,
01965     -813,  -813,  -813,  -813,  -813,  -813,  -813,    19,    19,  -813,
01966     -813,    19,  8891,  -813,   607,   608,  -813,  -813,   -35,  9680,
01967      610,  -813,  -813,  -813,   636,  2008,  -813,  -813,   422,  2309,
01968     2309,  2309,  2309,  1315,  1315,  2621,  1681,  2309,  2309,  3346,
01969     3346,   425,   425, 10940,  1315,  1315,   795,   795,   887,   337,
01970      337,   422,   422,   422,  4189,  3230,  4326,  3367,   364,   623,
01971     -813,   -35,   688,  -813,   706,  -813,   364,  3915,   755,   763,
01972     -813,  4608,   771,  4890,    65,    65,   642,  8431,   755,   135,
01973    10516,  7511, 10595,  -813,   324,  -813,   648,  -813,   230,  -813,
01974     -813,  -813, 10674,  7511, 10121,  4467,  9121,   647,  -813,  -813,
01975     -813,  1256,  -813,  2935,  -813,  3209,  6911,  3072,  -813,  8891,
01976      343,  -813,   284,  2529,  3504,   -35,   381,   526,  -813,  -813,
01977     -813,  -813,  7741,  7971,  -813,  -813,  9121,  3209,   657,  -813,
01978     -813,  -813,  3209,  5535,   262,  -813,   -35,   331,  9680,   597,
01979      505,   394,   -35,   276,   351,  -813,  -813,  -813,  -813,  -813,
01980     -813,  -813,   950,  -813,  -813,  -813,  -813,  -813,  1220,  -813,
01981     -813,  -813,  -813,   678,  -813,   674,  8891,  -813,   676,   768,
01982      692,  -813,   701,   786,   707,   800,  -813,  -813,   885,  -813,
01983     -813,  -813,  -813,  -813,   422,  -813,  1115,  5676,  -813,  -813,
01984     5402,    19,  5676,   718,  8546,  -813,   597,  9680,  9006,  8891,
01985      739,  9006,  9006,  -813,   522,   364,   721,   717,  9006,  9006,
01986     -813,   522,   364,  -813,  -813,  8661,   842,  -813,   664,  -813,
01987      842,  -813,  -813,  -813,  -813,   755,    71,  -813,    66,    80,
01988      -35,   141,   162,  9121,   230,  -813,  9121,  4467,   505,   394,
01989     -813,   -35,   755,    93,  1220,  4467,  1220,  7046,  -813,    97,
01990      104,  -813,  8891,  -813,  -813,  -813,  8891,  8891,   557,  8891,
01991     8891,   728,    93,  -813,   733,  -813,  -813,  -813,   366,   950,
01992      459,  -813,   732,   -35,  -813,   -35,  -813,  8891,  1220,  -813,
01993     -813,   586,  -813,  -813,  -813,    42,  -813,  1220,  -813,  -813,
01994     1307,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
01995      -35,   751,   757,   737,  9791,  -813,   740,   692,  -813,   742,
01996      747,  -813,   734,   877,   758,  5402,   878,  8891,   761,   597,
01997     3209,  8891,  -813,  3209,  -813,  3209,  -813,  -813,  -813,  9006,
01998     -813,  3209,  -813,  3209,  -813,  -813,   607,  -813,   804,  -813,
01999     5005,   890,  -813,  9121,   755,  -813,   755,  5676,  5676,  -813,
02000     8776,  4749,   288,    65,  -813,   230,   755,  -813,  -813,  -813,
02001      -35,   755,   230,  -813,  -813,  -813,  3209,  8891,  7971,  -813,
02002     -813,   -35,   873,   769,  1000,  -813,   765,    73,  -813,  -813,
02003     -813,   772,   773,  -813,   692,  -813,   776,  -813,   777,  -813,
02004      776,  5791,   787,  -813,  9791,  1220,  -813,   855,   673,   586,
02005     -813,  -813,  1220,  -813,  1307,  -813,  1016,  -813,  -813,   783,
02006     -813,   788,  3209,  -813,  3209,  9902,   112,  -813,  -813,  5676,
02007     -813,  -813,   112,  -813,  -813,   755,   755,  -813,   542,  -813,
02008     4467,  -813,  -813,  -813,  -813,  -813,   647,  -813,   796,   873,
02009      484,  -813,  -813,  5676,  5402,  -813,  1220,  -813,  1307,  -813,
02010     -813,  1307,  -813,  1307,  -813,  -813,   813,  -813,   673,  -813,
02011      799,   801,  -813, 10753,  -813,   692,   802,  -813,   808,   802,
02012     -813,   367,  -813,  -813,  -813,   875,  -813,   681,   565,   590,
02013      604,  4467,  -813,  4608,  -813,  -813,  -813,  -813,  -813,  5676,
02014      755,  4467,   873,   796,   873,   811,   923,   815,   776,   817,
02015      776,   776,  -813,  1220,  -813,  1307,  -813,   818,   820,  -813,
02016     1307,  -813,  1307,  -813,  -813,  1016,  -813,   648, 10832,  7511,
02017    10911,   763,   664,   755,  -813,   755,   796,   873,  -813,  -813,
02018     -813,  1307,  -813,  -813,  -813,   802,   819,   802,   802,  -813,
02019      169,   394,   -35,   127,   146,  -813,  -813,  -813,  -813,   796,
02020      776,  -813,  1307,  -813,  -813,  -813,   180,  -813,   802,  -813
02021 };
02022 
02023 /* YYPGOTO[NTERM-NUM].  */
02024 static const yytype_int16 yypgoto[] =
02025 {
02026     -813,  -813,  -813,  -361,  -813,    29,  -813,  -540,   -29,  -813,
02027      515,  -813,    43,  -813,  -301,   -63,   -71,    21,  -813,  -174,
02028     -813,   797,   -10,   869,  -158,    16,   -76,  -813,  -395,     8,
02029     1783,  -325,   870,   -53,  -813,    -5,  -813,  -813,     3,  -813,
02030     1127,  -813,   -19,  -813,   -67,   257,  -317,   118,    -3,  -813,
02031     -390,  -181,    -4,  -813,  -313,   -15,  -813,  -813,  -813,  -813,
02032     -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,  -813,
02033     -813,  -813,  -813,  -813,    55,  -813,  -813,  -813,  -813,  -813,
02034     -813,  -813,  -813,  -813,  -813,  -541,  -344,  -527,   -45,  -631,
02035     -813,  -770,  -784,   210,   290,   172,  -813,  -425,  -813,  -663,
02036     -813,   -31,  -813,  -813,  -813,  -813,  -813,  -813,  -813,   236,
02037     -813,  -813,  -813,  -813,  -813,  -813,  -813,   -96,  -813,  -813,
02038     -556,  -813,   -34,  -813,  -813,  -813,  -813,  -813,  -813,   889,
02039     -813,  -813,  -813,  -813,   691,  -813,  -813,  -813,  -813,  -813,
02040     -813,  -813,   933,  -813,   -97,  -813,  -813,  -813,  -813,  -813,
02041        0,  -813,     6,  -813,   -11,  1321,  1524,   897,  1945,  1604,
02042     -813,  -813,    58,  -813,  -404,  -154,  -323,  -812,   123,  -717,
02043       87,    76,   215,   101,  -813,  -813,  -813,   -69,  -711,  -629,
02044      106,   237,  -813,  -616,  -813,   -44,  -626,  -813,  -813,  -813,
02045       98,  -392,  -813,  -319,  -813,   624,   -46,   -26,  -168,  -565,
02046     -207,   -28,   -13,    -2
02047 };
02048 
02049 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
02050    positive, shift that token.  If negative, reduce the rule which
02051    number is the opposite.  If YYTABLE_NINF, syntax error.  */
02052 #define YYTABLE_NINF -628
02053 static const yytype_int16 yytable[] =
02054 {
02055      119,   235,   402,   238,   286,   327,   211,   211,   201,   318,
02056      211,   199,   217,   217,   202,   527,   217,   573,   361,   232,
02057      725,   364,   254,   237,   611,   359,   359,   522,   201,   359,
02058      618,   199,   611,   120,   202,   267,   559,   727,   567,   561,
02059      276,   307,   423,   396,   786,    71,   365,    71,   724,   264,
02060      758,   266,   270,   587,   300,   742,   308,    86,   461,    86,
02061      199,   880,   463,   275,   307,   434,   276,   259,   618,   660,
02062      810,   218,   218,   319,   639,   218,   887,   768,   276,   276,
02063      276,   628,   601,   690,   570,   841,   692,   301,   938,   846,
02064      453,  -105,   721,   454,   973,   449,   489,   685,   559,   199,
02065      567,   615,   943,  -522,   941,  -107,    86,   495,   234,   399,
02066      277,     3,   876,  -514,   223,   223,  -522,   233,   223,  -101,
02067      240,   218,   234,   316,   696,   570,   631,  -339,   250,  -101,
02068      314,   315,   321,  -102,   215,   225,   277,   892,   226,   686,
02069     -104,   655,  -101,   218,   218,   490,  -109,   218,   370,   381,
02070      381,   265,   269,   631,   642,   993,   496,   400,    58,  -106,
02071     -108,  -514,   882,   -92,   656,   852,  -104,   518,   316,  -288,
02072      433,   888,   435,  -288,  -339,  -339,   857,   254,   880,   318,
02073      900,   901,  -105,   292,   849,   407,   944,  -106,   409,   410,
02074      411,   585,   480,  -103,   483,   586,   487,   856,   467,   455,
02075      487,   858,   -96,   973,  -605,   861,   304,   850,   305,   451,
02076     1026,   443,   304,   588,   305,   416,   -98,   211,  -606,   211,
02077      211,   416,   941,   217,   254,   217,   294,   307,   432,   317,
02078      -92,   618,   611,   611,   880,   887,   234,   296,   500,   501,
02079      502,   503,   452,  1049,   -93,   464,   359,   359,   359,   359,
02080      423,   505,   506,   304,   660,   305,   619,  -100,   950,   276,
02081      621,    86,   466,   631,   730,   624,   815,   740,  -104,   259,
02082     -104,   -99,   764,   967,   317,   631,   741,   -95,   298,   961,
02083      230,   634,   218,   323,   218,   218,   968,  -106,   218,  -106,
02084      218,   574,   575,   880,   447,    86,   254,   986,   -97,   359,
02085      359,   -95,   819,   923,   514,   924,    86,  -605,    86,   526,
02086     -105,   276,  -105,  -103,   584,   932,   328,   218,   576,   515,
02087      934,  -103,  -523,  -103,   515,   223,   929,   223,   324,   277,
02088      999,   589,   404,   421,   520,   775,   307,   499,  -602,  1009,
02089      660,   259,   660,   406,   513,   424,   211,   427,  -102,   523,
02090      695,    71,   591,   304,   432,   305,   504,   233,   355,  -109,
02091      565,   314,   315,    86,   218,   218,   218,   218,    86,   218,
02092      218,   304,   987,   305,   967,   446,   -97,   -73,   218,  -513,
02093       86,   277,   851,   218,   984,   985,   408,  1036,   417,   680,
02094      990,   -95,  -434,   467,   608,   610,   680,   522,   -87,  -508,
02095      412,  -108,   837,   267,   565,   356,   357,   329,   211,   474,
02096      474,   218,   -95,    86,   414,   -95,   432,   218,   218,   -95,
02097      422,   860,   565,   862,   -94,   602,   604,  -513,   416,   416,
02098      766,   755,   218,   413,   625,   418,   419,   420,   610,   201,
02099      119,   267,   199,   467,  -602,   202,  -508,  -508,   565,  1024,
02100     -602,  1025,   440,  -434,   276,   475,   475,   476,   476,   218,
02101      218,   211,   352,   353,   354,   457,   -97,   460,   765,   432,
02102      759,  -515,   458,   218,   458,   565,   618,  1056,   611,   474,
02103      227,  -294,  1047,   482,  1048,    71,   442,   -97,   679,   682,
02104      -97,   703,   329,   693,   -97,   329,  -104,    86,  -434,   710,
02105     -434,  -434,   230,  1015,   276,   689,   689,    86,   450,   689,
02106      234,   645,   612,   646,   647,   648,   649,   700,   788,  -515,
02107      791,  -603,   444,   -72,   277,   475,   218,   476,  -294,  -294,
02108      826,  -609,  -606,   743,   748,   706,   645,   834,   646,   647,
02109      648,   649,   718,   456,   720,  -516,   723,   723,   350,   351,
02110      352,   353,   354,   462,  -518,   637,   704,   840,   526,   577,
02111      735,  -523,   767,   762,   711,   474,   465,   717,   469,   418,
02112      445,   211,   981,   726,   277,   859,   474,   484,   983,   432,
02113      755,   488,  -511,   211,   497,   565,   474,  -102,   491,   706,
02114      754,   432,  -609,  -516,   869,   872,   663,   565,   750,   751,
02115      494,   753,  -518,   610,   267,   875,   201,   470,   -93,   199,
02116      416,   475,   202,   476,   477,   760,   706,   807,   509,  -517,
02117      994,   467,   475,   276,   476,   479,    86,  -603,    86,  -511,
02118     -511,   119,   475,  -603,   476,   481,   218,  -609,   827,  -609,
02119     -609,  -106,   811,  -605,   650,   748,   867,   780,   218,  -519,
02120       86,   218,  -520,   864,   471,   472,   651,  -508,   813,   577,
02121      812,   814,   853,   816,   521,   855,   783,  -517,   783,  -511,
02122      359,   498,  -103,   359,   579,   818,    71,  -521,   843,   840,
02123      583,   218,   276,   620,   654,   655,   622,   623,    86,   689,
02124      633,  -284,   933,   277,   863,   -87,   836,  -519,   681,  -520,
02125     -520,   631,  1042,   937,   706,  -508,   854,   580,   656,   629,
02126      751,   515,   884,   839,   842,   706,   842,  -511,   842,   523,
02127      761,   474,   822,   824,  -521,  -521,   683,   947,   949,   830,
02128      832,   592,   952,   638,   954,  -295,   955,   885,  -284,  -284,
02129      405,   885,    86,  -266,   694,    86,   697,    86,   474,   812,
02130      199,   698,   277,   218,   581,   582,   218,   218,   878,   416,
02131      963,  -425,   804,   218,   218,   713,  -109,   475,  1018,   476,
02132      485,   715,   922,   803,   812,   774,   446,   708,   593,   594,
02133      359,   663,  -295,  -295,   719,   744,   909,  -100,   218,   276,
02134      763,   218,    86,   777,   475,   709,   476,   492,   911,    76,
02135       86,    76,  -108,  -104,   783,   783,   829,   593,   594,   802,
02136      778,   918,   781,    76,    76,  1019,  1020,    76,   925,   926,
02137      784,  -106,   928,   -99,   -95,   723,   807,   931,   785,   436,
02138      965,   927,  -103,   807,   935,   807,   917,   787,   789,   921,
02139      437,   438,   -97,   790,  1030,  1032,  1033,  1034,    76,   267,
02140      913,   811,   792,   -94,  -267,   885,   821,   840,   811,   898,
02141      811,   828,   956,    76,   868,   329,   870,   663,   874,   663,
02142       86,   893,   894,   895,   886,   906,   899,   890,   902,   276,
02143      342,   343,   783,   904,   218,    76,    76,   907,   910,    76,
02144      982,   908,   774,   873,   915,    86,  1057,  -268,   218,   919,
02145      276,   663,    86,    86,   942,   939,    86,   957,   946,   948,
02146      663,   962,   951,   953,   996,   997,   974,   349,   350,   351,
02147      352,   353,   354,  1002,  -269,   645,   842,   646,   647,   648,
02148      649,  1017,   992,  1028,   807,  1003,   807,  1005,  1010,   794,
02149      795,   807,   796,   807,  1012,  1016,    86,  1027,  1029,   958,
02150       46,    47,  1021,  1031,  1022,  1052,  -605,   329,  -606,   811,
02151     1023,   811,   368,   783,   769,   385,   811,   635,   811,   835,
02152      977,   804,   342,   343,    86,   804,   799,  1046,   804,   871,
02153      804,   903,   905,   807,  1039,    86,   865,  1045,   493,   966,
02154      403,   969,   290,   397,   991,   774,   883,   774,    86,    86,
02155      964,   960,   645,    76,   646,   647,   648,   649,   811,   211,
02156      350,   351,   352,   353,   354,   881,   706,   432,   802,   717,
02157      842,     0,   598,   565,    76,   802,    76,    76,     0,     0,
02158       76,     0,    76,   998,     0,  1000,    86,    76,    86,     0,
02159     1001,   769,     0,     0,    86,     0,    86,   770,    76,     0,
02160       76,     0,   645,     0,   646,   647,   648,   649,     0,    76,
02161        0,     0,   774,   995,    41,    42,    43,    44,   970,   663,
02162      646,   647,   648,   649,   218,     0,     0,     0,     0,   804,
02163        0,   804,     0,     0,     0,     0,   804,     0,   804,     0,
02164     1035,   769,  1037,     0,     0,     0,     0,   940,     0,  1038,
02165      309,   310,   311,   312,   313,    76,    76,    76,    76,    76,
02166       76,    76,    76,     0,     0,   774,     0,   774,  1050,     0,
02167       76,     0,    76,     0,     0,    76,   802,     0,   804,     0,
02168        0,     0,  1004,  1006,     0,     0,     0,     0,  1011,  1058,
02169     1013,  1014,     0,   213,   213,     0,     0,   213,     0,     0,
02170      774,     0,     0,    76,     0,    76,     0,     0,     0,    76,
02171       76,     0,     0,     0,     0,     0,     0,   645,     0,   646,
02172      647,   648,   649,   650,    76,   247,   249,     0,     0,     0,
02173      213,   213,     0,     0,     0,   651,     0,     0,     0,     0,
02174        0,     0,     0,   302,   303,     0,     0,     0,     0,     0,
02175        0,    76,    76,     0,     0,     0,   652,  1051,  1053,  1054,
02176     1055,     0,   653,   654,   655,    76,   645,     0,   646,   647,
02177      648,   649,   650,     0,     0,     0,     0,     0,     0,     0,
02178     1059,     0,     0,     0,   651,     0,     0,   656,     0,    76,
02179      657,     0,     0,     0,     0,     0,     0,     0,     0,    76,
02180        0,     0,     0,     0,     0,   652,  -627,     0,   234,     0,
02181        0,   653,   654,   655,  -627,  -627,  -627,     0,    76,  -627,
02182     -627,  -627,   645,  -627,   646,   647,   648,   649,   650,     0,
02183        0,     0,  -627,  -627,     0,     0,   656,     0,     0,   657,
02184      651,     0,     0,  -627,  -627,     0,  -627,  -627,  -627,  -627,
02185     -627,     0,   658,     0,     0,     0,     0,     0,     0,     0,
02186        0,   652,     0,     0,     0,     0,     0,   653,   654,   655,
02187        0,     0,     0,   113,     0,   113,     0,     0,     0,     0,
02188        0,   213,     0,     0,   213,   213,   213,   302,     0,     0,
02189        0,     0,   656,  -627,     0,   657,     0,     0,     0,     0,
02190        0,     0,     0,     0,   213,     0,   213,   213,     0,   645,
02191        0,   646,   647,   648,   649,   650,  -627,     0,    76,     0,
02192       76,     0,   113,     0,     0,     0,   278,   651,    76,     0,
02193        0,     0,     0,     0,     0,   329,     0,     0,  -627,  -627,
02194       76,  -627,    76,    76,   230,  -627,     0,  -627,   652,  -627,
02195      342,   343,   278,     0,     0,   654,   655,     0,     0,     0,
02196        0,     0,     0,     0,   372,   382,   382,   382,     0,     0,
02197        0,     0,     0,    76,     0,     0,     0,     0,     0,   656,
02198       76,     0,     0,     0,     0,   347,   348,   349,   350,   351,
02199      352,   353,   354,     0,     0,     0,     0,     0,     0,     0,
02200      213,     0,     0,     0,     0,   525,   528,   529,   530,   531,
02201      532,   533,   534,   535,   536,   537,   538,   539,   540,   541,
02202      542,   543,   544,   545,   546,   547,   548,   549,   550,   551,
02203      552,   553,     0,   213,    76,     0,     0,    76,     0,    76,
02204        0,     0,     0,     0,     0,    76,     0,     0,    76,    76,
02205        0,     0,     0,     0,     0,    76,    76,     0,     0,     0,
02206        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02207        0,     0,     0,     0,     0,     0,   114,   113,   114,     0,
02208       76,   603,   605,    76,    76,     0,     0,     0,     0,   607,
02209      213,   213,    76,     0,     0,   213,     0,   603,   605,   213,
02210        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02211        0,   113,     0,     0,     0,     0,     0,     0,   627,     0,
02212        0,     0,   113,   632,   113,   114,     0,     0,     0,   279,
02213        0,     0,     0,     0,   213,     0,     0,   213,     0,     0,
02214        0,     0,     0,     0,     0,   278,     0,     0,   213,     0,
02215        0,     0,     0,     0,     0,   279,   117,     0,   117,     0,
02216        0,     0,    76,     0,     0,     0,     0,   373,   383,   383,
02217      383,     0,     0,     0,   684,     0,    76,     0,     0,   113,
02218        0,     0,     0,     0,   113,     0,     0,    76,     0,   213,
02219       76,     0,     0,     0,    76,    76,   113,   278,    76,     0,
02220        0,     0,     0,     0,     0,   117,     0,     0,     0,   280,
02221        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02222        0,     0,     0,     0,     0,     0,     0,     0,     0,   113,
02223        0,     0,     0,     0,     0,   280,     0,     0,    76,     0,
02224        0,     0,     0,     0,     0,     0,     0,   374,   384,   384,
02225        0,     0,     0,     0,   213,     0,     0,     0,   213,     0,
02226        0,     0,     0,     0,     0,     0,    76,     0,     0,     0,
02227      213,     0,     0,     0,     0,     0,     0,    76,     0,     0,
02228      114,     0,     0,     0,     0,     0,   213,     0,     0,     0,
02229       76,    76,     0,     0,     0,     0,     0,     0,     0,   213,
02230      213,   329,   330,   331,   332,   333,   334,   335,   336,     0,
02231      338,   339,     0,   113,   114,     0,   342,   343,     0,     0,
02232        0,     0,     0,   113,     0,   114,     0,   114,    76,     0,
02233       76,     0,     0,     0,     0,    83,    76,    83,    76,     0,
02234      278,     0,     0,   213,     0,     0,     0,     0,   279,   345,
02235      346,   347,   348,   349,   350,   351,   352,   353,   354,     0,
02236      117,     0,     0,     0,     0,     0,    76,     0,     0,     0,
02237        0,   213,     0,     0,     0,   607,   820,     0,   823,   825,
02238        0,     0,   114,     0,    83,   831,   833,   114,     0,     0,
02239      278,     0,   213,     0,   117,     0,     0,     0,     0,   114,
02240      279,     0,     0,     0,     0,   117,     0,   117,     0,     0,
02241        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02242        0,     0,     0,     0,     0,     0,   369,     0,   280,   866,
02243        0,     0,   114,   823,   825,     0,   831,   833,     0,     0,
02244        0,     0,   113,     0,   113,     0,     0,     0,     0,     0,
02245        0,     0,     0,     0,   213,     0,     0,     0,     0,     0,
02246        0,     0,   117,     0,     0,     0,   113,   117,     0,     0,
02247        0,     0,     0,     0,     0,     0,     0,     0,     0,   117,
02248      280,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02249        0,     0,     0,     0,   213,     0,     0,   116,   912,   116,
02250        0,     0,     0,     0,   113,     0,   914,     0,     0,   278,
02251        0,     0,   117,     0,     0,     0,   114,     0,     0,     0,
02252        0,     0,     0,     0,     0,     0,   114,   213,     0,     0,
02253        0,     0,     0,     0,     0,     0,     0,     0,     0,    83,
02254        0,     0,     0,   279,   914,   213,   116,     0,     0,     0,
02255        0,     0,     0,     0,     0,     0,     0,     0,   113,     0,
02256        0,   113,     0,   113,     0,     0,     0,     0,   278,     0,
02257        0,     0,     0,    83,     0,     0,     0,     0,     0,     0,
02258        0,     0,     0,     0,    83,     0,    83,     0,     0,     0,
02259        0,     0,     0,   279,     0,     0,   117,     0,     0,     0,
02260        0,     0,   699,     0,     0,     0,   117,     0,   113,     0,
02261        0,     0,     0,     0,     0,     0,   113,     0,     0,     0,
02262        0,     0,     0,   280,     0,     0,     0,     0,   329,   330,
02263      331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
02264      341,    83,     0,   342,   343,   114,    83,   114,     0,     0,
02265        0,     0,     0,     0,     0,     0,     0,     0,    83,     0,
02266        0,   524,     0,     0,     0,     0,     0,     0,     0,   114,
02267        0,     0,     0,   280,   344,   382,   345,   346,   347,   348,
02268      349,   350,   351,   352,   353,   354,   113,     0,     0,     0,
02269        0,    83,     0,     0,  -243,     0,   213,     0,     0,     0,
02270        0,   116,     0,     0,     0,     0,     0,   114,     0,     0,
02271        0,   113,   279,     0,     0,     0,     0,     0,   113,   113,
02272        0,     0,   113,     0,     0,   117,     0,   117,     0,     0,
02273        0,     0,     0,     0,     0,   116,     0,     0,     0,     0,
02274        0,     0,     0,     0,     0,     0,   116,     0,   116,   117,
02275        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02276        0,   114,   113,     0,   114,   382,   114,     0,     0,     0,
02277        0,   279,     0,     0,     0,    83,     0,     0,     0,     0,
02278        0,     0,     0,     0,     0,    83,   978,   117,     0,     0,
02279      113,     0,   280,     0,     0,     0,     0,     0,     0,     0,
02280        0,   113,     0,   116,     0,     0,     0,     0,   116,     0,
02281        0,   114,     0,     0,   113,   113,     0,     0,     0,   114,
02282      116,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02283        0,     0,   798,     0,     0,     0,     0,     0,     0,     0,
02284        0,   117,     0,     0,   117,     0,   117,     0,     0,     0,
02285        0,   280,   113,   116,   113,     0,     0,     0,     0,     0,
02286      113,     0,   113,     0,     0,     0,     0,     0,     0,     0,
02287        0,     0,     0,     0,     0,     0,     0,     0,   383,     0,
02288        0,     0,     0,     0,     0,     0,     0,     0,     0,   114,
02289        0,   117,     0,     0,     0,     0,     0,     0,     0,   117,
02290        0,     0,     0,     0,    83,     0,    83,     0,     0,     0,
02291        0,     0,     0,     0,   114,     0,     0,     0,     0,     0,
02292        0,   114,   114,     0,     0,   114,     0,     0,    83,   329,
02293     -628,  -628,  -628,  -628,   334,   335,     0,   116,  -628,  -628,
02294        0,     0,     0,     0,   342,   343,     0,   116,     0,     0,
02295        0,     0,     0,     0,     0,     0,     0,     0,   384,     0,
02296        0,     0,     0,     0,     0,   114,    83,     0,   383,   117,
02297        0,     0,     0,     0,     0,     0,     0,   345,   346,   347,
02298      348,   349,   350,   351,   352,   353,   354,     0,     0,   979,
02299        0,     0,     0,   114,   117,     0,     0,     0,     0,     0,
02300        0,   117,   117,     0,   114,   117,     0,     0,     0,     0,
02301        0,     0,     0,     0,     0,     0,     0,   114,   114,     0,
02302       83,     0,     0,    83,     0,    83,     0,     0,     0,     0,
02303        0,   524,     0,     0,     0,     0,     0,     0,     0,     0,
02304        0,     0,     0,     0,     0,   117,     0,     0,   384,     0,
02305        0,     0,     0,     0,     0,   114,     0,   114,     0,     0,
02306        0,     0,     0,   114,     0,   114,   116,     0,   116,   980,
02307       83,     0,     0,   117,     0,     0,     0,     0,    83,  -609,
02308        0,     0,     0,     0,   117,     0,     0,  -609,  -609,  -609,
02309      116,     0,  -609,  -609,  -609,     0,  -609,   117,   117,     0,
02310        0,     0,     0,     0,     0,  -609,  -609,  -609,  -609,     0,
02311        0,     0,     0,     0,     0,     0,  -609,  -609,     0,  -609,
02312     -609,  -609,  -609,  -609,     0,     0,     0,     0,   116,     0,
02313        0,     0,     0,     0,     0,   117,     0,   117,     0,     0,
02314        0,     0,     0,   117,     0,   117,     0,     0,    83,  -609,
02315     -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,
02316     -609,  -609,     0,     0,  -609,  -609,  -609,     0,   756,  -609,
02317        0,     0,     0,    83,     0,  -609,     0,     0,     0,     0,
02318       83,    83,   116,     0,    83,   116,     0,   116,     0,  -609,
02319        0,     0,  -609,     0,  -105,  -609,  -609,  -609,  -609,  -609,
02320     -609,  -609,  -609,  -609,  -609,  -609,  -609,     0,     0,     0,
02321        0,  -609,  -609,  -609,  -609,  -609,     0,     0,  -609,  -609,
02322     -609,     0,  -609,     0,    83,     0,     0,     0,     0,     0,
02323        0,     0,   116,     0,     0,     0,     0,     0,     0,     0,
02324      116,   329,   330,   331,   332,   333,   334,   335,   976,     0,
02325      338,   339,    83,     0,     0,     0,   342,   343,     0,     0,
02326        0,     0,     0,    83,     0,     0,     0,     0,     0,     0,
02327        0,     0,     0,     0,     0,     0,    83,    83,     0,     0,
02328        0,     0,     0,     0,     0,     0,     0,     0,     0,   345,
02329      346,   347,   348,   349,   350,   351,   352,   353,   354,     0,
02330        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02331      116,     0,     0,     0,    83,     0,    83,     0,     0,     0,
02332        0,     0,    83,     0,    83,     0,     0,     0,     0,     0,
02333        0,     0,     0,     0,     0,   116,     0,     0,     0,     0,
02334        0,     0,   116,   116,     0,     0,   116,     0,     0,     0,
02335        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02336        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02337        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02338        0,     0,     0,     0,     0,     0,   116,     0,     0,     0,
02339        0,     0,     0,     0,     0,     0,     0,  -627,     4,     0,
02340        5,     6,     7,     8,     9,     0,     0,     0,    10,    11,
02341        0,     0,     0,    12,   116,    13,    14,    15,    16,    17,
02342       18,    19,     0,     0,     0,   116,     0,    20,    21,    22,
02343       23,    24,    25,    26,     0,     0,    27,     0,   116,   116,
02344        0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
02345       36,    37,    38,    39,    40,     0,    41,    42,    43,    44,
02346        0,    45,    46,    47,     0,    48,    49,     0,     0,     0,
02347        0,     0,     0,     0,     0,     0,   116,     0,   116,     0,
02348        0,     0,     0,     0,   116,    50,   116,     0,    51,    52,
02349        0,    53,    54,     0,    55,     0,     0,    56,    57,    58,
02350       59,    60,    61,    62,    63,    64,  -508,     0,     0,     0,
02351        0,     0,     0,     0,  -508,  -508,  -508,     0,     0,  -508,
02352     -508,  -508,     0,  -508,     0,    65,    66,    67,     0,   752,
02353        0,  -508,     0,  -508,  -508,  -508,     0,     0,  -627,     0,
02354     -627,     0,     0,  -508,  -508,     0,  -508,  -508,  -508,  -508,
02355     -508,     0,     0,     0,     0,   329,   330,   331,   332,   333,
02356      334,   335,   336,   337,   338,   339,   340,   341,     0,     0,
02357      342,   343,     0,     0,     0,     0,  -508,  -508,  -508,  -508,
02358     -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,     0,
02359        0,  -508,  -508,  -508,     0,  -508,  -508,     0,     0,     0,
02360        0,   344,  -508,   345,   346,   347,   348,   349,   350,   351,
02361      352,   353,   354,     0,     0,     0,  -508,     0,     0,  -508,
02362        0,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
02363     -508,  -508,  -508,  -508,     0,     0,     0,     0,     0,  -508,
02364     -508,  -508,  -508,  -511,     0,  -508,  -508,  -508,     0,  -508,
02365        0,  -511,  -511,  -511,     0,     0,  -511,  -511,  -511,     0,
02366     -511,     0,     0,     0,     0,     0,   699,     0,  -511,     0,
02367     -511,  -511,  -511,     0,     0,     0,     0,     0,     0,     0,
02368     -511,  -511,     0,  -511,  -511,  -511,  -511,  -511,     0,     0,
02369        0,     0,   329,   330,   331,   332,   333,   334,   335,   336,
02370      337,   338,   339,   340,   341,     0,     0,   342,   343,     0,
02371        0,     0,     0,  -511,  -511,  -511,  -511,  -511,  -511,  -511,
02372     -511,  -511,  -511,  -511,  -511,  -511,     0,     0,  -511,  -511,
02373     -511,     0,  -511,  -511,     0,     0,     0,     0,   344,  -511,
02374      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
02375        0,     0,     0,  -511,     0,     0,  -511,     0,  -511,  -511,
02376     -511,  -511,  -511,  -511,  -511,  -511,  -511,  -511,  -511,  -511,
02377     -511,     0,     0,     0,     0,     0,  -511,  -511,  -511,  -511,
02378     -610,     0,  -511,  -511,  -511,     0,  -511,     0,  -610,  -610,
02379     -610,     0,     0,  -610,  -610,  -610,     0,  -610,     0,     0,
02380        0,     0,     0,     0,     0,     0,  -610,  -610,  -610,  -610,
02381        0,     0,     0,     0,     0,     0,     0,  -610,  -610,     0,
02382     -610,  -610,  -610,  -610,  -610,     0,     0,     0,     0,   329,
02383      330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
02384      340,   341,     0,     0,   342,   343,     0,     0,     0,     0,
02385     -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,
02386     -610,  -610,  -610,     0,     0,  -610,  -610,  -610,     0,     0,
02387     -610,     0,     0,     0,     0,   344,  -610,   345,   346,   347,
02388      348,   349,   350,   351,   352,   353,   354,     0,     0,     0,
02389     -610,     0,     0,  -610,     0,     0,  -610,  -610,  -610,  -610,
02390     -610,  -610,  -610,  -610,  -610,  -610,  -610,  -610,     0,     0,
02391        0,     0,  -610,  -610,  -610,  -610,  -610,  -611,     0,  -610,
02392     -610,  -610,     0,  -610,     0,  -611,  -611,  -611,     0,     0,
02393     -611,  -611,  -611,     0,  -611,     0,     0,     0,     0,     0,
02394        0,     0,     0,  -611,  -611,  -611,  -611,     0,     0,     0,
02395        0,     0,     0,     0,  -611,  -611,     0,  -611,  -611,  -611,
02396     -611,  -611,     0,     0,     0,     0,   329,   330,   331,   332,
02397      333,   334,   335,   336,   337,   338,   339,  -628,  -628,     0,
02398        0,   342,   343,     0,     0,     0,     0,  -611,  -611,  -611,
02399     -611,  -611,  -611,  -611,  -611,  -611,  -611,  -611,  -611,  -611,
02400        0,     0,  -611,  -611,  -611,     0,     0,  -611,     0,     0,
02401        0,     0,     0,  -611,   345,   346,   347,   348,   349,   350,
02402      351,   352,   353,   354,     0,     0,     0,  -611,     0,     0,
02403     -611,     0,     0,  -611,  -611,  -611,  -611,  -611,  -611,  -611,
02404     -611,  -611,  -611,  -611,  -611,     0,     0,     0,     0,  -611,
02405     -611,  -611,  -611,  -611,  -294,     0,  -611,  -611,  -611,     0,
02406     -611,     0,  -294,  -294,  -294,     0,     0,  -294,  -294,  -294,
02407        0,  -294,     0,     0,     0,     0,     0,     0,     0,     0,
02408        0,  -294,  -294,  -294,     0,     0,     0,     0,     0,     0,
02409        0,  -294,  -294,     0,  -294,  -294,  -294,  -294,  -294,     0,
02410        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02411        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02412        0,     0,     0,     0,  -294,  -294,  -294,  -294,  -294,  -294,
02413     -294,  -294,  -294,  -294,  -294,  -294,  -294,     0,     0,  -294,
02414     -294,  -294,     0,   757,  -294,     0,     0,     0,     0,     0,
02415     -294,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02416        0,     0,     0,     0,  -294,     0,     0,  -294,     0,  -107,
02417     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,
02418     -294,  -294,     0,     0,     0,     0,     0,  -294,  -294,  -294,
02419     -294,  -433,     0,  -294,  -294,  -294,     0,  -294,     0,  -433,
02420     -433,  -433,     0,     0,  -433,  -433,  -433,     0,  -433,     0,
02421        0,     0,     0,     0,     0,     0,     0,  -433,  -433,  -433,
02422        0,     0,     0,     0,     0,     0,     0,     0,  -433,  -433,
02423        0,  -433,  -433,  -433,  -433,  -433,     0,     0,     0,     0,
02424        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02425        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02426        0,  -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,
02427     -433,  -433,  -433,  -433,     0,     0,  -433,  -433,  -433,     0,
02428        0,  -433,     0,     0,     0,     0,     0,  -433,     0,     0,
02429        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02430        0,  -433,     0,     0,     0,     0,     0,  -433,     0,  -433,
02431     -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,  -433,     0,
02432        0,     0,     0,  -433,  -433,  -433,  -433,  -433,  -285,   230,
02433     -433,  -433,  -433,     0,  -433,     0,  -285,  -285,  -285,     0,
02434        0,  -285,  -285,  -285,     0,  -285,     0,     0,     0,     0,
02435        0,     0,     0,     0,     0,  -285,  -285,  -285,     0,     0,
02436        0,     0,     0,     0,     0,  -285,  -285,     0,  -285,  -285,
02437     -285,  -285,  -285,     0,     0,     0,     0,     0,     0,     0,
02438        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02439        0,     0,     0,     0,     0,     0,     0,     0,  -285,  -285,
02440     -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02441     -285,     0,     0,  -285,  -285,  -285,     0,     0,  -285,     0,
02442        0,     0,     0,     0,  -285,     0,     0,     0,     0,     0,
02443        0,     0,     0,     0,     0,     0,     0,     0,  -285,     0,
02444        0,  -285,     0,     0,  -285,  -285,  -285,  -285,  -285,  -285,
02445     -285,  -285,  -285,  -285,  -285,  -285,     0,     0,     0,     0,
02446        0,  -285,  -285,  -285,  -285,  -423,     0,  -285,  -285,  -285,
02447        0,  -285,     0,  -423,  -423,  -423,     0,     0,  -423,  -423,
02448     -423,     0,  -423,     0,     0,     0,     0,     0,     0,     0,
02449        0,  -423,  -423,  -423,     0,     0,     0,     0,     0,     0,
02450        0,     0,  -423,  -423,     0,  -423,  -423,  -423,  -423,  -423,
02451        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02452        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02453        0,     0,     0,     0,     0,  -423,  -423,  -423,  -423,  -423,
02454     -423,  -423,  -423,  -423,  -423,  -423,  -423,  -423,     0,     0,
02455     -423,  -423,  -423,     0,     0,  -423,     0,     0,     0,     0,
02456        0,  -423,     0,     0,     0,     0,     0,     0,     0,     0,
02457        0,     0,     0,     0,     0,  -423,     0,     0,     0,     0,
02458        0,  -423,     0,  -423,  -423,  -423,  -423,  -423,  -423,  -423,
02459     -423,  -423,  -423,     0,     0,     0,     0,  -423,  -423,  -423,
02460     -423,  -423,  -301,  -423,  -423,  -423,  -423,     0,  -423,     0,
02461     -301,  -301,  -301,     0,     0,  -301,  -301,  -301,     0,  -301,
02462        0,     0,     0,     0,     0,     0,     0,     0,     0,  -301,
02463     -301,     0,     0,     0,     0,     0,     0,     0,     0,  -301,
02464     -301,     0,  -301,  -301,  -301,  -301,  -301,     0,     0,     0,
02465        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02466        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02467        0,     0,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02468     -301,  -301,  -301,  -301,  -301,     0,     0,  -301,  -301,  -301,
02469        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02470        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02471        0,     0,  -301,     0,     0,     0,     0,     0,  -301,     0,
02472     -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,  -301,
02473        0,     0,     0,     0,     0,  -301,  -301,  -301,  -301,  -609,
02474      227,  -301,  -301,  -301,     0,  -301,     0,  -609,  -609,  -609,
02475        0,     0,     0,  -609,  -609,     0,  -609,     0,     0,     0,
02476        0,     0,     0,     0,     0,  -609,     0,     0,     0,     0,
02477        0,     0,     0,     0,     0,     0,  -609,  -609,     0,  -609,
02478     -609,  -609,  -609,  -609,     0,     0,     0,     0,     0,     0,
02479        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02480        0,     0,     0,     0,     0,     0,     0,     0,     0,  -609,
02481     -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,  -609,
02482     -609,  -609,     0,     0,  -609,  -609,  -609,     0,   701,     0,
02483        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02484        0,     0,     0,     0,     0,     0,     0,     0,     0,  -609,
02485        0,     0,     0,     0,  -105,  -609,     0,  -609,  -609,  -609,
02486     -609,  -609,  -609,  -609,  -609,  -609,  -609,     0,     0,     0,
02487        0,  -609,  -609,  -609,  -609,   -96,  -294,     0,  -609,     0,
02488     -609,     0,  -609,     0,  -294,  -294,  -294,     0,     0,     0,
02489     -294,  -294,     0,  -294,     0,     0,     0,     0,     0,     0,
02490        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02491        0,     0,     0,  -294,  -294,     0,  -294,  -294,  -294,  -294,
02492     -294,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02493        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02494        0,     0,     0,     0,     0,     0,  -294,  -294,  -294,  -294,
02495     -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,  -294,     0,
02496        0,  -294,  -294,  -294,     0,   702,     0,     0,     0,     0,
02497        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02498        0,     0,     0,     0,     0,     0,  -294,     0,     0,     0,
02499        0,  -107,  -294,     0,  -294,  -294,  -294,  -294,  -294,  -294,
02500     -294,  -294,  -294,  -294,     0,     0,     0,     0,     0,  -294,
02501     -294,  -294,   -98,     0,     0,  -294,     0,  -294,   251,  -294,
02502        5,     6,     7,     8,     9,  -627,  -627,  -627,    10,    11,
02503        0,     0,  -627,    12,     0,    13,    14,    15,    16,    17,
02504       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02505       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02506        0,     0,    28,    29,   252,    31,    32,    33,    34,    35,
02507       36,    37,    38,    39,    40,     0,    41,    42,    43,    44,
02508        0,    45,    46,    47,     0,    48,    49,     0,     0,     0,
02509        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02510        0,     0,     0,     0,     0,    50,     0,     0,    51,    52,
02511        0,    53,    54,     0,    55,     0,     0,    56,    57,    58,
02512       59,    60,    61,    62,    63,    64,     0,     0,     0,     0,
02513        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02514        0,     0,     0,     0,     0,    65,    66,    67,     0,     0,
02515        0,     0,     0,     0,     0,     0,     0,     0,  -627,   251,
02516     -627,     5,     6,     7,     8,     9,     0,     0,  -627,    10,
02517       11,     0,  -627,  -627,    12,     0,    13,    14,    15,    16,
02518       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02519       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02520        0,     0,     0,    28,    29,   252,    31,    32,    33,    34,
02521       35,    36,    37,    38,    39,    40,     0,    41,    42,    43,
02522       44,     0,    45,    46,    47,     0,    48,    49,     0,     0,
02523        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02524        0,     0,     0,     0,     0,     0,    50,     0,     0,    51,
02525       52,     0,    53,    54,     0,    55,     0,     0,    56,    57,
02526       58,    59,    60,    61,    62,    63,    64,     0,     0,     0,
02527        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02528        0,     0,     0,     0,     0,     0,    65,    66,    67,     0,
02529        0,     0,     0,     0,     0,     0,     0,     0,     0,  -627,
02530      251,  -627,     5,     6,     7,     8,     9,     0,     0,  -627,
02531       10,    11,     0,     0,  -627,    12,  -627,    13,    14,    15,
02532       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02533       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02534        0,     0,     0,     0,    28,    29,   252,    31,    32,    33,
02535       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02536       43,    44,     0,    45,    46,    47,     0,    48,    49,     0,
02537        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02538        0,     0,     0,     0,     0,     0,     0,    50,     0,     0,
02539       51,    52,     0,    53,    54,     0,    55,     0,     0,    56,
02540       57,    58,    59,    60,    61,    62,    63,    64,     0,     0,
02541        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02542        0,     0,     0,     0,     0,     0,     0,    65,    66,    67,
02543        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02544     -627,   251,  -627,     5,     6,     7,     8,     9,     0,     0,
02545     -627,    10,    11,     0,     0,  -627,    12,     0,    13,    14,
02546       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02547       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02548        0,     0,     0,     0,     0,    28,    29,   252,    31,    32,
02549       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02550       42,    43,    44,     0,    45,    46,    47,     0,    48,    49,
02551        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02552        0,     0,     0,     0,     0,     0,     0,     0,    50,     0,
02553        0,    51,    52,     0,    53,    54,     0,    55,     0,     0,
02554       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
02555        0,     0,     0,     0,     0,     0,   251,     0,     5,     6,
02556        7,     8,     9,     0,  -627,  -627,    10,    11,    65,    66,
02557       67,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02558        0,  -627,     0,  -627,     0,    20,    21,    22,    23,    24,
02559       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02560       28,    29,   252,    31,    32,    33,    34,    35,    36,    37,
02561       38,    39,    40,     0,    41,    42,    43,    44,     0,    45,
02562       46,    47,     0,    48,    49,     0,     0,     0,     0,     0,
02563        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02564        0,     0,     0,    50,     0,     0,    51,    52,     0,    53,
02565       54,     0,    55,     0,     0,    56,    57,    58,    59,    60,
02566       61,    62,    63,    64,     0,     0,     0,     0,     0,     0,
02567        0,   251,     0,     5,     6,     7,     8,     9,     0,     0,
02568        0,    10,    11,    65,    66,    67,    12,     0,    13,    14,
02569       15,    16,    17,    18,    19,     0,  -627,     0,  -627,     0,
02570       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02571        0,     0,     0,     0,     0,    28,    29,   252,    31,    32,
02572       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02573       42,    43,    44,     0,    45,    46,    47,     0,    48,    49,
02574        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02575        0,     0,     0,     0,     0,     0,     0,     0,    50,     0,
02576        0,   253,    52,     0,    53,    54,     0,    55,     0,     0,
02577       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
02578        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02579        0,     0,     0,     0,     0,     0,     0,     0,    65,    66,
02580       67,     0,     0,     0,     0,     0,     0,     0,     0,  -627,
02581        0,  -627,   251,  -627,     5,     6,     7,     8,     9,     0,
02582        0,     0,    10,    11,     0,     0,     0,    12,     0,    13,
02583       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02584        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02585       27,     0,     0,     0,     0,     0,    28,    29,   252,    31,
02586       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02587       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02588       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02589        0,     0,     0,     0,     0,     0,     0,     0,     0,    50,
02590        0,     0,    51,    52,     0,    53,    54,     0,    55,     0,
02591        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02592        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02593        0,     0,     0,     0,     0,     0,     0,     0,     0,    65,
02594       66,    67,     0,     0,     0,     0,     0,     0,     0,     0,
02595     -627,     0,  -627,   251,  -627,     5,     6,     7,     8,     9,
02596        0,     0,     0,    10,    11,     0,     0,     0,    12,     0,
02597       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02598        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02599        0,    27,     0,     0,     0,     0,     0,    28,    29,   252,
02600       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02601        0,    41,    42,    43,    44,     0,    45,    46,    47,     0,
02602       48,    49,     0,     0,     0,     0,     0,     0,     0,     0,
02603        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02604       50,     0,     0,    51,    52,     0,    53,    54,     0,    55,
02605        0,     0,    56,    57,    58,    59,    60,    61,    62,    63,
02606       64,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02607        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02608       65,    66,    67,     0,     0,  -627,     4,     0,     5,     6,
02609        7,     8,     9,  -627,     0,  -627,    10,    11,     0,     0,
02610        0,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02611        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02612       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02613       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02614       38,    39,    40,     0,    41,    42,    43,    44,     0,    45,
02615       46,    47,     0,    48,    49,     0,     0,     0,     0,     0,
02616        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02617        0,     0,     0,    50,     0,     0,    51,    52,     0,    53,
02618       54,     0,    55,     0,     0,    56,    57,    58,    59,    60,
02619       61,    62,    63,    64,     0,     0,     0,     0,     0,     0,
02620        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02621        0,     0,     0,    65,    66,    67,     0,     0,  -627,     0,
02622        0,     0,     0,     0,     0,     0,  -627,   251,  -627,     5,
02623        6,     7,     8,     9,     0,     0,  -627,    10,    11,     0,
02624        0,     0,    12,     0,    13,    14,    15,    16,    17,    18,
02625       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02626       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02627        0,    28,    29,   252,    31,    32,    33,    34,    35,    36,
02628       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02629       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02630        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02631        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02632       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02633       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02634        0,     0,   251,     0,     5,     6,     7,     8,     9,     0,
02635        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02636       14,    15,    16,    17,    18,    19,     0,  -627,     0,  -627,
02637        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02638       27,     0,     0,     0,     0,     0,    28,    29,   252,    31,
02639       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02640       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02641       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02642        0,     0,     0,     0,     0,     0,     0,     0,     0,    50,
02643        0,     0,    51,    52,     0,    53,    54,     0,    55,     0,
02644        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02645        0,  -627,     0,     0,     0,     0,     0,     0,     0,     5,
02646        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02647       66,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02648       19,     0,  -627,     0,  -627,     0,    20,    21,    22,    23,
02649       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02650        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02651       37,    38,    39,    40,   204,    41,    42,    43,    44,     0,
02652       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02653        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02654        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02655       53,    54,     0,   207,   208,   209,    56,    57,    58,    59,
02656       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02657        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02658        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02659       14,    15,    16,    17,    18,    19,     0,     0,     0,   234,
02660        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02661       27,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02662       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02663       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02664       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02665        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02666        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
02667        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02668        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02669        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02670       66,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02671       19,     0,   304,     0,   305,     0,    20,    21,    22,    23,
02672       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02673        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02674       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02675       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02676        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02677        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02678       53,    54,     0,     0,     0,     0,    56,    57,    58,    59,
02679       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02680        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02681        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02682       14,    15,    16,    17,    18,    19,     0,     0,     0,   234,
02683        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02684       27,     0,     0,     0,     0,     0,    28,    29,    30,    31,
02685       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02686       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02687       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02688        0,     0,     0,     0,     0,     0,     0,     0,     0,    50,
02689        0,     0,    51,    52,     0,    53,    54,     0,    55,     0,
02690        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02691        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02692        6,     7,     8,     9,     0,     0,     0,    10,    11,    65,
02693       66,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02694       19,     0,   498,     0,     0,     0,    20,    21,    22,    23,
02695       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02696        0,    28,    29,   252,    31,    32,    33,    34,    35,    36,
02697       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02698       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02699        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02700        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02701       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02702       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02703        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02704        0,     0,     0,     0,    65,    66,    67,     0,     0,     0,
02705        0,     0,     0,     0,     0,     0,     0,   498,   121,   122,
02706      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02707      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
02708      143,   144,     0,     0,     0,   145,   146,   147,   386,   387,
02709      388,   389,   152,   153,   154,     0,     0,     0,     0,     0,
02710      155,   156,   157,   158,   390,   391,   392,   393,   163,    37,
02711       38,   394,    40,     0,     0,     0,     0,     0,     0,     0,
02712        0,     0,     0,   165,   166,   167,   168,   169,   170,   171,
02713      172,   173,     0,     0,   174,   175,     0,     0,   176,   177,
02714      178,   179,     0,     0,     0,     0,     0,     0,     0,     0,
02715        0,     0,   180,   181,     0,     0,     0,     0,     0,     0,
02716        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02717        0,     0,     0,   182,   183,   184,   185,   186,   187,   188,
02718      189,   190,   191,     0,   192,   193,     0,     0,     0,     0,
02719        0,     0,   194,   395,   121,   122,   123,   124,   125,   126,
02720      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02721      137,   138,   139,   140,   141,   142,   143,   144,     0,     0,
02722        0,   145,   146,   147,   148,   149,   150,   151,   152,   153,
02723      154,     0,     0,     0,     0,     0,   155,   156,   157,   158,
02724      159,   160,   161,   162,   163,   283,   284,   164,   285,     0,
02725        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
02726      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
02727      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
02728        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
02729        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02730        0,     0,     0,     0,     0,     0,     0,     0,     0,   182,
02731      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
02732      192,   193,     0,     0,     0,     0,     0,     0,   194,   121,
02733      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02734      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
02735      142,   143,   144,     0,     0,     0,   145,   146,   147,   148,
02736      149,   150,   151,   152,   153,   154,     0,     0,     0,     0,
02737        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02738      236,     0,   164,     0,     0,     0,     0,     0,     0,     0,
02739        0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
02740      171,   172,   173,     0,     0,   174,   175,     0,     0,   176,
02741      177,   178,   179,     0,     0,     0,     0,     0,     0,     0,
02742        0,     0,     0,   180,   181,     0,     0,    57,     0,     0,
02743        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02744        0,     0,     0,     0,   182,   183,   184,   185,   186,   187,
02745      188,   189,   190,   191,     0,   192,   193,     0,     0,     0,
02746        0,     0,     0,   194,   121,   122,   123,   124,   125,   126,
02747      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02748      137,   138,   139,   140,   141,   142,   143,   144,     0,     0,
02749        0,   145,   146,   147,   148,   149,   150,   151,   152,   153,
02750      154,     0,     0,     0,     0,     0,   155,   156,   157,   158,
02751      159,   160,   161,   162,   163,     0,     0,   164,     0,     0,
02752        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
02753      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
02754      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
02755        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
02756        0,     0,    57,     0,     0,     0,     0,     0,     0,     0,
02757        0,     0,     0,     0,     0,     0,     0,     0,     0,   182,
02758      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
02759      192,   193,     0,     0,     0,     0,     0,     0,   194,   121,
02760      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02761      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
02762      142,   143,   144,     0,     0,     0,   145,   146,   147,   148,
02763      149,   150,   151,   152,   153,   154,     0,     0,     0,     0,
02764        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02765        0,     0,   164,     0,     0,     0,     0,     0,     0,     0,
02766        0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
02767      171,   172,   173,     0,     0,   174,   175,     0,     0,   176,
02768      177,   178,   179,     0,     0,     0,     0,     0,     0,     0,
02769        0,     0,     0,   180,   181,     0,     0,     0,     0,     0,
02770        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02771        0,     0,     0,     0,   182,   183,   184,   185,   186,   187,
02772      188,   189,   190,   191,     0,   192,   193,     5,     6,     7,
02773        0,     9,     0,   194,     0,    10,    11,     0,     0,     0,
02774       12,     0,    13,    14,    15,   241,   242,    18,    19,     0,
02775        0,     0,     0,     0,   243,   244,   245,    23,    24,    25,
02776       26,     0,     0,   203,     0,     0,     0,     0,     0,     0,
02777      271,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02778       39,    40,     0,    41,    42,    43,    44,     0,    45,    46,
02779       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02780        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02781        0,     0,   272,     0,     0,   206,    52,     0,    53,    54,
02782        0,     0,     0,     0,    56,    57,    58,    59,    60,    61,
02783       62,    63,    64,     0,     0,     0,     0,     0,     5,     6,
02784        7,     0,     9,     0,     0,     0,    10,    11,     0,     0,
02785        0,    12,   273,    13,    14,    15,   241,   242,    18,    19,
02786      274,     0,     0,     0,     0,   243,   244,   245,    23,    24,
02787       25,    26,     0,     0,   203,     0,     0,     0,     0,     0,
02788        0,   271,     0,     0,    32,    33,    34,    35,    36,    37,
02789       38,    39,    40,     0,    41,    42,    43,    44,     0,    45,
02790       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02791        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02792        0,     0,     0,   272,     0,     0,   206,    52,     0,    53,
02793       54,     0,     0,     0,     0,    56,    57,    58,    59,    60,
02794       61,    62,    63,    64,     0,     0,     0,     0,     0,     5,
02795        6,     7,     8,     9,     0,     0,     0,    10,    11,     0,
02796        0,     0,    12,   273,    13,    14,    15,    16,    17,    18,
02797       19,   519,     0,     0,     0,     0,    20,    21,    22,    23,
02798       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02799        0,    28,    29,    30,    31,    32,    33,    34,    35,    36,
02800       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02801       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02802        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02803        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02804       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02805       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02806        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02807        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02808       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02809        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02810      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02811       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02812       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02813       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02814        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02815        0,     0,   206,    52,     0,    53,    54,     0,   207,   208,
02816      209,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02817        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02818        6,     7,     8,     9,     0,     0,     0,    10,    11,    65,
02819      210,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02820       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02821       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02822        0,    28,    29,     0,    31,    32,    33,    34,    35,    36,
02823       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02824       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02825        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02826        0,     0,     0,     0,    50,     0,     0,    51,    52,     0,
02827       53,    54,     0,    55,     0,     0,    56,    57,    58,    59,
02828       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02829        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02830        0,     0,    10,    11,    65,    66,    67,    12,     0,    13,
02831       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02832        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02833      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02834       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02835       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02836       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02837        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02838        0,     0,   206,    52,     0,    53,    54,     0,   609,   208,
02839      209,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02840        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02841        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02842      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02843       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02844       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02845        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02846       37,    38,    39,    40,   204,    41,    42,    43,    44,     0,
02847       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02848        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02849        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02850       53,    54,     0,   207,   208,     0,    56,    57,    58,    59,
02851       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02852        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02853        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02854       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02855        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02856      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02857       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02858       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02859       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02860        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02861        0,     0,   206,    52,     0,    53,    54,     0,     0,   208,
02862      209,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02863        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02864        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02865      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02866       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02867       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02868        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02869       37,    38,    39,    40,   204,    41,    42,    43,    44,     0,
02870       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02871        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02872        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02873       53,    54,     0,   609,   208,     0,    56,    57,    58,    59,
02874       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02875        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02876        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02877       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02878        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02879      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02880       32,    33,    34,    35,    36,    37,    38,    39,    40,   204,
02881       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02882       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02883        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02884        0,     0,   206,    52,     0,    53,    54,     0,     0,   208,
02885        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02886        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02887        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02888      210,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02889       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02890       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02891        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02892       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02893       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02894        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02895        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02896       53,    54,     0,   512,     0,     0,    56,    57,    58,    59,
02897       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02898        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02899        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02900       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02901        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02902      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02903       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02904       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02905       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02906        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02907        0,     0,   206,    52,     0,    53,    54,     0,   207,     0,
02908        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02909        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02910        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02911      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02912       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02913       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02914        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02915       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02916       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02917        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02918        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02919       53,    54,     0,   817,     0,     0,    56,    57,    58,    59,
02920       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02921        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02922        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02923       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02924        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02925      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02926       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02927       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02928       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02929        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02930        0,     0,   206,    52,     0,    53,    54,     0,   512,     0,
02931        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02932        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02933        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02934      210,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02935       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02936       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02937        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02938       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02939       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02940        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02941        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02942       53,    54,     0,   609,     0,     0,    56,    57,    58,    59,
02943       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02944        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02945        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02946       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
02947        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
02948      203,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02949       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02950       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02951       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02952        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02953        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
02954        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02955        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02956        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02957      210,    67,    12,     0,    13,    14,    15,    16,    17,    18,
02958       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02959       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02960        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02961       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02962       45,    46,    47,     0,    48,    49,     0,     0,     0,     0,
02963        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02964        0,     0,     0,     0,   205,     0,     0,   206,    52,     0,
02965       53,    54,     0,     0,     0,     0,    56,    57,    58,    59,
02966       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02967        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02968        0,     0,    10,    11,    65,   210,    67,    12,     0,    13,
02969       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02970        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02971       27,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02972       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02973       41,    42,    43,    44,     0,    45,    46,    47,     0,    48,
02974       49,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02975        0,     0,     0,     0,     0,     0,     0,     0,     0,   205,
02976        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
02977        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
02978        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02979        6,     7,     0,     9,     0,     0,     0,    10,    11,    65,
02980       66,    67,    12,     0,    13,    14,    15,   241,   242,    18,
02981       19,     0,     0,     0,     0,     0,   243,   244,   245,    23,
02982       24,    25,    26,     0,     0,   203,     0,     0,     0,     0,
02983        0,     0,   271,     0,     0,    32,    33,    34,    35,    36,
02984       37,    38,    39,    40,     0,    41,    42,    43,    44,     0,
02985       45,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02986        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02987        0,     0,     0,     0,   272,     0,     0,   325,    52,     0,
02988       53,    54,     0,   326,     0,     0,    56,    57,    58,    59,
02989       60,    61,    62,    63,    64,     0,     0,     0,     0,     0,
02990        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02991        0,     0,     0,    12,   273,    13,    14,    15,   241,   242,
02992       18,    19,     0,     0,     0,     0,     0,   243,   244,   245,
02993       23,    24,    25,    26,     0,     0,   203,     0,     0,     0,
02994        0,     0,     0,   271,     0,     0,    32,    33,    34,    35,
02995       36,    37,    38,    39,    40,     0,    41,    42,    43,    44,
02996        0,    45,    46,    47,     0,     0,     0,     0,     0,     0,
02997        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02998        0,     0,     0,     0,     0,   367,     0,     0,    51,    52,
02999        0,    53,    54,     0,    55,     0,     0,    56,    57,    58,
03000       59,    60,    61,    62,    63,    64,     0,     0,     0,     0,
03001        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
03002       11,     0,     0,     0,    12,   273,    13,    14,    15,   241,
03003      242,    18,    19,     0,     0,     0,     0,     0,   243,   244,
03004      245,    23,    24,    25,    26,     0,     0,   203,     0,     0,
03005        0,     0,     0,     0,   271,     0,     0,    32,    33,    34,
03006      375,    36,    37,    38,   376,    40,     0,    41,    42,    43,
03007       44,     0,    45,    46,    47,     0,     0,     0,     0,     0,
03008        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03009        0,     0,     0,   377,     0,     0,   378,     0,     0,   206,
03010       52,     0,    53,    54,     0,     0,     0,     0,    56,    57,
03011       58,    59,    60,    61,    62,    63,    64,     0,     0,     0,
03012        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
03013       10,    11,     0,     0,     0,    12,   273,    13,    14,    15,
03014      241,   242,    18,    19,     0,     0,     0,     0,     0,   243,
03015      244,   245,    23,    24,    25,    26,     0,     0,   203,     0,
03016        0,     0,     0,     0,     0,   271,     0,     0,    32,    33,
03017       34,   375,    36,    37,    38,   376,    40,     0,    41,    42,
03018       43,    44,     0,    45,    46,    47,     0,     0,     0,     0,
03019        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03020        0,     0,     0,     0,     0,     0,     0,   378,     0,     0,
03021      206,    52,     0,    53,    54,     0,     0,     0,     0,    56,
03022       57,    58,    59,    60,    61,    62,    63,    64,     0,     0,
03023        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
03024        0,    10,    11,     0,     0,     0,    12,   273,    13,    14,
03025       15,   241,   242,    18,    19,     0,     0,     0,     0,     0,
03026      243,   244,   245,    23,    24,    25,    26,     0,     0,   203,
03027        0,     0,     0,     0,     0,     0,   271,     0,     0,    32,
03028       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
03029       42,    43,    44,     0,    45,    46,    47,     0,     0,     0,
03030        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03031        0,     0,     0,     0,     0,     0,     0,     0,   272,     0,
03032        0,   325,    52,     0,    53,    54,     0,     0,     0,     0,
03033       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
03034        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
03035        0,     0,    10,    11,     0,     0,     0,    12,   273,    13,
03036       14,    15,   241,   242,    18,    19,     0,     0,     0,     0,
03037        0,   243,   244,   245,    23,    24,    25,    26,     0,     0,
03038      203,     0,     0,     0,     0,     0,     0,   271,     0,     0,
03039       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
03040       41,    42,    43,    44,     0,    45,    46,    47,     0,     0,
03041        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03042        0,     0,     0,     0,     0,     0,     0,     0,     0,   897,
03043        0,     0,   206,    52,     0,    53,    54,     0,     0,     0,
03044        0,    56,    57,    58,    59,    60,    61,    62,    63,    64,
03045        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
03046        0,     0,     0,    10,    11,     0,     0,     0,    12,   273,
03047       13,    14,    15,   241,   242,    18,    19,     0,     0,     0,
03048        0,     0,   243,   244,   245,    23,    24,    25,    26,     0,
03049        0,   203,     0,     0,     0,     0,     0,     0,   271,     0,
03050        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
03051        0,    41,    42,    43,    44,     0,    45,    46,    47,     0,
03052        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03053        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03054      975,     0,     0,   206,    52,     0,    53,    54,     0,     0,
03055        0,     0,    56,    57,    58,    59,    60,    61,    62,    63,
03056       64,     0,     0,     0,     0,   554,   555,     0,     0,   556,
03057        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03058      273,   165,   166,   167,   168,   169,   170,   171,   172,   173,
03059        0,     0,   174,   175,     0,     0,   176,   177,   178,   179,
03060        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03061      180,   181,     0,     0,     0,     0,     0,     0,     0,     0,
03062        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03063        0,   182,   183,   184,   185,   186,   187,   188,   189,   190,
03064      191,     0,   192,   193,   562,   563,     0,     0,   564,     0,
03065      194,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03066      165,   166,   167,   168,   169,   170,   171,   172,   173,     0,
03067        0,   174,   175,     0,     0,   176,   177,   178,   179,     0,
03068        0,     0,     0,     0,     0,     0,     0,     0,     0,   180,
03069      181,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03070        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03071      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
03072        0,   192,   193,   599,   563,     0,     0,   600,     0,   194,
03073        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
03074      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
03075      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
03076        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
03077        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03078        0,     0,     0,     0,     0,     0,     0,     0,     0,   182,
03079      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
03080      192,   193,   613,   555,     0,     0,   614,     0,   194,     0,
03081        0,     0,     0,     0,     0,     0,     0,     0,   165,   166,
03082      167,   168,   169,   170,   171,   172,   173,     0,     0,   174,
03083      175,     0,     0,   176,   177,   178,   179,     0,     0,     0,
03084        0,     0,     0,     0,     0,     0,     0,   180,   181,     0,
03085        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03086        0,     0,     0,     0,     0,     0,     0,     0,   182,   183,
03087      184,   185,   186,   187,   188,   189,   190,   191,     0,   192,
03088      193,   616,   563,     0,     0,   617,     0,   194,     0,     0,
03089        0,     0,     0,     0,     0,     0,     0,   165,   166,   167,
03090      168,   169,   170,   171,   172,   173,     0,     0,   174,   175,
03091        0,     0,   176,   177,   178,   179,     0,     0,     0,     0,
03092        0,     0,     0,     0,     0,     0,   180,   181,     0,     0,
03093        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03094        0,     0,     0,     0,     0,     0,     0,   182,   183,   184,
03095      185,   186,   187,   188,   189,   190,   191,     0,   192,   193,
03096      640,   555,     0,     0,   641,     0,   194,     0,     0,     0,
03097        0,     0,     0,     0,     0,     0,   165,   166,   167,   168,
03098      169,   170,   171,   172,   173,     0,     0,   174,   175,     0,
03099        0,   176,   177,   178,   179,     0,     0,     0,     0,     0,
03100        0,     0,     0,     0,     0,   180,   181,     0,     0,     0,
03101        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03102        0,     0,     0,     0,     0,     0,   182,   183,   184,   185,
03103      186,   187,   188,   189,   190,   191,     0,   192,   193,   643,
03104      563,     0,     0,   644,     0,   194,     0,     0,     0,     0,
03105        0,     0,     0,     0,     0,   165,   166,   167,   168,   169,
03106      170,   171,   172,   173,     0,     0,   174,   175,     0,     0,
03107      176,   177,   178,   179,     0,     0,     0,     0,     0,     0,
03108        0,     0,     0,     0,   180,   181,     0,     0,     0,     0,
03109        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03110        0,     0,     0,     0,     0,   182,   183,   184,   185,   186,
03111      187,   188,   189,   190,   191,     0,   192,   193,   728,   555,
03112        0,     0,   729,     0,   194,     0,     0,     0,     0,     0,
03113        0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
03114      171,   172,   173,     0,     0,   174,   175,     0,     0,   176,
03115      177,   178,   179,     0,     0,     0,     0,     0,     0,     0,
03116        0,     0,     0,   180,   181,     0,     0,     0,     0,     0,
03117        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03118        0,     0,     0,     0,   182,   183,   184,   185,   186,   187,
03119      188,   189,   190,   191,     0,   192,   193,   731,   563,     0,
03120        0,   732,     0,   194,     0,     0,     0,     0,     0,     0,
03121        0,     0,     0,   165,   166,   167,   168,   169,   170,   171,
03122      172,   173,     0,     0,   174,   175,     0,     0,   176,   177,
03123      178,   179,     0,     0,     0,     0,     0,     0,     0,     0,
03124        0,     0,   180,   181,     0,     0,     0,     0,     0,     0,
03125        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03126        0,     0,     0,   182,   183,   184,   185,   186,   187,   188,
03127      189,   190,   191,     0,   192,   193,   738,   555,     0,     0,
03128      739,     0,   194,     0,     0,     0,     0,     0,     0,     0,
03129        0,     0,   165,   166,   167,   168,   169,   170,   171,   172,
03130      173,     0,     0,   174,   175,     0,     0,   176,   177,   178,
03131      179,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03132        0,   180,   181,     0,     0,     0,     0,     0,     0,     0,
03133        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03134        0,     0,   182,   183,   184,   185,   186,   187,   188,   189,
03135      190,   191,     0,   192,   193,  1007,   555,     0,     0,  1008,
03136        0,   194,     0,     0,     0,     0,     0,     0,     0,     0,
03137        0,   165,   166,   167,   168,   169,   170,   171,   172,   173,
03138        0,     0,   174,   175,     0,     0,   176,   177,   178,   179,
03139        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03140      180,   181,     0,     0,     0,     0,     0,     0,     0,     0,
03141        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03142        0,   182,   183,   184,   185,   186,   187,   188,   189,   190,
03143      191,     0,   192,   193,  1040,   555,     0,     0,  1041,     0,
03144      194,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03145      165,   166,   167,   168,   169,   170,   171,   172,   173,     0,
03146        0,   174,   175,     0,     0,   176,   177,   178,   179,     0,
03147        0,     0,     0,     0,     0,     0,     0,     0,     0,   180,
03148      181,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03149        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03150      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
03151        0,   192,   193,  1043,   563,     0,     0,  1044,     0,   194,
03152        0,     0,     0,     0,     0,     0,     0,     0,     0,   165,
03153      166,   167,   168,   169,   170,   171,   172,   173,     0,     0,
03154      174,   175,     0,     0,   176,   177,   178,   179,     0,     0,
03155        0,     0,     0,     0,     0,     0,     0,     0,   180,   181,
03156      329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
03157      339,   340,   341,     0,     0,   342,   343,     0,     0,   182,
03158      183,   184,   185,   186,   187,   188,   189,   190,   191,     0,
03159      192,   193,     0,     0,     0,     0,     0,     0,   194,     0,
03160        0,     0,     0,     0,     0,     0,   344,     0,   345,   346,
03161      347,   348,   349,   350,   351,   352,   353,   354,     0,     0,
03162        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03163        0,     0,     0,   234
03164 };
03165 
03166 #define yypact_value_is_default(yystate) \
03167   ((yystate) == (-813))
03168 
03169 #define yytable_value_is_error(yytable_value) \
03170   ((yytable_value) == (-628))
03171 
03172 static const yytype_int16 yycheck[] =
03173 {
03174        2,    27,    98,    29,    57,    81,    16,    17,     8,    76,
03175       20,     8,    16,    17,     8,   328,    20,   361,    89,    22,
03176      576,    92,    51,    28,   414,    88,    89,   328,    28,    92,
03177      422,    28,   422,     4,    28,    54,   355,   578,   357,   356,
03178       55,    69,   223,    96,   670,     2,    92,     4,   575,    53,
03179      615,    53,    54,   378,    65,   595,    69,     2,   265,     4,
03180       57,   778,   269,    55,    92,   233,    81,    51,   460,   473,
03181      686,    16,    17,    76,   469,    20,   787,   642,    93,    94,
03182       95,   442,   401,   508,    13,   716,   511,    66,   872,   720,
03183      258,    25,    27,   261,   906,   253,    63,    78,   417,    96,
03184      419,   418,    29,    89,   874,    25,    51,    63,   143,    87,
03185       55,     0,   775,    87,    16,    17,    89,   138,    20,    25,
03186      132,    66,   143,    26,   519,    13,   445,    87,    56,   115,
03187       37,    38,    28,    25,    16,    17,    81,   800,    20,   120,
03188       13,    99,   115,    88,    89,   112,    25,    92,    93,    94,
03189       95,    53,    54,   472,   471,   939,   112,   135,   102,    13,
03190       25,   135,   778,   136,   122,   730,    25,   325,    26,   139,
03191      233,   787,   235,   143,   134,   135,   741,   206,   895,   246,
03192      806,   807,    13,   142,   725,   204,   113,    25,   207,   208,
03193      209,    52,   289,    13,   291,    56,   293,   737,   274,   262,
03194      297,   742,   136,  1015,   138,   745,   141,   136,   143,   255,
03195      994,   240,   141,     1,   143,   217,   136,   227,   138,   229,
03196      230,   223,   992,   227,   253,   229,   142,   255,   230,   132,
03197      136,   623,   622,   623,   951,   946,   143,   142,   309,   310,
03198      311,   312,   255,  1027,   136,   271,   309,   310,   311,   312,
03199      431,   314,   315,   141,   658,   143,   424,   136,   884,   274,
03200      428,   206,   273,   582,   581,   433,   691,   592,   141,   253,
03201      143,   136,   633,   902,   132,   594,   593,   136,   142,   895,
03202      138,   449,   227,   115,   229,   230,   902,   141,   233,   143,
03203      235,   362,   363,  1010,   251,   240,   325,   928,   136,   362,
03204      363,    25,   697,   844,   323,   846,   251,   138,   253,   328,
03205      141,   326,   143,    25,   377,   856,   115,   262,   364,   323,
03206      861,   141,    89,   143,   328,   227,   853,   229,   136,   274,
03207      946,   119,    89,    89,   326,   658,   364,   308,    26,   965,
03208      744,   325,   746,   136,   323,   227,   356,   229,   115,   328,
03209      518,   308,   380,   141,   356,   143,   313,   138,    87,   115,
03210      357,    37,    38,   308,   309,   310,   311,   312,   313,   314,
03211      315,   141,   928,   143,  1003,    89,    25,   115,   323,    87,
03212      325,   326,   726,   328,   925,   926,    56,  1003,    87,   486,
03213      930,   115,    26,   469,   413,   414,   493,   698,   136,    87,
03214      115,   115,   715,   422,   401,   134,   135,    70,   418,    63,
03215       63,   356,   136,   358,   136,   139,   418,   362,   363,   143,
03216      136,   744,   419,   746,   136,   404,   405,   135,   430,   431,
03217      637,   612,   377,    90,   439,   134,   135,    89,   457,   439,
03218      442,   460,   439,   519,   132,   439,   134,   135,   445,   990,
03219      138,   991,   138,    87,   469,   109,   109,   111,   111,   404,
03220      405,   471,   125,   126,   127,   136,   115,   136,   636,   471,
03221       89,    87,   143,   418,   143,   472,   868,  1042,   868,    63,
03222      138,    87,  1023,    67,  1025,   442,   132,   136,   142,   142,
03223      139,   558,    70,   512,   143,    70,   115,   442,   132,   566,
03224      134,   135,   138,   136,   519,   507,   508,   452,   139,   511,
03225      143,    52,   414,    54,    55,    56,    57,   543,   672,   135,
03226      674,    26,    87,   115,   469,   109,   471,   111,   134,   135,
03227      704,    26,   138,   596,   601,   561,    52,   711,    54,    55,
03228       56,    57,   571,   140,   573,    87,   574,   575,   123,   124,
03229      125,   126,   127,   133,    87,   457,   559,    15,   577,    17,
03230      588,    89,   638,   626,   567,    63,    56,   569,   136,   134,
03231      135,   581,   916,   577,   519,   743,    63,   112,   922,   581,
03232      761,   112,    87,   593,    70,   582,    63,   115,   112,   615,
03233      609,   593,    87,   135,   762,   136,   473,   594,   601,   601,
03234      112,   606,   135,   622,   623,   773,   606,    87,   136,   606,
03235      612,   109,   606,   111,   112,    89,   642,   686,    96,    87,
03236      136,   697,   109,   638,   111,   112,   571,   132,   573,   134,
03237      135,   633,   109,   138,   111,   112,   581,   132,   705,   134,
03238      135,   115,   686,   138,    58,   712,    89,   666,   593,    87,
03239      595,   596,    87,   749,   134,   135,    70,    87,   687,    17,
03240      686,   690,   733,   692,   136,   736,   668,   135,   670,    87,
03241      733,   141,   115,   736,    56,   694,   633,    87,    14,    15,
03242       25,   626,   697,   139,    98,    99,   136,   136,   633,   691,
03243      132,    87,   860,   638,   747,   136,   715,   135,   142,   134,
03244      135,  1020,  1019,   871,   730,   135,   734,    87,   122,   133,
03245      712,   715,   781,   715,   716,   741,   718,   135,   720,   698,
03246      622,    63,   701,   702,   134,   135,   142,   881,   882,   708,
03247      709,    87,   886,   136,   888,    87,   890,   781,   134,   135,
03248       89,   785,   687,   136,   136,   690,   136,   692,    63,   775,
03249      747,   115,   697,   698,   134,   135,   701,   702,   777,   761,
03250       87,   138,   686,   708,   709,    10,   115,   109,    87,   111,
03251      112,     8,   843,   686,   800,   652,    89,    89,   134,   135,
03252      843,   658,   134,   135,    13,   138,   815,   136,   733,   804,
03253      133,   736,   737,   115,   109,    89,   111,   112,   817,     2,
03254      745,     4,   115,   115,   806,   807,    89,   134,   135,   686,
03255      136,   840,   136,    16,    17,   134,   135,    20,   847,   848,
03256       52,   115,   851,   136,   136,   853,   895,   855,   136,    54,
03257      899,   850,   115,   902,   862,   904,   838,   136,    52,   841,
03258       65,    66,   136,   136,   998,   999,  1000,  1001,    51,   868,
03259      829,   895,    52,   136,   136,   899,   117,    15,   902,   804,
03260      904,   140,   891,    66,   136,    70,   133,   744,   136,   746,
03261      815,   120,   115,   136,   787,   141,   136,   790,   136,   894,
03262       85,    86,   884,   136,   829,    88,    89,    10,    10,    92,
03263      919,   133,   769,   770,    90,   840,  1050,   136,   843,     9,
03264      915,   778,   847,   848,   139,   136,   851,   120,   136,   136,
03265      787,    56,   136,   136,   943,   944,   133,   122,   123,   124,
03266      125,   126,   127,   110,   136,    52,   928,    54,    55,    56,
03267       57,    56,   136,    10,  1003,   136,  1005,   136,   136,    54,
03268       55,  1010,    57,  1012,   136,   971,   891,   136,   133,   894,
03269       65,    66,   981,   136,   983,   136,   138,    70,   138,  1003,
03270      989,  1005,    93,   965,    91,    95,  1010,   452,  1012,   712,
03271      915,   895,    85,    86,   919,   899,   686,  1022,   902,   769,
03272      904,   809,   810,  1052,  1015,   930,   750,  1021,   297,   902,
03273      101,   904,    59,    96,   936,   872,   781,   874,   943,   944,
03274      899,   895,    52,   206,    54,    55,    56,    57,  1052,  1019,
03275      123,   124,   125,   126,   127,   778,  1042,  1019,   895,  1021,
03276     1022,    -1,   398,  1020,   227,   902,   229,   230,    -1,    -1,
03277      233,    -1,   235,   946,    -1,   948,   981,   240,   983,    -1,
03278      953,    91,    -1,    -1,   989,    -1,   991,    97,   251,    -1,
03279      253,    -1,    52,    -1,    54,    55,    56,    57,    -1,   262,
03280       -1,    -1,   939,   940,    59,    60,    61,    62,    52,   946,
03281       54,    55,    56,    57,  1019,    -1,    -1,    -1,    -1,  1003,
03282       -1,  1005,    -1,    -1,    -1,    -1,  1010,    -1,  1012,    -1,
03283     1003,    91,  1005,    -1,    -1,    -1,    -1,    97,    -1,  1012,
03284       40,    41,    42,    43,    44,   308,   309,   310,   311,   312,
03285      313,   314,   315,    -1,    -1,   992,    -1,   994,  1031,    -1,
03286      323,    -1,   325,    -1,    -1,   328,  1003,    -1,  1052,    -1,
03287       -1,    -1,   960,   961,    -1,    -1,    -1,    -1,   966,  1052,
03288      968,   969,    -1,    16,    17,    -1,    -1,    20,    -1,    -1,
03289     1027,    -1,    -1,   356,    -1,   358,    -1,    -1,    -1,   362,
03290      363,    -1,    -1,    -1,    -1,    -1,    -1,    52,    -1,    54,
03291       55,    56,    57,    58,   377,    48,    49,    -1,    -1,    -1,
03292       53,    54,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,
03293       -1,    -1,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03294       -1,   404,   405,    -1,    -1,    -1,    91,  1035,  1036,  1037,
03295     1038,    -1,    97,    98,    99,   418,    52,    -1,    54,    55,
03296       56,    57,    58,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03297     1058,    -1,    -1,    -1,    70,    -1,    -1,   122,    -1,   442,
03298      125,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   452,
03299       -1,    -1,    -1,    -1,    -1,    91,     0,    -1,   143,    -1,
03300       -1,    97,    98,    99,     8,     9,    10,    -1,   471,    13,
03301       14,    15,    52,    17,    54,    55,    56,    57,    58,    -1,
03302       -1,    -1,    26,    27,    -1,    -1,   122,    -1,    -1,   125,
03303       70,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03304       44,    -1,   138,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03305       -1,    91,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,
03306       -1,    -1,    -1,     2,    -1,     4,    -1,    -1,    -1,    -1,
03307       -1,   204,    -1,    -1,   207,   208,   209,   210,    -1,    -1,
03308       -1,    -1,   122,    87,    -1,   125,    -1,    -1,    -1,    -1,
03309       -1,    -1,    -1,    -1,   227,    -1,   229,   230,    -1,    52,
03310       -1,    54,    55,    56,    57,    58,   110,    -1,   571,    -1,
03311      573,    -1,    51,    -1,    -1,    -1,    55,    70,   581,    -1,
03312       -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,   132,   133,
03313      593,   135,   595,   596,   138,   139,    -1,   141,    91,   143,
03314       85,    86,    81,    -1,    -1,    98,    99,    -1,    -1,    -1,
03315       -1,    -1,    -1,    -1,    93,    94,    95,    96,    -1,    -1,
03316       -1,    -1,    -1,   626,    -1,    -1,    -1,    -1,    -1,   122,
03317      633,    -1,    -1,    -1,    -1,   120,   121,   122,   123,   124,
03318      125,   126,   127,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03319      323,    -1,    -1,    -1,    -1,   328,   329,   330,   331,   332,
03320      333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
03321      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
03322      353,   354,    -1,   356,   687,    -1,    -1,   690,    -1,   692,
03323       -1,    -1,    -1,    -1,    -1,   698,    -1,    -1,   701,   702,
03324       -1,    -1,    -1,    -1,    -1,   708,   709,    -1,    -1,    -1,
03325       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03326       -1,    -1,    -1,    -1,    -1,    -1,     2,   206,     4,    -1,
03327      733,   404,   405,   736,   737,    -1,    -1,    -1,    -1,   412,
03328      413,   414,   745,    -1,    -1,   418,    -1,   420,   421,   422,
03329       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03330       -1,   240,    -1,    -1,    -1,    -1,    -1,    -1,   441,    -1,
03331       -1,    -1,   251,   446,   253,    51,    -1,    -1,    -1,    55,
03332       -1,    -1,    -1,    -1,   457,    -1,    -1,   460,    -1,    -1,
03333       -1,    -1,    -1,    -1,    -1,   274,    -1,    -1,   471,    -1,
03334       -1,    -1,    -1,    -1,    -1,    81,     2,    -1,     4,    -1,
03335       -1,    -1,   815,    -1,    -1,    -1,    -1,    93,    94,    95,
03336       96,    -1,    -1,    -1,   497,    -1,   829,    -1,    -1,   308,
03337       -1,    -1,    -1,    -1,   313,    -1,    -1,   840,    -1,   512,
03338      843,    -1,    -1,    -1,   847,   848,   325,   326,   851,    -1,
03339       -1,    -1,    -1,    -1,    -1,    51,    -1,    -1,    -1,    55,
03340       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03341       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,
03342       -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,   891,    -1,
03343       -1,    -1,    -1,    -1,    -1,    -1,    -1,    93,    94,    95,
03344       -1,    -1,    -1,    -1,   577,    -1,    -1,    -1,   581,    -1,
03345       -1,    -1,    -1,    -1,    -1,    -1,   919,    -1,    -1,    -1,
03346      593,    -1,    -1,    -1,    -1,    -1,    -1,   930,    -1,    -1,
03347      206,    -1,    -1,    -1,    -1,    -1,   609,    -1,    -1,    -1,
03348      943,   944,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   622,
03349      623,    70,    71,    72,    73,    74,    75,    76,    77,    -1,
03350       79,    80,    -1,   442,   240,    -1,    85,    86,    -1,    -1,
03351       -1,    -1,    -1,   452,    -1,   251,    -1,   253,   981,    -1,
03352      983,    -1,    -1,    -1,    -1,     2,   989,     4,   991,    -1,
03353      469,    -1,    -1,   666,    -1,    -1,    -1,    -1,   274,   118,
03354      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03355      206,    -1,    -1,    -1,    -1,    -1,  1019,    -1,    -1,    -1,
03356       -1,   694,    -1,    -1,    -1,   698,   699,    -1,   701,   702,
03357       -1,    -1,   308,    -1,    51,   708,   709,   313,    -1,    -1,
03358      519,    -1,   715,    -1,   240,    -1,    -1,    -1,    -1,   325,
03359      326,    -1,    -1,    -1,    -1,   251,    -1,   253,    -1,    -1,
03360       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03361       -1,    -1,    -1,    -1,    -1,    -1,    93,    -1,   274,   752,
03362       -1,    -1,   358,   756,   757,    -1,   759,   760,    -1,    -1,
03363       -1,    -1,   571,    -1,   573,    -1,    -1,    -1,    -1,    -1,
03364       -1,    -1,    -1,    -1,   777,    -1,    -1,    -1,    -1,    -1,
03365       -1,    -1,   308,    -1,    -1,    -1,   595,   313,    -1,    -1,
03366       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   325,
03367      326,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03368       -1,    -1,    -1,    -1,   817,    -1,    -1,     2,   821,     4,
03369       -1,    -1,    -1,    -1,   633,    -1,   829,    -1,    -1,   638,
03370       -1,    -1,   358,    -1,    -1,    -1,   442,    -1,    -1,    -1,
03371       -1,    -1,    -1,    -1,    -1,    -1,   452,   850,    -1,    -1,
03372       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   206,
03373       -1,    -1,    -1,   469,   867,   868,    51,    -1,    -1,    -1,
03374       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   687,    -1,
03375       -1,   690,    -1,   692,    -1,    -1,    -1,    -1,   697,    -1,
03376       -1,    -1,    -1,   240,    -1,    -1,    -1,    -1,    -1,    -1,
03377       -1,    -1,    -1,    -1,   251,    -1,   253,    -1,    -1,    -1,
03378       -1,    -1,    -1,   519,    -1,    -1,   442,    -1,    -1,    -1,
03379       -1,    -1,    44,    -1,    -1,    -1,   452,    -1,   737,    -1,
03380       -1,    -1,    -1,    -1,    -1,    -1,   745,    -1,    -1,    -1,
03381       -1,    -1,    -1,   469,    -1,    -1,    -1,    -1,    70,    71,
03382       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03383       82,   308,    -1,    85,    86,   571,   313,   573,    -1,    -1,
03384       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   325,    -1,
03385       -1,   328,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   595,
03386       -1,    -1,    -1,   519,   116,   804,   118,   119,   120,   121,
03387      122,   123,   124,   125,   126,   127,   815,    -1,    -1,    -1,
03388       -1,   358,    -1,    -1,   136,    -1,  1019,    -1,    -1,    -1,
03389       -1,   206,    -1,    -1,    -1,    -1,    -1,   633,    -1,    -1,
03390       -1,   840,   638,    -1,    -1,    -1,    -1,    -1,   847,   848,
03391       -1,    -1,   851,    -1,    -1,   571,    -1,   573,    -1,    -1,
03392       -1,    -1,    -1,    -1,    -1,   240,    -1,    -1,    -1,    -1,
03393       -1,    -1,    -1,    -1,    -1,    -1,   251,    -1,   253,   595,
03394       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03395       -1,   687,   891,    -1,   690,   894,   692,    -1,    -1,    -1,
03396       -1,   697,    -1,    -1,    -1,   442,    -1,    -1,    -1,    -1,
03397       -1,    -1,    -1,    -1,    -1,   452,   915,   633,    -1,    -1,
03398      919,    -1,   638,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03399       -1,   930,    -1,   308,    -1,    -1,    -1,    -1,   313,    -1,
03400       -1,   737,    -1,    -1,   943,   944,    -1,    -1,    -1,   745,
03401      325,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03402       -1,    -1,   678,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03403       -1,   687,    -1,    -1,   690,    -1,   692,    -1,    -1,    -1,
03404       -1,   697,   981,   358,   983,    -1,    -1,    -1,    -1,    -1,
03405      989,    -1,   991,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03406       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   804,    -1,
03407       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   815,
03408       -1,   737,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   745,
03409       -1,    -1,    -1,    -1,   571,    -1,   573,    -1,    -1,    -1,
03410       -1,    -1,    -1,    -1,   840,    -1,    -1,    -1,    -1,    -1,
03411       -1,   847,   848,    -1,    -1,   851,    -1,    -1,   595,    70,
03412       71,    72,    73,    74,    75,    76,    -1,   442,    79,    80,
03413       -1,    -1,    -1,    -1,    85,    86,    -1,   452,    -1,    -1,
03414       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   804,    -1,
03415       -1,    -1,    -1,    -1,    -1,   891,   633,    -1,   894,   815,
03416       -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,
03417      121,   122,   123,   124,   125,   126,   127,    -1,    -1,   915,
03418       -1,    -1,    -1,   919,   840,    -1,    -1,    -1,    -1,    -1,
03419       -1,   847,   848,    -1,   930,   851,    -1,    -1,    -1,    -1,
03420       -1,    -1,    -1,    -1,    -1,    -1,    -1,   943,   944,    -1,
03421      687,    -1,    -1,   690,    -1,   692,    -1,    -1,    -1,    -1,
03422       -1,   698,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03423       -1,    -1,    -1,    -1,    -1,   891,    -1,    -1,   894,    -1,
03424       -1,    -1,    -1,    -1,    -1,   981,    -1,   983,    -1,    -1,
03425       -1,    -1,    -1,   989,    -1,   991,   571,    -1,   573,   915,
03426      737,    -1,    -1,   919,    -1,    -1,    -1,    -1,   745,     0,
03427       -1,    -1,    -1,    -1,   930,    -1,    -1,     8,     9,    10,
03428      595,    -1,    13,    14,    15,    -1,    17,   943,   944,    -1,
03429       -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,    -1,
03430       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03431       41,    42,    43,    44,    -1,    -1,    -1,    -1,   633,    -1,
03432       -1,    -1,    -1,    -1,    -1,   981,    -1,   983,    -1,    -1,
03433       -1,    -1,    -1,   989,    -1,   991,    -1,    -1,   815,    70,
03434       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03435       81,    82,    -1,    -1,    85,    86,    87,    -1,    89,    90,
03436       -1,    -1,    -1,   840,    -1,    96,    -1,    -1,    -1,    -1,
03437      847,   848,   687,    -1,   851,   690,    -1,   692,    -1,   110,
03438       -1,    -1,   113,    -1,   115,   116,   117,   118,   119,   120,
03439      121,   122,   123,   124,   125,   126,   127,    -1,    -1,    -1,
03440       -1,   132,   133,   134,   135,   136,    -1,    -1,   139,   140,
03441      141,    -1,   143,    -1,   891,    -1,    -1,    -1,    -1,    -1,
03442       -1,    -1,   737,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03443      745,    70,    71,    72,    73,    74,    75,    76,   915,    -1,
03444       79,    80,   919,    -1,    -1,    -1,    85,    86,    -1,    -1,
03445       -1,    -1,    -1,   930,    -1,    -1,    -1,    -1,    -1,    -1,
03446       -1,    -1,    -1,    -1,    -1,    -1,   943,   944,    -1,    -1,
03447       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
03448      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03449       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03450      815,    -1,    -1,    -1,   981,    -1,   983,    -1,    -1,    -1,
03451       -1,    -1,   989,    -1,   991,    -1,    -1,    -1,    -1,    -1,
03452       -1,    -1,    -1,    -1,    -1,   840,    -1,    -1,    -1,    -1,
03453       -1,    -1,   847,   848,    -1,    -1,   851,    -1,    -1,    -1,
03454       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03455       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03456       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03457       -1,    -1,    -1,    -1,    -1,    -1,   891,    -1,    -1,    -1,
03458       -1,    -1,    -1,    -1,    -1,    -1,    -1,     0,     1,    -1,
03459        3,     4,     5,     6,     7,    -1,    -1,    -1,    11,    12,
03460       -1,    -1,    -1,    16,   919,    18,    19,    20,    21,    22,
03461       23,    24,    -1,    -1,    -1,   930,    -1,    30,    31,    32,
03462       33,    34,    35,    36,    -1,    -1,    39,    -1,   943,   944,
03463       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03464       53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
03465       -1,    64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,
03466       -1,    -1,    -1,    -1,    -1,    -1,   981,    -1,   983,    -1,
03467       -1,    -1,    -1,    -1,   989,    88,   991,    -1,    91,    92,
03468       -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,   102,
03469      103,   104,   105,   106,   107,   108,     0,    -1,    -1,    -1,
03470       -1,    -1,    -1,    -1,     8,     9,    10,    -1,    -1,    13,
03471       14,    15,    -1,    17,    -1,   128,   129,   130,    -1,    44,
03472       -1,    25,    -1,    27,    28,    29,    -1,    -1,   141,    -1,
03473      143,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03474       44,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
03475       75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
03476       85,    86,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
03477       74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
03478       -1,    85,    86,    87,    -1,    89,    90,    -1,    -1,    -1,
03479       -1,   116,    96,   118,   119,   120,   121,   122,   123,   124,
03480      125,   126,   127,    -1,    -1,    -1,   110,    -1,    -1,   113,
03481       -1,   115,   116,   117,   118,   119,   120,   121,   122,   123,
03482      124,   125,   126,   127,    -1,    -1,    -1,    -1,    -1,   133,
03483      134,   135,   136,     0,    -1,   139,   140,   141,    -1,   143,
03484       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03485       17,    -1,    -1,    -1,    -1,    -1,    44,    -1,    25,    -1,
03486       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03487       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03488       -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
03489       78,    79,    80,    81,    82,    -1,    -1,    85,    86,    -1,
03490       -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
03491       77,    78,    79,    80,    81,    82,    -1,    -1,    85,    86,
03492       87,    -1,    89,    90,    -1,    -1,    -1,    -1,   116,    96,
03493      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
03494       -1,    -1,    -1,   110,    -1,    -1,   113,    -1,   115,   116,
03495      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
03496      127,    -1,    -1,    -1,    -1,    -1,   133,   134,   135,   136,
03497        0,    -1,   139,   140,   141,    -1,   143,    -1,     8,     9,
03498       10,    -1,    -1,    13,    14,    15,    -1,    17,    -1,    -1,
03499       -1,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,
03500       -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,
03501       40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,    70,
03502       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03503       81,    82,    -1,    -1,    85,    86,    -1,    -1,    -1,    -1,
03504       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03505       80,    81,    82,    -1,    -1,    85,    86,    87,    -1,    -1,
03506       90,    -1,    -1,    -1,    -1,   116,    96,   118,   119,   120,
03507      121,   122,   123,   124,   125,   126,   127,    -1,    -1,    -1,
03508      110,    -1,    -1,   113,    -1,    -1,   116,   117,   118,   119,
03509      120,   121,   122,   123,   124,   125,   126,   127,    -1,    -1,
03510       -1,    -1,   132,   133,   134,   135,   136,     0,    -1,   139,
03511      140,   141,    -1,   143,    -1,     8,     9,    10,    -1,    -1,
03512       13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,
03513       -1,    -1,    -1,    26,    27,    28,    29,    -1,    -1,    -1,
03514       -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,
03515       43,    44,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
03516       74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
03517       -1,    85,    86,    -1,    -1,    -1,    -1,    70,    71,    72,
03518       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
03519       -1,    -1,    85,    86,    87,    -1,    -1,    90,    -1,    -1,
03520       -1,    -1,    -1,    96,   118,   119,   120,   121,   122,   123,
03521      124,   125,   126,   127,    -1,    -1,    -1,   110,    -1,    -1,
03522      113,    -1,    -1,   116,   117,   118,   119,   120,   121,   122,
03523      123,   124,   125,   126,   127,    -1,    -1,    -1,    -1,   132,
03524      133,   134,   135,   136,     0,    -1,   139,   140,   141,    -1,
03525      143,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03526       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03527       -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,
03528       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03529       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03530       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03531       -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
03532       76,    77,    78,    79,    80,    81,    82,    -1,    -1,    85,
03533       86,    87,    -1,    89,    90,    -1,    -1,    -1,    -1,    -1,
03534       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03535       -1,    -1,    -1,    -1,   110,    -1,    -1,   113,    -1,   115,
03536      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03537      126,   127,    -1,    -1,    -1,    -1,    -1,   133,   134,   135,
03538      136,     0,    -1,   139,   140,   141,    -1,   143,    -1,     8,
03539        9,    10,    -1,    -1,    13,    14,    15,    -1,    17,    -1,
03540       -1,    -1,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,
03541       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,
03542       -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
03543       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03544       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03545       -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
03546       79,    80,    81,    82,    -1,    -1,    85,    86,    87,    -1,
03547       -1,    90,    -1,    -1,    -1,    -1,    -1,    96,    -1,    -1,
03548       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03549       -1,   110,    -1,    -1,    -1,    -1,    -1,   116,    -1,   118,
03550      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03551       -1,    -1,    -1,   132,   133,   134,   135,   136,     0,   138,
03552      139,   140,   141,    -1,   143,    -1,     8,     9,    10,    -1,
03553       -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03554       -1,    -1,    -1,    -1,    -1,    27,    28,    29,    -1,    -1,
03555       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03556       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03557       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03558       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,
03559       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03560       82,    -1,    -1,    85,    86,    87,    -1,    -1,    90,    -1,
03561       -1,    -1,    -1,    -1,    96,    -1,    -1,    -1,    -1,    -1,
03562       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,
03563       -1,   113,    -1,    -1,   116,   117,   118,   119,   120,   121,
03564      122,   123,   124,   125,   126,   127,    -1,    -1,    -1,    -1,
03565       -1,   133,   134,   135,   136,     0,    -1,   139,   140,   141,
03566       -1,   143,    -1,     8,     9,    10,    -1,    -1,    13,    14,
03567       15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03568       -1,    26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
03569       -1,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03570       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03571       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03572       -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
03573       75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
03574       85,    86,    87,    -1,    -1,    90,    -1,    -1,    -1,    -1,
03575       -1,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03576       -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,    -1,    -1,
03577       -1,   116,    -1,   118,   119,   120,   121,   122,   123,   124,
03578      125,   126,   127,    -1,    -1,    -1,    -1,   132,   133,   134,
03579      135,   136,     0,   138,   139,   140,   141,    -1,   143,    -1,
03580        8,     9,    10,    -1,    -1,    13,    14,    15,    -1,    17,
03581       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    27,
03582       28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,
03583       38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
03584       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03585       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03586       -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
03587       78,    79,    80,    81,    82,    -1,    -1,    85,    86,    87,
03588       -1,    -1,    90,    -1,    -1,    -1,    -1,    -1,    96,    -1,
03589       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03590       -1,    -1,   110,    -1,    -1,    -1,    -1,    -1,   116,    -1,
03591      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
03592       -1,    -1,    -1,    -1,    -1,   133,   134,   135,   136,     0,
03593      138,   139,   140,   141,    -1,   143,    -1,     8,     9,    10,
03594       -1,    -1,    -1,    14,    15,    -1,    17,    -1,    -1,    -1,
03595       -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,
03596       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
03597       41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
03598       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03599       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
03600       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03601       81,    82,    -1,    -1,    85,    86,    87,    -1,    89,    -1,
03602       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03603       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
03604       -1,    -1,    -1,    -1,   115,   116,    -1,   118,   119,   120,
03605      121,   122,   123,   124,   125,   126,   127,    -1,    -1,    -1,
03606       -1,   132,   133,   134,   135,   136,     0,    -1,   139,    -1,
03607      141,    -1,   143,    -1,     8,     9,    10,    -1,    -1,    -1,
03608       14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,
03609       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03610       -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03611       44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03612       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03613       -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
03614       74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
03615       -1,    85,    86,    87,    -1,    89,    -1,    -1,    -1,    -1,
03616       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03617       -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,    -1,
03618       -1,   115,   116,    -1,   118,   119,   120,   121,   122,   123,
03619      124,   125,   126,   127,    -1,    -1,    -1,    -1,    -1,   133,
03620      134,   135,   136,    -1,    -1,   139,    -1,   141,     1,   143,
03621        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
03622       -1,    -1,    15,    16,    -1,    18,    19,    20,    21,    22,
03623       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03624       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03625       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03626       53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
03627       -1,    64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,
03628       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03629       -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,
03630       -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,   102,
03631      103,   104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,
03632       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03633       -1,    -1,    -1,    -1,    -1,   128,   129,   130,    -1,    -1,
03634       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     1,
03635      143,     3,     4,     5,     6,     7,    -1,    -1,    10,    11,
03636       12,    -1,    14,    15,    16,    -1,    18,    19,    20,    21,
03637       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03638       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03639       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03640       52,    53,    54,    55,    56,    57,    -1,    59,    60,    61,
03641       62,    -1,    64,    65,    66,    -1,    68,    69,    -1,    -1,
03642       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03643       -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    91,
03644       92,    -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,
03645      102,   103,   104,   105,   106,   107,   108,    -1,    -1,    -1,
03646       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03647       -1,    -1,    -1,    -1,    -1,    -1,   128,   129,   130,    -1,
03648       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,
03649        1,   143,     3,     4,     5,     6,     7,    -1,    -1,    10,
03650       11,    12,    -1,    -1,    15,    16,    17,    18,    19,    20,
03651       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03652       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03653       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
03654       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03655       61,    62,    -1,    64,    65,    66,    -1,    68,    69,    -1,
03656       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03657       -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,
03658       91,    92,    -1,    94,    95,    -1,    97,    -1,    -1,   100,
03659      101,   102,   103,   104,   105,   106,   107,   108,    -1,    -1,
03660       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03661       -1,    -1,    -1,    -1,    -1,    -1,    -1,   128,   129,   130,
03662       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03663      141,     1,   143,     3,     4,     5,     6,     7,    -1,    -1,
03664       10,    11,    12,    -1,    -1,    15,    16,    -1,    18,    19,
03665       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03666       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03667       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03668       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03669       60,    61,    62,    -1,    64,    65,    66,    -1,    68,    69,
03670       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03671       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
03672       -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,    -1,
03673      100,   101,   102,   103,   104,   105,   106,   107,   108,    -1,
03674       -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,
03675        5,     6,     7,    -1,     9,    10,    11,    12,   128,   129,
03676      130,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03677       -1,   141,    -1,   143,    -1,    30,    31,    32,    33,    34,
03678       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03679       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03680       55,    56,    57,    -1,    59,    60,    61,    62,    -1,    64,
03681       65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,    -1,
03682       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03683       -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,
03684       95,    -1,    97,    -1,    -1,   100,   101,   102,   103,   104,
03685      105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,    -1,
03686       -1,     1,    -1,     3,     4,     5,     6,     7,    -1,    -1,
03687       -1,    11,    12,   128,   129,   130,    16,    -1,    18,    19,
03688       20,    21,    22,    23,    24,    -1,   141,    -1,   143,    -1,
03689       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03690       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03691       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03692       60,    61,    62,    -1,    64,    65,    66,    -1,    68,    69,
03693       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03694       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
03695       -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,    -1,
03696      100,   101,   102,   103,   104,   105,   106,   107,   108,    -1,
03697       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03698       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   128,   129,
03699      130,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   139,
03700       -1,   141,     1,   143,     3,     4,     5,     6,     7,    -1,
03701       -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,    18,
03702       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03703       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03704       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03705       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03706       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03707       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03708       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03709       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
03710       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03711       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03712       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   128,
03713      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03714      139,    -1,   141,     1,   143,     3,     4,     5,     6,     7,
03715       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,
03716       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03717       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03718       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03719       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03720       -1,    59,    60,    61,    62,    -1,    64,    65,    66,    -1,
03721       68,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03722       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03723       88,    -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,
03724       -1,    -1,   100,   101,   102,   103,   104,   105,   106,   107,
03725      108,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03726       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03727      128,   129,   130,    -1,    -1,   133,     1,    -1,     3,     4,
03728        5,     6,     7,   141,    -1,   143,    11,    12,    -1,    -1,
03729       -1,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03730       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03731       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03732       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03733       55,    56,    57,    -1,    59,    60,    61,    62,    -1,    64,
03734       65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,    -1,
03735       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03736       -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,
03737       95,    -1,    97,    -1,    -1,   100,   101,   102,   103,   104,
03738      105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,    -1,
03739       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03740       -1,    -1,    -1,   128,   129,   130,    -1,    -1,   133,    -1,
03741       -1,    -1,    -1,    -1,    -1,    -1,   141,     1,   143,     3,
03742        4,     5,     6,     7,    -1,    -1,    10,    11,    12,    -1,
03743       -1,    -1,    16,    -1,    18,    19,    20,    21,    22,    23,
03744       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03745       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03746       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03747       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03748       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03749       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03750       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03751       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03752      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03753       -1,    -1,     1,    -1,     3,     4,     5,     6,     7,    -1,
03754       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03755       19,    20,    21,    22,    23,    24,    -1,   141,    -1,   143,
03756       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03757       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03758       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03759       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03760       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03761       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03762       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
03763       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03764       -1,   110,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03765        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03766      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03767       24,    -1,   141,    -1,   143,    -1,    30,    31,    32,    33,
03768       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03769       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03770       54,    55,    56,    57,    58,    59,    60,    61,    62,    -1,
03771       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03772       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03773       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03774       94,    95,    -1,    97,    98,    99,   100,   101,   102,   103,
03775      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03776       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03777       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03778       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,   143,
03779       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03780       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03781       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03782       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03783       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03784       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03785       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
03786       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03787       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03788        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03789      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03790       24,    -1,   141,    -1,   143,    -1,    30,    31,    32,    33,
03791       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03792       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03793       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03794       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03795       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03796       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03797       94,    95,    -1,    -1,    -1,    -1,   100,   101,   102,   103,
03798      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03799       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03800       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03801       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,   143,
03802       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03803       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03804       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03805       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03806       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03807       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03808       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
03809       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03810       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03811        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   128,
03812      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03813       24,    -1,   141,    -1,    -1,    -1,    30,    31,    32,    33,
03814       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03815       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03816       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03817       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03818       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03819       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03820       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03821      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03822       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03823       -1,    -1,    -1,    -1,   128,   129,   130,    -1,    -1,    -1,
03824       -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,
03825        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03826       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03827       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03828       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03829       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03830       55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03831       -1,    -1,    -1,    68,    69,    70,    71,    72,    73,    74,
03832       75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,    84,
03833       85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03834       -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
03835       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03836       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,   124,
03837      125,   126,   127,    -1,   129,   130,    -1,    -1,    -1,    -1,
03838       -1,    -1,   137,   138,     3,     4,     5,     6,     7,     8,
03839        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03840       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03841       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03842       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03843       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03844       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
03845       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
03846       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
03847       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
03848       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
03850      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03851      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,   137,     3,
03852        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03853       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03854       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03855       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03856       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03857       54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03858       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03859       74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,
03860       84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03861       -1,    -1,    -1,    97,    98,    -1,    -1,   101,    -1,    -1,
03862       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03863       -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
03864      124,   125,   126,   127,    -1,   129,   130,    -1,    -1,    -1,
03865       -1,    -1,    -1,   137,     3,     4,     5,     6,     7,     8,
03866        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03867       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03868       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03869       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03870       49,    50,    51,    52,    53,    -1,    -1,    56,    -1,    -1,
03871       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
03872       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
03873       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
03874       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
03875       -1,    -1,   101,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03876       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
03877      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
03878      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,   137,     3,
03879        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03880       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03881       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03882       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03883       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03884       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03885       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03886       74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,
03887       84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03888       -1,    -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,
03889       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03890       -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
03891      124,   125,   126,   127,    -1,   129,   130,     3,     4,     5,
03892       -1,     7,    -1,   137,    -1,    11,    12,    -1,    -1,    -1,
03893       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03894       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03895       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03896       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03897       56,    57,    -1,    59,    60,    61,    62,    -1,    64,    65,
03898       66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03899       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03900       -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,    95,
03901       -1,    -1,    -1,    -1,   100,   101,   102,   103,   104,   105,
03902      106,   107,   108,    -1,    -1,    -1,    -1,    -1,     3,     4,
03903        5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,
03904       -1,    16,   128,    18,    19,    20,    21,    22,    23,    24,
03905      136,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03906       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03907       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03908       55,    56,    57,    -1,    59,    60,    61,    62,    -1,    64,
03909       65,    66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03910       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03911       -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,    94,
03912       95,    -1,    -1,    -1,    -1,   100,   101,   102,   103,   104,
03913      105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,     3,
03914        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,    -1,
03915       -1,    -1,    16,   128,    18,    19,    20,    21,    22,    23,
03916       24,   136,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03917       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03918       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03919       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03920       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03921       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03922       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03923       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03924      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03925       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03926       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03927       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03928       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03929       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03930       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03931       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03932       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03933       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03934       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    98,
03935       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03936       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03937        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   128,
03938      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03939       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03940       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03941       -1,    45,    46,    -1,    48,    49,    50,    51,    52,    53,
03942       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
03943       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03944       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03945       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03946       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
03947      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03948       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03949       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03950       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03951       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03952       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03953       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03954       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03955       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03956       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03957       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    98,
03958       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03959       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03960        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03961      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03962       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03963       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03964       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03965       54,    55,    56,    57,    58,    59,    60,    61,    62,    -1,
03966       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03967       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03968       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03969       94,    95,    -1,    97,    98,    -1,   100,   101,   102,   103,
03970      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03971       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03972       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03973       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03974       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03975       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03976       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03977       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
03978       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03979       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
03980       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    98,
03981       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03982       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03983        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
03984      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
03985       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03986       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03987       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03988       54,    55,    56,    57,    58,    59,    60,    61,    62,    -1,
03989       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
03990       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03991       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
03992       94,    95,    -1,    97,    98,    -1,   100,   101,   102,   103,
03993      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
03994       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03995       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
03996       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03997       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03998       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03999       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
04000       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04001       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04002       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04003       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    98,
04004       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04005       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04006        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04007      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04008       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04009       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04010       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04011       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04012       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04013       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04014       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04015       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04016      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04017       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04018       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04019       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04020       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04021       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04022       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04023       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04024       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04025       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04026       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
04027       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04028       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04029        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04030      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04031       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04032       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04033       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04034       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04035       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04036       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04037       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04038       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04039      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04040       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04041       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04042       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04043       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04044       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04045       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04046       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04047       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04048       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04049       -1,    -1,    91,    92,    -1,    94,    95,    -1,    97,    -1,
04050       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04051       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04052        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04053      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04054       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04055       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04056       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04057       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04058       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04059       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04060       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04061       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04062      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04063       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04064       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04065       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04066       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04067       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04068       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04069       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04070       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04071       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04072       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
04073       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04074       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04075        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04076      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04077       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04078       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04079       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04080       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04081       64,    65,    66,    -1,    68,    69,    -1,    -1,    -1,    -1,
04082       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04083       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04084       94,    95,    -1,    -1,    -1,    -1,   100,   101,   102,   103,
04085      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04086       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04087       -1,    -1,    11,    12,   128,   129,   130,    16,    -1,    18,
04088       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04089       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04090       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04091       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04092       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    68,
04093       69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04094       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04095       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
04096       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04097       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04098        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   128,
04099      129,   130,    16,    -1,    18,    19,    20,    21,    22,    23,
04100       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04101       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04102       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04103       54,    55,    56,    57,    -1,    59,    60,    61,    62,    -1,
04104       64,    65,    66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04105       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04106       -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,    -1,
04107       94,    95,    -1,    97,    -1,    -1,   100,   101,   102,   103,
04108      104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,    -1,
04109        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04110       -1,    -1,    -1,    16,   128,    18,    19,    20,    21,    22,
04111       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04112       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04113       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04114       53,    54,    55,    56,    57,    -1,    59,    60,    61,    62,
04115       -1,    64,    65,    66,    -1,    -1,    -1,    -1,    -1,    -1,
04116       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04117       -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    91,    92,
04118       -1,    94,    95,    -1,    97,    -1,    -1,   100,   101,   102,
04119      103,   104,   105,   106,   107,   108,    -1,    -1,    -1,    -1,
04120       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
04121       12,    -1,    -1,    -1,    16,   128,    18,    19,    20,    21,
04122       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
04123       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
04124       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
04125       52,    53,    54,    55,    56,    57,    -1,    59,    60,    61,
04126       62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,    -1,
04127       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04128       -1,    -1,    -1,    85,    -1,    -1,    88,    -1,    -1,    91,
04129       92,    -1,    94,    95,    -1,    -1,    -1,    -1,   100,   101,
04130      102,   103,   104,   105,   106,   107,   108,    -1,    -1,    -1,
04131       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
04132       11,    12,    -1,    -1,    -1,    16,   128,    18,    19,    20,
04133       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
04134       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
04135       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
04136       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
04137       61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,
04138       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04139       -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,
04140       91,    92,    -1,    94,    95,    -1,    -1,    -1,    -1,   100,
04141      101,   102,   103,   104,   105,   106,   107,   108,    -1,    -1,
04142       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04143       -1,    11,    12,    -1,    -1,    -1,    16,   128,    18,    19,
04144       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04145       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04146       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04147       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04148       60,    61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,
04149       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04150       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
04151       -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,    -1,
04152      100,   101,   102,   103,   104,   105,   106,   107,   108,    -1,
04153       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04154       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   128,    18,
04155       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04156       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04157       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04158       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04159       59,    60,    61,    62,    -1,    64,    65,    66,    -1,    -1,
04160       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04161       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,
04162       -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,    -1,
04163       -1,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04164       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
04165       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,   128,
04166       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
04167       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
04168       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
04169       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
04170       -1,    59,    60,    61,    62,    -1,    64,    65,    66,    -1,
04171       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04172       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04173       88,    -1,    -1,    91,    92,    -1,    94,    95,    -1,    -1,
04174       -1,    -1,   100,   101,   102,   103,   104,   105,   106,   107,
04175      108,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,
04176       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04177      128,    68,    69,    70,    71,    72,    73,    74,    75,    76,
04178       -1,    -1,    79,    80,    -1,    -1,    83,    84,    85,    86,
04179       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04180       97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04181       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04182       -1,   118,   119,   120,   121,   122,   123,   124,   125,   126,
04183      127,    -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,
04184      137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04185       68,    69,    70,    71,    72,    73,    74,    75,    76,    -1,
04186       -1,    79,    80,    -1,    -1,    83,    84,    85,    86,    -1,
04187       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,
04188       98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04189       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04190      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
04191       -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,   137,
04192       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
04193       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
04194       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
04195       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
04196       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04197       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,
04198      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
04199      129,   130,    52,    53,    -1,    -1,    56,    -1,   137,    -1,
04200       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,
04201       70,    71,    72,    73,    74,    75,    76,    -1,    -1,    79,
04202       80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,    -1,
04203       -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    -1,
04204       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04205       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,
04206      120,   121,   122,   123,   124,   125,   126,   127,    -1,   129,
04207      130,    52,    53,    -1,    -1,    56,    -1,   137,    -1,    -1,
04208       -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
04209       71,    72,    73,    74,    75,    76,    -1,    -1,    79,    80,
04210       -1,    -1,    83,    84,    85,    86,    -1,    -1,    -1,    -1,
04211       -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    -1,    -1,
04212       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04213       -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,
04214      121,   122,   123,   124,   125,   126,   127,    -1,   129,   130,
04215       52,    53,    -1,    -1,    56,    -1,   137,    -1,    -1,    -1,
04216       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
04217       72,    73,    74,    75,    76,    -1,    -1,    79,    80,    -1,
04218       -1,    83,    84,    85,    86,    -1,    -1,    -1,    -1,    -1,
04219       -1,    -1,    -1,    -1,    -1,    97,    98,    -1,    -1,    -1,
04220       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04221       -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
04222      122,   123,   124,   125,   126,   127,    -1,   129,   130,    52,
04223       53,    -1,    -1,    56,    -1,   137,    -1,    -1,    -1,    -1,
04224       -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,
04225       73,    74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,
04226       83,    84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,
04227       -1,    -1,    -1,    -1,    97,    98,    -1,    -1,    -1,    -1,
04228       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04229       -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,
04230      123,   124,   125,   126,   127,    -1,   129,   130,    52,    53,
04231       -1,    -1,    56,    -1,   137,    -1,    -1,    -1,    -1,    -1,
04232       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
04233       74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,
04234       84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04235       -1,    -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,
04236       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04237       -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
04238      124,   125,   126,   127,    -1,   129,   130,    52,    53,    -1,
04239       -1,    56,    -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,
04240       -1,    -1,    -1,    68,    69,    70,    71,    72,    73,    74,
04241       75,    76,    -1,    -1,    79,    80,    -1,    -1,    83,    84,
04242       85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04243       -1,    -1,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
04244       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04245       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,   124,
04246      125,   126,   127,    -1,   129,   130,    52,    53,    -1,    -1,
04247       56,    -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04248       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
04249       76,    -1,    -1,    79,    80,    -1,    -1,    83,    84,    85,
04250       86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04251       -1,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04252       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04253       -1,    -1,   118,   119,   120,   121,   122,   123,   124,   125,
04254      126,   127,    -1,   129,   130,    52,    53,    -1,    -1,    56,
04255       -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04256       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
04257       -1,    -1,    79,    80,    -1,    -1,    83,    84,    85,    86,
04258       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04259       97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04260       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04261       -1,   118,   119,   120,   121,   122,   123,   124,   125,   126,
04262      127,    -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,
04263      137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04264       68,    69,    70,    71,    72,    73,    74,    75,    76,    -1,
04265       -1,    79,    80,    -1,    -1,    83,    84,    85,    86,    -1,
04266       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,
04267       98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04268       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04269      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
04270       -1,   129,   130,    52,    53,    -1,    -1,    56,    -1,   137,
04271       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
04272       69,    70,    71,    72,    73,    74,    75,    76,    -1,    -1,
04273       79,    80,    -1,    -1,    83,    84,    85,    86,    -1,    -1,
04274       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
04275       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
04276       80,    81,    82,    -1,    -1,    85,    86,    -1,    -1,   118,
04277      119,   120,   121,   122,   123,   124,   125,   126,   127,    -1,
04278      129,   130,    -1,    -1,    -1,    -1,    -1,    -1,   137,    -1,
04279       -1,    -1,    -1,    -1,    -1,    -1,   116,    -1,   118,   119,
04280      120,   121,   122,   123,   124,   125,   126,   127,    -1,    -1,
04281       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04282       -1,    -1,    -1,   143
04283 };
04284 
04285 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04286    symbol of state STATE-NUM.  */
04287 static const yytype_uint16 yystos[] =
04288 {
04289        0,   145,   146,     0,     1,     3,     4,     5,     6,     7,
04290       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04291       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04292       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04293       57,    59,    60,    61,    62,    64,    65,    66,    68,    69,
04294       88,    91,    92,    94,    95,    97,   100,   101,   102,   103,
04295      104,   105,   106,   107,   108,   128,   129,   130,   147,   148,
04296      149,   156,   158,   159,   161,   162,   165,   166,   167,   169,
04297      170,   171,   173,   174,   184,   199,   218,   219,   220,   221,
04298      222,   223,   224,   225,   226,   227,   228,   255,   256,   270,
04299      271,   272,   273,   274,   275,   276,   279,   281,   282,   294,
04300      296,   297,   298,   299,   300,   301,   302,   303,   336,   347,
04301      149,     3,     4,     5,     6,     7,     8,     9,    10,    11,
04302       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
04303       22,    23,    24,    25,    26,    30,    31,    32,    33,    34,
04304       35,    36,    37,    38,    39,    45,    46,    47,    48,    49,
04305       50,    51,    52,    53,    56,    68,    69,    70,    71,    72,
04306       73,    74,    75,    76,    79,    80,    83,    84,    85,    86,
04307       97,    98,   118,   119,   120,   121,   122,   123,   124,   125,
04308      126,   127,   129,   130,   137,   177,   178,   179,   180,   182,
04309      183,   294,   296,    39,    58,    88,    91,    97,    98,    99,
04310      129,   166,   174,   184,   186,   191,   194,   196,   218,   299,
04311      300,   302,   303,   334,   335,   191,   191,   138,   192,   193,
04312      138,   188,   192,   138,   143,   341,    54,   179,   341,   150,
04313      132,    21,    22,    30,    31,    32,   165,   184,   218,   184,
04314       56,     1,    47,    91,   152,   153,   154,   156,   168,   169,
04315      347,   201,   202,   187,   196,   334,   347,   186,   333,   334,
04316      347,    46,    88,   128,   136,   173,   199,   218,   299,   300,
04317      303,   246,   247,    54,    55,    57,   177,   286,   295,   285,
04318      286,   287,   142,   277,   142,   283,   142,   280,   142,   284,
04319      298,   161,   184,   184,   141,   143,   340,   345,   346,    40,
04320       41,    42,    43,    44,    37,    38,    26,   132,   188,   192,
04321      261,    28,   253,   115,   136,    91,    97,   170,   115,    70,
04322       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
04323       81,    82,    85,    86,   116,   118,   119,   120,   121,   122,
04324      123,   124,   125,   126,   127,    87,   134,   135,   200,   159,
04325      160,   160,   205,   207,   160,   340,   346,    88,   167,   174,
04326      218,   234,   299,   300,   303,    52,    56,    85,    88,   175,
04327      176,   218,   299,   300,   303,   176,    33,    34,    35,    36,
04328       49,    50,    51,    52,    56,   138,   177,   301,   331,    87,
04329      135,   339,   261,   273,    89,    89,   136,   186,    56,   186,
04330      186,   186,   115,    90,   136,   195,   347,    87,   134,   135,
04331       89,    89,   136,   195,   191,   341,   342,   191,   190,   191,
04332      196,   334,   347,   159,   342,   159,    54,    65,    66,   157,
04333      138,   185,   132,   152,    87,   135,    89,   156,   155,   168,
04334      139,   340,   346,   342,   342,   159,   140,   136,   143,   344,
04335      136,   344,   133,   344,   341,    56,   298,   170,   172,   136,
04336       87,   134,   135,   248,    63,   109,   111,   112,   288,   112,
04337      288,   112,    67,   288,   112,   112,   278,   288,   112,    63,
04338      112,   112,   112,   278,   112,    63,   112,    70,   141,   149,
04339      160,   160,   160,   160,   156,   159,   159,   263,   262,    96,
04340      163,   254,    97,   161,   186,   196,   197,   198,   168,   136,
04341      173,   136,   158,   161,   174,   184,   186,   198,   184,   184,
04342      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04343      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04344      184,   184,   184,   184,    52,    53,    56,   182,   260,   337,
04345      338,   190,    52,    53,    56,   182,   259,   337,   151,   152,
04346       13,   230,   345,   230,   160,   160,   340,    17,   264,    56,
04347       87,   134,   135,    25,   159,    52,    56,   175,     1,   119,
04348      304,   345,    87,   134,   135,   214,   332,   215,   339,    52,
04349       56,   337,   161,   184,   161,   184,   181,   184,   186,    97,
04350      186,   194,   334,    52,    56,   190,    52,    56,   335,   342,
04351      139,   342,   136,   136,   342,   179,   204,   184,   147,   133,
04352      337,   337,   184,   132,   342,   154,   203,   334,   136,   172,
04353       52,    56,   190,    52,    56,    52,    54,    55,    56,    57,
04354       58,    70,    91,    97,    98,    99,   122,   125,   138,   251,
04355      308,   310,   311,   312,   313,   314,   315,   316,   319,   320,
04356      321,   322,   325,   326,   327,   328,   329,   290,   289,   142,
04357      288,   142,   142,   142,   184,    78,   120,   241,   242,   347,
04358      241,   164,   241,   186,   136,   342,   172,   136,   115,    44,
04359      341,    89,    89,   188,   192,   258,   341,   343,    89,    89,
04360      188,   192,   257,    10,   229,     8,   266,   347,   152,    13,
04361      152,    27,   231,   345,   231,   264,   196,   229,    52,    56,
04362      190,    52,    56,   209,   212,   345,   305,   211,    52,    56,
04363      175,   190,   151,   159,   138,   306,   307,   216,   188,   189,
04364      192,   347,    44,   179,   186,   195,    89,    89,   343,    89,
04365       89,   334,   159,   133,   147,   342,   344,   170,   343,    91,
04366       97,   235,   236,   237,   312,   310,   249,   115,   136,   309,
04367      186,   136,   330,   347,    52,   136,   330,   136,   309,    52,
04368      136,   309,    52,   291,    54,    55,    57,   293,   303,   238,
04369      240,   243,   312,   314,   315,   317,   318,   321,   323,   324,
04370      327,   329,   341,   152,   152,   241,   152,    97,   186,   172,
04371      184,   117,   161,   184,   161,   184,   163,   188,   140,    89,
04372      161,   184,   161,   184,   163,   189,   186,   198,   267,   347,
04373       15,   233,   347,    14,   232,   233,   233,   206,   208,   229,
04374      136,   230,   343,   160,   345,   160,   151,   343,   229,   342,
04375      310,   151,   310,   177,   261,   253,   184,    89,   136,   342,
04376      133,   237,   136,   312,   136,   342,   243,   250,   186,   308,
04377      313,   325,   327,   316,   321,   329,   314,   322,   327,   312,
04378      314,   292,   243,   120,   115,   136,   239,    88,   218,   136,
04379      330,   330,   136,   239,   136,   239,   141,    10,   133,   152,
04380       10,   186,   184,   161,   184,    90,   268,   347,   152,     9,
04381      269,   347,   160,   229,   229,   152,   152,   186,   152,   231,
04382      213,   345,   229,   342,   229,   345,   217,   342,   236,   136,
04383       97,   235,   139,    29,   113,   252,   136,   309,   136,   309,
04384      330,   136,   309,   136,   309,   309,   152,   120,   218,   238,
04385      324,   327,    56,    87,   317,   321,   314,   323,   327,   314,
04386       52,   244,   245,   311,   133,    88,   174,   218,   299,   300,
04387      303,   230,   152,   230,   229,   229,   233,   264,   265,   210,
04388      151,   306,   136,   236,   136,   312,   152,   152,   314,   327,
04389      314,   314,   110,   136,   239,   136,   239,    52,    56,   330,
04390      136,   239,   136,   239,   239,   136,   341,    56,    87,   134,
04391      135,   152,   152,   152,   229,   151,   236,   136,    10,   133,
04392      309,   136,   309,   309,   309,   314,   327,   314,   314,   245,
04393       52,    56,   190,    52,    56,   266,   232,   229,   229,   236,
04394      314,   239,   136,   239,   239,   239,   343,   309,   314,   239
04395 };
04396 
04397 #define yyerrok         (yyerrstatus = 0)
04398 #define yyclearin       (yychar = YYEMPTY)
04399 #define YYEMPTY         (-2)
04400 #define YYEOF           0
04401 
04402 #define YYACCEPT        goto yyacceptlab
04403 #define YYABORT         goto yyabortlab
04404 #define YYERROR         goto yyerrorlab
04405 
04406 
04407 /* Like YYERROR except do call yyerror.  This remains here temporarily
04408    to ease the transition to the new meaning of YYERROR, for GCC.
04409    Once GCC version 2 has supplanted version 1, this can go.  However,
04410    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04411    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04412    discussed.  */
04413 
04414 #define YYFAIL          goto yyerrlab
04415 #if defined YYFAIL
04416   /* This is here to suppress warnings from the GCC cpp's
04417      -Wunused-macros.  Normally we don't worry about that warning, but
04418      some users do, and we want to make it easy for users to remove
04419      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04420 #endif
04421 
04422 #define YYRECOVERING()  (!!yyerrstatus)
04423 
04424 #define YYBACKUP(Token, Value)                                  \
04425 do                                                              \
04426   if (yychar == YYEMPTY && yylen == 1)                          \
04427     {                                                           \
04428       yychar = (Token);                                         \
04429       yylval = (Value);                                         \
04430       YYPOPSTACK (1);                                           \
04431       goto yybackup;                                            \
04432     }                                                           \
04433   else                                                          \
04434     {                                                           \
04435       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04436       YYERROR;                                                  \
04437     }                                                           \
04438 while (YYID (0))
04439 
04440 
04441 #define YYTERROR        1
04442 #define YYERRCODE       256
04443 
04444 
04445 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04446    If N is 0, then set CURRENT to the empty location which ends
04447    the previous symbol: RHS[0] (always defined).  */
04448 
04449 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04450 #ifndef YYLLOC_DEFAULT
04451 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04452     do                                                                  \
04453       if (YYID (N))                                                    \
04454         {                                                               \
04455           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04456           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04457           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04458           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04459         }                                                               \
04460       else                                                              \
04461         {                                                               \
04462           (Current).first_line   = (Current).last_line   =              \
04463             YYRHSLOC (Rhs, 0).last_line;                                \
04464           (Current).first_column = (Current).last_column =              \
04465             YYRHSLOC (Rhs, 0).last_column;                              \
04466         }                                                               \
04467     while (YYID (0))
04468 #endif
04469 
04470 
04471 /* This macro is provided for backward compatibility. */
04472 
04473 #ifndef YY_LOCATION_PRINT
04474 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04475 #endif
04476 
04477 
04478 /* YYLEX -- calling `yylex' with the right arguments.  */
04479 
04480 #ifdef YYLEX_PARAM
04481 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04482 #else
04483 # define YYLEX yylex (&yylval, parser)
04484 #endif
04485 
04486 /* Enable debugging if requested.  */
04487 #if YYDEBUG
04488 
04489 # ifndef YYFPRINTF
04490 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04491 #  define YYFPRINTF fprintf
04492 # endif
04493 
04494 # define YYDPRINTF(Args)                        \
04495 do {                                            \
04496   if (yydebug)                                  \
04497     YYFPRINTF Args;                             \
04498 } while (YYID (0))
04499 
04500 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04501 do {                                                                      \
04502   if (yydebug)                                                            \
04503     {                                                                     \
04504       YYFPRINTF (stderr, "%s ", Title);                                   \
04505       yy_symbol_print (stderr,                                            \
04506                   Type, Value, parser); \
04507       YYFPRINTF (stderr, "\n");                                           \
04508     }                                                                     \
04509 } while (YYID (0))
04510 
04511 
04512 /*--------------------------------.
04513 | Print this symbol on YYOUTPUT.  |
04514 `--------------------------------*/
04515 
04516 /*ARGSUSED*/
04517 #if (defined __STDC__ || defined __C99__FUNC__ \
04518      || defined __cplusplus || defined _MSC_VER)
04519 static void
04520 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04521 #else
04522 static void
04523 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04524     FILE *yyoutput;
04525     int yytype;
04526     YYSTYPE const * const yyvaluep;
04527     struct parser_params *parser;
04528 #endif
04529 {
04530   if (!yyvaluep)
04531     return;
04532   YYUSE (parser);
04533 # ifdef YYPRINT
04534   if (yytype < YYNTOKENS)
04535     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04536 # else
04537   YYUSE (yyoutput);
04538 # endif
04539   switch (yytype)
04540     {
04541       default:
04542         break;
04543     }
04544 }
04545 
04546 
04547 /*--------------------------------.
04548 | Print this symbol on YYOUTPUT.  |
04549 `--------------------------------*/
04550 
04551 #if (defined __STDC__ || defined __C99__FUNC__ \
04552      || defined __cplusplus || defined _MSC_VER)
04553 static void
04554 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04555 #else
04556 static void
04557 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04558     FILE *yyoutput;
04559     int yytype;
04560     YYSTYPE const * const yyvaluep;
04561     struct parser_params *parser;
04562 #endif
04563 {
04564   if (yytype < YYNTOKENS)
04565     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04566   else
04567     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04568 
04569   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04570   YYFPRINTF (yyoutput, ")");
04571 }
04572 
04573 /*------------------------------------------------------------------.
04574 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04575 | TOP (included).                                                   |
04576 `------------------------------------------------------------------*/
04577 
04578 #if (defined __STDC__ || defined __C99__FUNC__ \
04579      || defined __cplusplus || defined _MSC_VER)
04580 static void
04581 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04582 #else
04583 static void
04584 yy_stack_print (yybottom, yytop)
04585     yytype_int16 *yybottom;
04586     yytype_int16 *yytop;
04587 #endif
04588 {
04589   YYFPRINTF (stderr, "Stack now");
04590   for (; yybottom <= yytop; yybottom++)
04591     {
04592       int yybot = *yybottom;
04593       YYFPRINTF (stderr, " %d", yybot);
04594     }
04595   YYFPRINTF (stderr, "\n");
04596 }
04597 
04598 # define YY_STACK_PRINT(Bottom, Top)                            \
04599 do {                                                            \
04600   if (yydebug)                                                  \
04601     yy_stack_print ((Bottom), (Top));                           \
04602 } while (YYID (0))
04603 
04604 
04605 /*------------------------------------------------.
04606 | Report that the YYRULE is going to be reduced.  |
04607 `------------------------------------------------*/
04608 
04609 #if (defined __STDC__ || defined __C99__FUNC__ \
04610      || defined __cplusplus || defined _MSC_VER)
04611 static void
04612 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04613 #else
04614 static void
04615 yy_reduce_print (yyvsp, yyrule, parser)
04616     YYSTYPE *yyvsp;
04617     int yyrule;
04618     struct parser_params *parser;
04619 #endif
04620 {
04621   int yynrhs = yyr2[yyrule];
04622   int yyi;
04623   unsigned long int yylno = yyrline[yyrule];
04624   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04625              yyrule - 1, yylno);
04626   /* The symbols being reduced.  */
04627   for (yyi = 0; yyi < yynrhs; yyi++)
04628     {
04629       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04630       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04631                        &(yyvsp[(yyi + 1) - (yynrhs)])
04632                                        , parser);
04633       YYFPRINTF (stderr, "\n");
04634     }
04635 }
04636 
04637 # define YY_REDUCE_PRINT(Rule)          \
04638 do {                                    \
04639   if (yydebug)                          \
04640     yy_reduce_print (yyvsp, Rule, parser); \
04641 } while (YYID (0))
04642 
04643 /* Nonzero means print parse trace.  It is left uninitialized so that
04644    multiple parsers can coexist.  */
04645 #ifndef yydebug
04646 int yydebug;
04647 #endif
04648 #else /* !YYDEBUG */
04649 # define YYDPRINTF(Args)
04650 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04651 # define YY_STACK_PRINT(Bottom, Top)
04652 # define YY_REDUCE_PRINT(Rule)
04653 #endif /* !YYDEBUG */
04654 
04655 
04656 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04657 #ifndef YYINITDEPTH
04658 # define YYINITDEPTH 200
04659 #endif
04660 
04661 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04662    if the built-in stack extension method is used).
04663 
04664    Do not make this value too large; the results are undefined if
04665    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04666    evaluated with infinite-precision integer arithmetic.  */
04667 
04668 #ifndef YYMAXDEPTH
04669 # define YYMAXDEPTH 10000
04670 #endif
04671 
04672 
04673 #if YYERROR_VERBOSE
04674 
04675 # ifndef yystrlen
04676 #  if defined __GLIBC__ && defined _STRING_H
04677 #   define yystrlen strlen
04678 #  else
04679 /* Return the length of YYSTR.  */
04680 #if (defined __STDC__ || defined __C99__FUNC__ \
04681      || defined __cplusplus || defined _MSC_VER)
04682 static YYSIZE_T
04683 yystrlen (const char *yystr)
04684 #else
04685 static YYSIZE_T
04686 yystrlen (yystr)
04687     const char *yystr;
04688 #endif
04689 {
04690   YYSIZE_T yylen;
04691   for (yylen = 0; yystr[yylen]; yylen++)
04692     continue;
04693   return yylen;
04694 }
04695 #  endif
04696 # endif
04697 
04698 # ifndef yystpcpy
04699 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04700 #   define yystpcpy stpcpy
04701 #  else
04702 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04703    YYDEST.  */
04704 #if (defined __STDC__ || defined __C99__FUNC__ \
04705      || defined __cplusplus || defined _MSC_VER)
04706 static char *
04707 yystpcpy (char *yydest, const char *yysrc)
04708 #else
04709 static char *
04710 yystpcpy (yydest, yysrc)
04711     char *yydest;
04712     const char *yysrc;
04713 #endif
04714 {
04715   char *yyd = yydest;
04716   const char *yys = yysrc;
04717 
04718   while ((*yyd++ = *yys++) != '\0')
04719     continue;
04720 
04721   return yyd - 1;
04722 }
04723 #  endif
04724 # endif
04725 
04726 # ifndef yytnamerr
04727 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04728    quotes and backslashes, so that it's suitable for yyerror.  The
04729    heuristic is that double-quoting is unnecessary unless the string
04730    contains an apostrophe, a comma, or backslash (other than
04731    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04732    null, do not copy; instead, return the length of what the result
04733    would have been.  */
04734 static YYSIZE_T
04735 yytnamerr (char *yyres, const char *yystr)
04736 {
04737   if (*yystr == '"')
04738     {
04739       YYSIZE_T yyn = 0;
04740       char const *yyp = yystr;
04741 
04742       for (;;)
04743         switch (*++yyp)
04744           {
04745           case '\'':
04746           case ',':
04747             goto do_not_strip_quotes;
04748 
04749           case '\\':
04750             if (*++yyp != '\\')
04751               goto do_not_strip_quotes;
04752             /* Fall through.  */
04753           default:
04754             if (yyres)
04755               yyres[yyn] = *yyp;
04756             yyn++;
04757             break;
04758 
04759           case '"':
04760             if (yyres)
04761               yyres[yyn] = '\0';
04762             return yyn;
04763           }
04764     do_not_strip_quotes: ;
04765     }
04766 
04767   if (! yyres)
04768     return yystrlen (yystr);
04769 
04770   return yystpcpy (yyres, yystr) - yyres;
04771 }
04772 # endif
04773 
04774 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
04775    about the unexpected token YYTOKEN for the state stack whose top is
04776    YYSSP.
04777 
04778    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
04779    not large enough to hold the message.  In that case, also set
04780    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
04781    required number of bytes is too large to store.  */
04782 static int
04783 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
04784                 yytype_int16 *yyssp, int yytoken)
04785 {
04786   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
04787   YYSIZE_T yysize = yysize0;
04788   YYSIZE_T yysize1;
04789   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04790   /* Internationalized format string. */
04791   const char *yyformat = 0;
04792   /* Arguments of yyformat. */
04793   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04794   /* Number of reported tokens (one for the "unexpected", one per
04795      "expected"). */
04796   int yycount = 0;
04797 
04798   /* There are many possibilities here to consider:
04799      - Assume YYFAIL is not used.  It's too flawed to consider.  See
04800        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
04801        for details.  YYERROR is fine as it does not invoke this
04802        function.
04803      - If this state is a consistent state with a default action, then
04804        the only way this function was invoked is if the default action
04805        is an error action.  In that case, don't check for expected
04806        tokens because there are none.
04807      - The only way there can be no lookahead present (in yychar) is if
04808        this state is a consistent state with a default action.  Thus,
04809        detecting the absence of a lookahead is sufficient to determine
04810        that there is no unexpected or expected token to report.  In that
04811        case, just report a simple "syntax error".
04812      - Don't assume there isn't a lookahead just because this state is a
04813        consistent state with a default action.  There might have been a
04814        previous inconsistent state, consistent state with a non-default
04815        action, or user semantic action that manipulated yychar.
04816      - Of course, the expected token list depends on states to have
04817        correct lookahead information, and it depends on the parser not
04818        to perform extra reductions after fetching a lookahead from the
04819        scanner and before detecting a syntax error.  Thus, state merging
04820        (from LALR or IELR) and default reductions corrupt the expected
04821        token list.  However, the list is correct for canonical LR with
04822        one exception: it will still contain any token that will not be
04823        accepted due to an error action in a later state.
04824   */
04825   if (yytoken != YYEMPTY)
04826     {
04827       int yyn = yypact[*yyssp];
04828       yyarg[yycount++] = yytname[yytoken];
04829       if (!yypact_value_is_default (yyn))
04830         {
04831           /* Start YYX at -YYN if negative to avoid negative indexes in
04832              YYCHECK.  In other words, skip the first -YYN actions for
04833              this state because they are default actions.  */
04834           int yyxbegin = yyn < 0 ? -yyn : 0;
04835           /* Stay within bounds of both yycheck and yytname.  */
04836           int yychecklim = YYLAST - yyn + 1;
04837           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04838           int yyx;
04839 
04840           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04841             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
04842                 && !yytable_value_is_error (yytable[yyx + yyn]))
04843               {
04844                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04845                   {
04846                     yycount = 1;
04847                     yysize = yysize0;
04848                     break;
04849                   }
04850                 yyarg[yycount++] = yytname[yyx];
04851                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04852                 if (! (yysize <= yysize1
04853                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04854                   return 2;
04855                 yysize = yysize1;
04856               }
04857         }
04858     }
04859 
04860   switch (yycount)
04861     {
04862 # define YYCASE_(N, S)                      \
04863       case N:                               \
04864         yyformat = S;                       \
04865       break
04866       YYCASE_(0, YY_("syntax error"));
04867       YYCASE_(1, YY_("syntax error, unexpected %s"));
04868       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
04869       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
04870       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
04871       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
04872 # undef YYCASE_
04873     }
04874 
04875   yysize1 = yysize + yystrlen (yyformat);
04876   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04877     return 2;
04878   yysize = yysize1;
04879 
04880   if (*yymsg_alloc < yysize)
04881     {
04882       *yymsg_alloc = 2 * yysize;
04883       if (! (yysize <= *yymsg_alloc
04884              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
04885         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
04886       return 1;
04887     }
04888 
04889   /* Avoid sprintf, as that infringes on the user's name space.
04890      Don't have undefined behavior even if the translation
04891      produced a string with the wrong number of "%s"s.  */
04892   {
04893     char *yyp = *yymsg;
04894     int yyi = 0;
04895     while ((*yyp = *yyformat) != '\0')
04896       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
04897         {
04898           yyp += yytnamerr (yyp, yyarg[yyi++]);
04899           yyformat += 2;
04900         }
04901       else
04902         {
04903           yyp++;
04904           yyformat++;
04905         }
04906   }
04907   return 0;
04908 }
04909 #endif /* YYERROR_VERBOSE */
04910 
04911 /*-----------------------------------------------.
04912 | Release the memory associated to this symbol.  |
04913 `-----------------------------------------------*/
04914 
04915 /*ARGSUSED*/
04916 #if (defined __STDC__ || defined __C99__FUNC__ \
04917      || defined __cplusplus || defined _MSC_VER)
04918 static void
04919 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04920 #else
04921 static void
04922 yydestruct (yymsg, yytype, yyvaluep, parser)
04923     const char *yymsg;
04924     int yytype;
04925     YYSTYPE *yyvaluep;
04926     struct parser_params *parser;
04927 #endif
04928 {
04929   YYUSE (yyvaluep);
04930   YYUSE (parser);
04931 
04932   if (!yymsg)
04933     yymsg = "Deleting";
04934   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04935 
04936   switch (yytype)
04937     {
04938 
04939       default:
04940         break;
04941     }
04942 }
04943 
04944 
04945 /* Prevent warnings from -Wmissing-prototypes.  */
04946 #ifdef YYPARSE_PARAM
04947 #if defined __STDC__ || defined __cplusplus
04948 int yyparse (void *YYPARSE_PARAM);
04949 #else
04950 int yyparse ();
04951 #endif
04952 #else /* ! YYPARSE_PARAM */
04953 #if defined __STDC__ || defined __cplusplus
04954 int yyparse (struct parser_params *parser);
04955 #else
04956 int yyparse ();
04957 #endif
04958 #endif /* ! YYPARSE_PARAM */
04959 
04960 
04961 /*----------.
04962 | yyparse.  |
04963 `----------*/
04964 
04965 #ifdef YYPARSE_PARAM
04966 #if (defined __STDC__ || defined __C99__FUNC__ \
04967      || defined __cplusplus || defined _MSC_VER)
04968 int
04969 yyparse (void *YYPARSE_PARAM)
04970 #else
04971 int
04972 yyparse (YYPARSE_PARAM)
04973     void *YYPARSE_PARAM;
04974 #endif
04975 #else /* ! YYPARSE_PARAM */
04976 #if (defined __STDC__ || defined __C99__FUNC__ \
04977      || defined __cplusplus || defined _MSC_VER)
04978 int
04979 yyparse (struct parser_params *parser)
04980 #else
04981 int
04982 yyparse (parser)
04983     struct parser_params *parser;
04984 #endif
04985 #endif
04986 {
04987 /* The lookahead symbol.  */
04988 int yychar;
04989 
04990 /* The semantic value of the lookahead symbol.  */
04991 YYSTYPE yylval;
04992 
04993     /* Number of syntax errors so far.  */
04994     int yynerrs;
04995 
04996     int yystate;
04997     /* Number of tokens to shift before error messages enabled.  */
04998     int yyerrstatus;
04999 
05000     /* The stacks and their tools:
05001        `yyss': related to states.
05002        `yyvs': related to semantic values.
05003 
05004        Refer to the stacks thru separate pointers, to allow yyoverflow
05005        to reallocate them elsewhere.  */
05006 
05007     /* The state stack.  */
05008     yytype_int16 yyssa[YYINITDEPTH];
05009     yytype_int16 *yyss;
05010     yytype_int16 *yyssp;
05011 
05012     /* The semantic value stack.  */
05013     YYSTYPE yyvsa[YYINITDEPTH];
05014     YYSTYPE *yyvs;
05015     YYSTYPE *yyvsp;
05016 
05017     YYSIZE_T yystacksize;
05018 
05019   int yyn;
05020   int yyresult;
05021   /* Lookahead token as an internal (translated) token number.  */
05022   int yytoken;
05023   /* The variables used to return semantic value and location from the
05024      action routines.  */
05025   YYSTYPE yyval;
05026 
05027 #if YYERROR_VERBOSE
05028   /* Buffer for error messages, and its allocated size.  */
05029   char yymsgbuf[128];
05030   char *yymsg = yymsgbuf;
05031   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
05032 #endif
05033 
05034 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
05035 
05036   /* The number of symbols on the RHS of the reduced rule.
05037      Keep to zero when no symbol should be popped.  */
05038   int yylen = 0;
05039 
05040   yytoken = 0;
05041   yyss = yyssa;
05042   yyvs = yyvsa;
05043   yystacksize = YYINITDEPTH;
05044 
05045   YYDPRINTF ((stderr, "Starting parse\n"));
05046 
05047   yystate = 0;
05048   yyerrstatus = 0;
05049   yynerrs = 0;
05050   yychar = YYEMPTY; /* Cause a token to be read.  */
05051 
05052   /* Initialize stack pointers.
05053      Waste one element of value and location stack
05054      so that they stay on the same level as the state stack.
05055      The wasted elements are never initialized.  */
05056   yyssp = yyss;
05057   yyvsp = yyvs;
05058 
05059   goto yysetstate;
05060 
05061 /*------------------------------------------------------------.
05062 | yynewstate -- Push a new state, which is found in yystate.  |
05063 `------------------------------------------------------------*/
05064  yynewstate:
05065   /* In all cases, when you get here, the value and location stacks
05066      have just been pushed.  So pushing a state here evens the stacks.  */
05067   yyssp++;
05068 
05069  yysetstate:
05070   *yyssp = yystate;
05071 
05072   if (yyss + yystacksize - 1 <= yyssp)
05073     {
05074       /* Get the current used size of the three stacks, in elements.  */
05075       YYSIZE_T yysize = yyssp - yyss + 1;
05076 
05077 #ifdef yyoverflow
05078       {
05079         /* Give user a chance to reallocate the stack.  Use copies of
05080            these so that the &'s don't force the real ones into
05081            memory.  */
05082         YYSTYPE *yyvs1 = yyvs;
05083         yytype_int16 *yyss1 = yyss;
05084 
05085         /* Each stack pointer address is followed by the size of the
05086            data in use in that stack, in bytes.  This used to be a
05087            conditional around just the two extra args, but that might
05088            be undefined if yyoverflow is a macro.  */
05089         yyoverflow (YY_("memory exhausted"),
05090                     &yyss1, yysize * sizeof (*yyssp),
05091                     &yyvs1, yysize * sizeof (*yyvsp),
05092                     &yystacksize);
05093 
05094         yyss = yyss1;
05095         yyvs = yyvs1;
05096       }
05097 #else /* no yyoverflow */
05098 # ifndef YYSTACK_RELOCATE
05099       goto yyexhaustedlab;
05100 # else
05101       /* Extend the stack our own way.  */
05102       if (YYMAXDEPTH <= yystacksize)
05103         goto yyexhaustedlab;
05104       yystacksize *= 2;
05105       if (YYMAXDEPTH < yystacksize)
05106         yystacksize = YYMAXDEPTH;
05107 
05108       {
05109         yytype_int16 *yyss1 = yyss;
05110         union yyalloc *yyptr =
05111           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
05112         if (! yyptr)
05113           goto yyexhaustedlab;
05114         YYSTACK_RELOCATE (yyss_alloc, yyss);
05115         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
05116 #  undef YYSTACK_RELOCATE
05117         if (yyss1 != yyssa)
05118           YYSTACK_FREE (yyss1);
05119       }
05120 # endif
05121 #endif /* no yyoverflow */
05122 
05123       yyssp = yyss + yysize - 1;
05124       yyvsp = yyvs + yysize - 1;
05125 
05126       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
05127                   (unsigned long int) yystacksize));
05128 
05129       if (yyss + yystacksize - 1 <= yyssp)
05130         YYABORT;
05131     }
05132 
05133   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
05134 
05135   if (yystate == YYFINAL)
05136     YYACCEPT;
05137 
05138   goto yybackup;
05139 
05140 /*-----------.
05141 | yybackup.  |
05142 `-----------*/
05143 yybackup:
05144 
05145   /* Do appropriate processing given the current state.  Read a
05146      lookahead token if we need one and don't already have one.  */
05147 
05148   /* First try to decide what to do without reference to lookahead token.  */
05149   yyn = yypact[yystate];
05150   if (yypact_value_is_default (yyn))
05151     goto yydefault;
05152 
05153   /* Not known => get a lookahead token if don't already have one.  */
05154 
05155   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
05156   if (yychar == YYEMPTY)
05157     {
05158       YYDPRINTF ((stderr, "Reading a token: "));
05159       yychar = YYLEX;
05160     }
05161 
05162   if (yychar <= YYEOF)
05163     {
05164       yychar = yytoken = YYEOF;
05165       YYDPRINTF ((stderr, "Now at end of input.\n"));
05166     }
05167   else
05168     {
05169       yytoken = YYTRANSLATE (yychar);
05170       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
05171     }
05172 
05173   /* If the proper action on seeing token YYTOKEN is to reduce or to
05174      detect an error, take that action.  */
05175   yyn += yytoken;
05176   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
05177     goto yydefault;
05178   yyn = yytable[yyn];
05179   if (yyn <= 0)
05180     {
05181       if (yytable_value_is_error (yyn))
05182         goto yyerrlab;
05183       yyn = -yyn;
05184       goto yyreduce;
05185     }
05186 
05187   /* Count tokens shifted since error; after three, turn off error
05188      status.  */
05189   if (yyerrstatus)
05190     yyerrstatus--;
05191 
05192   /* Shift the lookahead token.  */
05193   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
05194 
05195   /* Discard the shifted token.  */
05196   yychar = YYEMPTY;
05197 
05198   yystate = yyn;
05199   *++yyvsp = yylval;
05200 
05201   goto yynewstate;
05202 
05203 
05204 /*-----------------------------------------------------------.
05205 | yydefault -- do the default action for the current state.  |
05206 `-----------------------------------------------------------*/
05207 yydefault:
05208   yyn = yydefact[yystate];
05209   if (yyn == 0)
05210     goto yyerrlab;
05211   goto yyreduce;
05212 
05213 
05214 /*-----------------------------.
05215 | yyreduce -- Do a reduction.  |
05216 `-----------------------------*/
05217 yyreduce:
05218   /* yyn is the number of a rule to reduce with.  */
05219   yylen = yyr2[yyn];
05220 
05221   /* If YYLEN is nonzero, implement the default value of the action:
05222      `$$ = $1'.
05223 
05224      Otherwise, the following line sets YYVAL to garbage.
05225      This behavior is undocumented and Bison
05226      users should not rely upon it.  Assigning to YYVAL
05227      unconditionally makes the parser a bit smaller, and it avoids a
05228      GCC warning that YYVAL may be used uninitialized.  */
05229   yyval = yyvsp[1-yylen];
05230 
05231 
05232   YY_REDUCE_PRINT (yyn);
05233   switch (yyn)
05234     {
05235         case 2:
05236 
05237 /* Line 1806 of yacc.c  */
05238 #line 863 "ripper.y"
05239     {
05240                         lex_state = EXPR_BEG;
05241 #if 0
05242                         local_push(compile_for_eval || rb_parse_in_main());
05243 #endif
05244                         local_push(0);
05245 
05246                     }
05247     break;
05248 
05249   case 3:
05250 
05251 /* Line 1806 of yacc.c  */
05252 #line 872 "ripper.y"
05253     {
05254 #if 0
05255                         if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
05256                             /* last expression should not be void */
05257                             if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
05258                             else {
05259                                 NODE *node = (yyvsp[(2) - (2)].val);
05260                                 while (node->nd_next) {
05261                                     node = node->nd_next;
05262                                 }
05263                                 void_expr(node->nd_head);
05264                             }
05265                         }
05266                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
05267 #endif
05268                         (yyval.val) = (yyvsp[(2) - (2)].val);
05269                         parser->result = dispatch1(program, (yyval.val));
05270 
05271                         local_pop();
05272                     }
05273     break;
05274 
05275   case 4:
05276 
05277 /* Line 1806 of yacc.c  */
05278 #line 895 "ripper.y"
05279     {
05280 #if 0
05281                         void_stmts((yyvsp[(1) - (2)].val));
05282                         fixup_nodes(&deferred_nodes);
05283 #endif
05284 
05285                         (yyval.val) = (yyvsp[(1) - (2)].val);
05286                     }
05287     break;
05288 
05289   case 5:
05290 
05291 /* Line 1806 of yacc.c  */
05292 #line 906 "ripper.y"
05293     {
05294 #if 0
05295                         (yyval.val) = NEW_BEGIN(0);
05296 #endif
05297                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05298                                                   dispatch0(void_stmt));
05299 
05300                     }
05301     break;
05302 
05303   case 6:
05304 
05305 /* Line 1806 of yacc.c  */
05306 #line 915 "ripper.y"
05307     {
05308 #if 0
05309                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05310 #endif
05311                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05312 
05313                     }
05314     break;
05315 
05316   case 7:
05317 
05318 /* Line 1806 of yacc.c  */
05319 #line 923 "ripper.y"
05320     {
05321 #if 0
05322                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05323 #endif
05324                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05325 
05326                     }
05327     break;
05328 
05329   case 8:
05330 
05331 /* Line 1806 of yacc.c  */
05332 #line 931 "ripper.y"
05333     {
05334                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05335                     }
05336     break;
05337 
05338   case 10:
05339 
05340 /* Line 1806 of yacc.c  */
05341 #line 938 "ripper.y"
05342     {
05343 #if 0
05344                         /* local_push(0); */
05345 #endif
05346 
05347                     }
05348     break;
05349 
05350   case 11:
05351 
05352 /* Line 1806 of yacc.c  */
05353 #line 945 "ripper.y"
05354     {
05355 #if 0
05356                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05357                                                             (yyvsp[(4) - (5)].val));
05358                         /* NEW_PREEXE($4)); */
05359                         /* local_pop(); */
05360                         (yyval.val) = NEW_BEGIN(0);
05361 #endif
05362                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05363 
05364                     }
05365     break;
05366 
05367   case 12:
05368 
05369 /* Line 1806 of yacc.c  */
05370 #line 962 "ripper.y"
05371     {
05372 #if 0
05373                         (yyval.val) = (yyvsp[(1) - (4)].val);
05374                         if ((yyvsp[(2) - (4)].val)) {
05375                             (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05376                         }
05377                         else if ((yyvsp[(3) - (4)].val)) {
05378                             rb_warn0("else without rescue is useless");
05379                             (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
05380                         }
05381                         if ((yyvsp[(4) - (4)].val)) {
05382                             if ((yyval.val)) {
05383                                 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
05384                             }
05385                             else {
05386                                 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
05387                             }
05388                         }
05389                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05390 #endif
05391                         (yyval.val) = dispatch4(bodystmt,
05392                                        escape_Qundef((yyvsp[(1) - (4)].val)),
05393                                        escape_Qundef((yyvsp[(2) - (4)].val)),
05394                                        escape_Qundef((yyvsp[(3) - (4)].val)),
05395                                        escape_Qundef((yyvsp[(4) - (4)].val)));
05396 
05397                     }
05398     break;
05399 
05400   case 13:
05401 
05402 /* Line 1806 of yacc.c  */
05403 #line 992 "ripper.y"
05404     {
05405 #if 0
05406                         void_stmts((yyvsp[(1) - (2)].val));
05407                         fixup_nodes(&deferred_nodes);
05408 #endif
05409 
05410                         (yyval.val) = (yyvsp[(1) - (2)].val);
05411                     }
05412     break;
05413 
05414   case 14:
05415 
05416 /* Line 1806 of yacc.c  */
05417 #line 1003 "ripper.y"
05418     {
05419 #if 0
05420                         (yyval.val) = NEW_BEGIN(0);
05421 #endif
05422                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05423                                                   dispatch0(void_stmt));
05424 
05425                     }
05426     break;
05427 
05428   case 15:
05429 
05430 /* Line 1806 of yacc.c  */
05431 #line 1012 "ripper.y"
05432     {
05433 #if 0
05434                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05435 #endif
05436                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05437 
05438                     }
05439     break;
05440 
05441   case 16:
05442 
05443 /* Line 1806 of yacc.c  */
05444 #line 1020 "ripper.y"
05445     {
05446 #if 0
05447                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05448 #endif
05449                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05450 
05451                     }
05452     break;
05453 
05454   case 17:
05455 
05456 /* Line 1806 of yacc.c  */
05457 #line 1028 "ripper.y"
05458     {
05459                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05460                     }
05461     break;
05462 
05463   case 18:
05464 
05465 /* Line 1806 of yacc.c  */
05466 #line 1034 "ripper.y"
05467     {
05468                         (yyval.val) = (yyvsp[(1) - (1)].val);
05469                     }
05470     break;
05471 
05472   case 19:
05473 
05474 /* Line 1806 of yacc.c  */
05475 #line 1038 "ripper.y"
05476     {
05477                         yyerror("BEGIN is permitted only at toplevel");
05478 #if 0
05479                         /* local_push(0); */
05480 #endif
05481 
05482                     }
05483     break;
05484 
05485   case 20:
05486 
05487 /* Line 1806 of yacc.c  */
05488 #line 1046 "ripper.y"
05489     {
05490 #if 0
05491                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05492                                                             (yyvsp[(4) - (5)].val));
05493                         /* NEW_PREEXE($4)); */
05494                         /* local_pop(); */
05495                         (yyval.val) = NEW_BEGIN(0);
05496 #endif
05497                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05498 
05499                     }
05500     break;
05501 
05502   case 21:
05503 
05504 /* Line 1806 of yacc.c  */
05505 #line 1058 "ripper.y"
05506     {lex_state = EXPR_FNAME;}
05507     break;
05508 
05509   case 22:
05510 
05511 /* Line 1806 of yacc.c  */
05512 #line 1059 "ripper.y"
05513     {
05514 #if 0
05515                         (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05516 #endif
05517                         (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05518 
05519                     }
05520     break;
05521 
05522   case 23:
05523 
05524 /* Line 1806 of yacc.c  */
05525 #line 1067 "ripper.y"
05526     {
05527 #if 0
05528                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05529 #endif
05530                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05531 
05532                     }
05533     break;
05534 
05535   case 24:
05536 
05537 /* Line 1806 of yacc.c  */
05538 #line 1075 "ripper.y"
05539     {
05540 #if 0
05541                         char buf[2];
05542                         buf[0] = '$';
05543                         buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
05544                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
05545 #endif
05546                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05547 
05548                     }
05549     break;
05550 
05551   case 25:
05552 
05553 /* Line 1806 of yacc.c  */
05554 #line 1086 "ripper.y"
05555     {
05556 #if 0
05557                         yyerror("can't make alias for the number variables");
05558                         (yyval.val) = NEW_BEGIN(0);
05559 #endif
05560                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05561                         (yyval.val) = dispatch1(alias_error, (yyval.val));
05562 
05563                     }
05564     break;
05565 
05566   case 26:
05567 
05568 /* Line 1806 of yacc.c  */
05569 #line 1096 "ripper.y"
05570     {
05571 #if 0
05572                         (yyval.val) = (yyvsp[(2) - (2)].val);
05573 #endif
05574                         (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
05575 
05576                     }
05577     break;
05578 
05579   case 27:
05580 
05581 /* Line 1806 of yacc.c  */
05582 #line 1104 "ripper.y"
05583     {
05584 #if 0
05585                         (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05586                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05587 #endif
05588                         (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05589 
05590                     }
05591     break;
05592 
05593   case 28:
05594 
05595 /* Line 1806 of yacc.c  */
05596 #line 1113 "ripper.y"
05597     {
05598 #if 0
05599                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05600                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05601 #endif
05602                         (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05603 
05604                     }
05605     break;
05606 
05607   case 29:
05608 
05609 /* Line 1806 of yacc.c  */
05610 #line 1122 "ripper.y"
05611     {
05612 #if 0
05613                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05614                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05615                         }
05616                         else {
05617                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05618                         }
05619 #endif
05620                         (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05621 
05622                     }
05623     break;
05624 
05625   case 30:
05626 
05627 /* Line 1806 of yacc.c  */
05628 #line 1135 "ripper.y"
05629     {
05630 #if 0
05631                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05632                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05633                         }
05634                         else {
05635                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05636                         }
05637 #endif
05638                         (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05639 
05640                     }
05641     break;
05642 
05643   case 31:
05644 
05645 /* Line 1806 of yacc.c  */
05646 #line 1148 "ripper.y"
05647     {
05648 #if 0
05649                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
05650                         (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
05651 #endif
05652                         (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05653 
05654                     }
05655     break;
05656 
05657   case 32:
05658 
05659 /* Line 1806 of yacc.c  */
05660 #line 1157 "ripper.y"
05661     {
05662                         if (in_def || in_single) {
05663                             rb_warn0("END in method; use at_exit");
05664                         }
05665 #if 0
05666                         (yyval.val) = NEW_POSTEXE(NEW_NODE(
05667                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
05668 #endif
05669                         (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
05670 
05671                     }
05672     break;
05673 
05674   case 34:
05675 
05676 /* Line 1806 of yacc.c  */
05677 #line 1170 "ripper.y"
05678     {
05679 #if 0
05680                         value_expr((yyvsp[(3) - (3)].val));
05681                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05682                         (yyval.val) = (yyvsp[(1) - (3)].val);
05683 #endif
05684                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05685 
05686                     }
05687     break;
05688 
05689   case 35:
05690 
05691 /* Line 1806 of yacc.c  */
05692 #line 1180 "ripper.y"
05693     {
05694                         value_expr((yyvsp[(3) - (3)].val));
05695                         (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05696                     }
05697     break;
05698 
05699   case 36:
05700 
05701 /* Line 1806 of yacc.c  */
05702 #line 1185 "ripper.y"
05703     {
05704 #if 0
05705                         NODE *args;
05706 
05707                         value_expr((yyvsp[(6) - (6)].val));
05708                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
05709                         args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
05710                         if ((yyvsp[(5) - (6)].val) == tOROP) {
05711                             (yyvsp[(5) - (6)].val) = 0;
05712                         }
05713                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
05714                             (yyvsp[(5) - (6)].val) = 1;
05715                         }
05716                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
05717                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
05718 #endif
05719                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
05720                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
05721 
05722                     }
05723     break;
05724 
05725   case 37:
05726 
05727 /* Line 1806 of yacc.c  */
05728 #line 1206 "ripper.y"
05729     {
05730                         value_expr((yyvsp[(5) - (5)].val));
05731                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05732                     }
05733     break;
05734 
05735   case 38:
05736 
05737 /* Line 1806 of yacc.c  */
05738 #line 1211 "ripper.y"
05739     {
05740                         value_expr((yyvsp[(5) - (5)].val));
05741                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05742                     }
05743     break;
05744 
05745   case 39:
05746 
05747 /* Line 1806 of yacc.c  */
05748 #line 1216 "ripper.y"
05749     {
05750 #if 0
05751                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05752                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05753 #endif
05754                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05755                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05756 
05757                     }
05758     break;
05759 
05760   case 40:
05761 
05762 /* Line 1806 of yacc.c  */
05763 #line 1226 "ripper.y"
05764     {
05765                         value_expr((yyvsp[(5) - (5)].val));
05766                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05767                     }
05768     break;
05769 
05770   case 41:
05771 
05772 /* Line 1806 of yacc.c  */
05773 #line 1231 "ripper.y"
05774     {
05775 #if 0
05776                         rb_backref_error((yyvsp[(1) - (3)].val));
05777                         (yyval.val) = NEW_BEGIN(0);
05778 #endif
05779                         (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
05780                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05781 
05782                     }
05783     break;
05784 
05785   case 42:
05786 
05787 /* Line 1806 of yacc.c  */
05788 #line 1241 "ripper.y"
05789     {
05790 #if 0
05791                         value_expr((yyvsp[(3) - (3)].val));
05792                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05793 #endif
05794                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05795 
05796                     }
05797     break;
05798 
05799   case 43:
05800 
05801 /* Line 1806 of yacc.c  */
05802 #line 1250 "ripper.y"
05803     {
05804 #if 0
05805                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05806                         (yyval.val) = (yyvsp[(1) - (3)].val);
05807 #endif
05808                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05809 
05810                     }
05811     break;
05812 
05813   case 45:
05814 
05815 /* Line 1806 of yacc.c  */
05816 #line 1262 "ripper.y"
05817     {
05818 #if 0
05819                         value_expr((yyvsp[(3) - (3)].val));
05820                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05821 #endif
05822                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05823 
05824                     }
05825     break;
05826 
05827   case 46:
05828 
05829 /* Line 1806 of yacc.c  */
05830 #line 1271 "ripper.y"
05831     {
05832 #if 0
05833                         value_expr((yyvsp[(3) - (3)].val));
05834                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05835 #endif
05836                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05837 
05838                     }
05839     break;
05840 
05841   case 48:
05842 
05843 /* Line 1806 of yacc.c  */
05844 #line 1284 "ripper.y"
05845     {
05846 #if 0
05847                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05848 #endif
05849                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
05850 
05851                     }
05852     break;
05853 
05854   case 49:
05855 
05856 /* Line 1806 of yacc.c  */
05857 #line 1292 "ripper.y"
05858     {
05859 #if 0
05860                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05861 #endif
05862                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
05863 
05864                     }
05865     break;
05866 
05867   case 50:
05868 
05869 /* Line 1806 of yacc.c  */
05870 #line 1300 "ripper.y"
05871     {
05872 #if 0
05873                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
05874 #endif
05875                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
05876 
05877                     }
05878     break;
05879 
05880   case 51:
05881 
05882 /* Line 1806 of yacc.c  */
05883 #line 1308 "ripper.y"
05884     {
05885 #if 0
05886                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
05887 #endif
05888                         (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
05889 
05890                     }
05891     break;
05892 
05893   case 53:
05894 
05895 /* Line 1806 of yacc.c  */
05896 #line 1319 "ripper.y"
05897     {
05898 #if 0
05899                         value_expr((yyvsp[(1) - (1)].val));
05900                         (yyval.val) = (yyvsp[(1) - (1)].val);
05901                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
05902 #endif
05903                         (yyval.val) = (yyvsp[(1) - (1)].val);
05904 
05905                     }
05906     break;
05907 
05908   case 57:
05909 
05910 /* Line 1806 of yacc.c  */
05911 #line 1336 "ripper.y"
05912     {
05913 #if 0
05914                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05915 #endif
05916                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05917                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05918 
05919                     }
05920     break;
05921 
05922   case 58:
05923 
05924 /* Line 1806 of yacc.c  */
05925 #line 1347 "ripper.y"
05926     {
05927                         (yyvsp[(1) - (1)].vars) = dyna_push();
05928 #if 0
05929                         (yyval.num) = ruby_sourceline;
05930 #endif
05931 
05932                     }
05933     break;
05934 
05935   case 59:
05936 
05937 /* Line 1806 of yacc.c  */
05938 #line 1357 "ripper.y"
05939     {
05940 #if 0
05941                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
05942                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
05943 #endif
05944                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
05945 
05946                         dyna_pop((yyvsp[(1) - (5)].vars));
05947                     }
05948     break;
05949 
05950   case 60:
05951 
05952 /* Line 1806 of yacc.c  */
05953 #line 1369 "ripper.y"
05954     {
05955 #if 0
05956                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
05957                         nd_set_line((yyval.val), tokline);
05958 #endif
05959 
05960                     }
05961     break;
05962 
05963   case 61:
05964 
05965 /* Line 1806 of yacc.c  */
05966 #line 1379 "ripper.y"
05967     {
05968 #if 0
05969                         (yyval.val) = (yyvsp[(1) - (2)].val);
05970                         (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
05971 #endif
05972                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05973 
05974                     }
05975     break;
05976 
05977   case 62:
05978 
05979 /* Line 1806 of yacc.c  */
05980 #line 1388 "ripper.y"
05981     {
05982 #if 0
05983                         block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
05984                         (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
05985                         (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
05986                         (yyval.val) = (yyvsp[(3) - (3)].val);
05987                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
05988 #endif
05989                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05990                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
05991 
05992                     }
05993     break;
05994 
05995   case 63:
05996 
05997 /* Line 1806 of yacc.c  */
05998 #line 1401 "ripper.y"
05999     {
06000 #if 0
06001                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06002                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
06003 #endif
06004                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06005 
06006                     }
06007     break;
06008 
06009   case 64:
06010 
06011 /* Line 1806 of yacc.c  */
06012 #line 1410 "ripper.y"
06013     {
06014 #if 0
06015                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
06016                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
06017                         (yyval.val) = (yyvsp[(5) - (5)].val);
06018                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06019 #endif
06020                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
06021                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
06022 
06023                    }
06024     break;
06025 
06026   case 65:
06027 
06028 /* Line 1806 of yacc.c  */
06029 #line 1422 "ripper.y"
06030     {
06031 #if 0
06032                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06033                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
06034 #endif
06035                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06036 
06037                     }
06038     break;
06039 
06040   case 66:
06041 
06042 /* Line 1806 of yacc.c  */
06043 #line 1431 "ripper.y"
06044     {
06045 #if 0
06046                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
06047                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
06048                         (yyval.val) = (yyvsp[(5) - (5)].val);
06049                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06050 #endif
06051                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
06052                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
06053 
06054                    }
06055     break;
06056 
06057   case 67:
06058 
06059 /* Line 1806 of yacc.c  */
06060 #line 1443 "ripper.y"
06061     {
06062 #if 0
06063                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
06064                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
06065 #endif
06066                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
06067 
06068                     }
06069     break;
06070 
06071   case 68:
06072 
06073 /* Line 1806 of yacc.c  */
06074 #line 1452 "ripper.y"
06075     {
06076 #if 0
06077                         (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
06078                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
06079 #endif
06080                         (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
06081 
06082                     }
06083     break;
06084 
06085   case 69:
06086 
06087 /* Line 1806 of yacc.c  */
06088 #line 1461 "ripper.y"
06089     {
06090 #if 0
06091                         (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
06092 #endif
06093                         (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
06094 
06095                     }
06096     break;
06097 
06098   case 70:
06099 
06100 /* Line 1806 of yacc.c  */
06101 #line 1469 "ripper.y"
06102     {
06103 #if 0
06104                         (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
06105 #endif
06106                         (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
06107 
06108                     }
06109     break;
06110 
06111   case 71:
06112 
06113 /* Line 1806 of yacc.c  */
06114 #line 1477 "ripper.y"
06115     {
06116 #if 0
06117                         (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
06118 #endif
06119                         (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
06120 
06121                     }
06122     break;
06123 
06124   case 73:
06125 
06126 /* Line 1806 of yacc.c  */
06127 #line 1488 "ripper.y"
06128     {
06129 #if 0
06130                         (yyval.val) = (yyvsp[(2) - (3)].val);
06131 #endif
06132                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06133 
06134                     }
06135     break;
06136 
06137   case 75:
06138 
06139 /* Line 1806 of yacc.c  */
06140 #line 1499 "ripper.y"
06141     {
06142 #if 0
06143                         (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
06144 #endif
06145                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06146 
06147                     }
06148     break;
06149 
06150   case 76:
06151 
06152 /* Line 1806 of yacc.c  */
06153 #line 1509 "ripper.y"
06154     {
06155 #if 0
06156                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
06157 #endif
06158                         (yyval.val) = (yyvsp[(1) - (1)].val);
06159 
06160                     }
06161     break;
06162 
06163   case 77:
06164 
06165 /* Line 1806 of yacc.c  */
06166 #line 1517 "ripper.y"
06167     {
06168 #if 0
06169                         (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
06170 #endif
06171                         (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
06172 
06173                     }
06174     break;
06175 
06176   case 78:
06177 
06178 /* Line 1806 of yacc.c  */
06179 #line 1525 "ripper.y"
06180     {
06181 #if 0
06182                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06183 #endif
06184                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06185 
06186                     }
06187     break;
06188 
06189   case 79:
06190 
06191 /* Line 1806 of yacc.c  */
06192 #line 1533 "ripper.y"
06193     {
06194 #if 0
06195                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
06196 #endif
06197                         (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06198                         (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
06199 
06200                     }
06201     break;
06202 
06203   case 80:
06204 
06205 /* Line 1806 of yacc.c  */
06206 #line 1542 "ripper.y"
06207     {
06208 #if 0
06209                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
06210 #endif
06211                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
06212 
06213                     }
06214     break;
06215 
06216   case 81:
06217 
06218 /* Line 1806 of yacc.c  */
06219 #line 1550 "ripper.y"
06220     {
06221 #if 0
06222                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
06223 #endif
06224                         (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
06225                         (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06226 
06227                     }
06228     break;
06229 
06230   case 82:
06231 
06232 /* Line 1806 of yacc.c  */
06233 #line 1559 "ripper.y"
06234     {
06235 #if 0
06236                         (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
06237 #endif
06238                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
06239 
06240                     }
06241     break;
06242 
06243   case 83:
06244 
06245 /* Line 1806 of yacc.c  */
06246 #line 1567 "ripper.y"
06247     {
06248 #if 0
06249                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
06250 #endif
06251                         (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
06252                         (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
06253 
06254                     }
06255     break;
06256 
06257   case 84:
06258 
06259 /* Line 1806 of yacc.c  */
06260 #line 1576 "ripper.y"
06261     {
06262 #if 0
06263                         (yyval.val) = NEW_MASGN(0, -1);
06264 #endif
06265                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06266 
06267                     }
06268     break;
06269 
06270   case 85:
06271 
06272 /* Line 1806 of yacc.c  */
06273 #line 1584 "ripper.y"
06274     {
06275 #if 0
06276                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
06277 #endif
06278                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06279                         (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
06280 
06281                     }
06282     break;
06283 
06284   case 87:
06285 
06286 /* Line 1806 of yacc.c  */
06287 #line 1596 "ripper.y"
06288     {
06289 #if 0
06290                         (yyval.val) = (yyvsp[(2) - (3)].val);
06291 #endif
06292                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06293 
06294                     }
06295     break;
06296 
06297   case 88:
06298 
06299 /* Line 1806 of yacc.c  */
06300 #line 1606 "ripper.y"
06301     {
06302 #if 0
06303                         (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
06304 #endif
06305                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
06306 
06307                     }
06308     break;
06309 
06310   case 89:
06311 
06312 /* Line 1806 of yacc.c  */
06313 #line 1614 "ripper.y"
06314     {
06315 #if 0
06316                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06317 #endif
06318                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06319 
06320                     }
06321     break;
06322 
06323   case 90:
06324 
06325 /* Line 1806 of yacc.c  */
06326 #line 1624 "ripper.y"
06327     {
06328 #if 0
06329                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
06330 #endif
06331                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
06332 
06333                     }
06334     break;
06335 
06336   case 91:
06337 
06338 /* Line 1806 of yacc.c  */
06339 #line 1632 "ripper.y"
06340     {
06341 #if 0
06342                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06343 #endif
06344                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06345 
06346                     }
06347     break;
06348 
06349   case 92:
06350 
06351 /* Line 1806 of yacc.c  */
06352 #line 1642 "ripper.y"
06353     {
06354                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06355                     }
06356     break;
06357 
06358   case 93:
06359 
06360 /* Line 1806 of yacc.c  */
06361 #line 1646 "ripper.y"
06362     {
06363                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06364                     }
06365     break;
06366 
06367   case 94:
06368 
06369 /* Line 1806 of yacc.c  */
06370 #line 1650 "ripper.y"
06371     {
06372 #if 0
06373                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06374 #endif
06375                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06376 
06377                     }
06378     break;
06379 
06380   case 95:
06381 
06382 /* Line 1806 of yacc.c  */
06383 #line 1658 "ripper.y"
06384     {
06385 #if 0
06386                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06387 #endif
06388                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06389 
06390                     }
06391     break;
06392 
06393   case 96:
06394 
06395 /* Line 1806 of yacc.c  */
06396 #line 1666 "ripper.y"
06397     {
06398 #if 0
06399                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06400 #endif
06401                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06402 
06403                     }
06404     break;
06405 
06406   case 97:
06407 
06408 /* Line 1806 of yacc.c  */
06409 #line 1674 "ripper.y"
06410     {
06411 #if 0
06412                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06413 #endif
06414                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06415 
06416                     }
06417     break;
06418 
06419   case 98:
06420 
06421 /* Line 1806 of yacc.c  */
06422 #line 1682 "ripper.y"
06423     {
06424 #if 0
06425                         if (in_def || in_single)
06426                             yyerror("dynamic constant assignment");
06427                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06428 #endif
06429                         if (in_def || in_single)
06430                             yyerror("dynamic constant assignment");
06431                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06432 
06433                     }
06434     break;
06435 
06436   case 99:
06437 
06438 /* Line 1806 of yacc.c  */
06439 #line 1694 "ripper.y"
06440     {
06441 #if 0
06442                         if (in_def || in_single)
06443                             yyerror("dynamic constant assignment");
06444                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06445 #endif
06446                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06447 
06448                     }
06449     break;
06450 
06451   case 100:
06452 
06453 /* Line 1806 of yacc.c  */
06454 #line 1704 "ripper.y"
06455     {
06456 #if 0
06457                         rb_backref_error((yyvsp[(1) - (1)].val));
06458                         (yyval.val) = NEW_BEGIN(0);
06459 #endif
06460                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
06461                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06462 
06463                     }
06464     break;
06465 
06466   case 101:
06467 
06468 /* Line 1806 of yacc.c  */
06469 #line 1716 "ripper.y"
06470     {
06471                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06472 #if 0
06473                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06474 #endif
06475                         (yyval.val) = dispatch1(var_field, (yyval.val));
06476 
06477                     }
06478     break;
06479 
06480   case 102:
06481 
06482 /* Line 1806 of yacc.c  */
06483 #line 1725 "ripper.y"
06484     {
06485                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06486 #if 0
06487                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06488 #endif
06489                         (yyval.val) = dispatch1(var_field, (yyval.val));
06490 
06491                     }
06492     break;
06493 
06494   case 103:
06495 
06496 /* Line 1806 of yacc.c  */
06497 #line 1734 "ripper.y"
06498     {
06499 #if 0
06500                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06501 #endif
06502                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06503 
06504                     }
06505     break;
06506 
06507   case 104:
06508 
06509 /* Line 1806 of yacc.c  */
06510 #line 1742 "ripper.y"
06511     {
06512 #if 0
06513                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06514 #endif
06515                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06516 
06517                     }
06518     break;
06519 
06520   case 105:
06521 
06522 /* Line 1806 of yacc.c  */
06523 #line 1750 "ripper.y"
06524     {
06525 #if 0
06526                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06527 #endif
06528                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
06529 
06530                     }
06531     break;
06532 
06533   case 106:
06534 
06535 /* Line 1806 of yacc.c  */
06536 #line 1758 "ripper.y"
06537     {
06538 #if 0
06539                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06540 #endif
06541                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06542 
06543                     }
06544     break;
06545 
06546   case 107:
06547 
06548 /* Line 1806 of yacc.c  */
06549 #line 1766 "ripper.y"
06550     {
06551 #if 0
06552                         if (in_def || in_single)
06553                             yyerror("dynamic constant assignment");
06554                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06555 #endif
06556                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06557                         if (in_def || in_single) {
06558                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06559                         }
06560 
06561                     }
06562     break;
06563 
06564   case 108:
06565 
06566 /* Line 1806 of yacc.c  */
06567 #line 1779 "ripper.y"
06568     {
06569 #if 0
06570                         if (in_def || in_single)
06571                             yyerror("dynamic constant assignment");
06572                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06573 #endif
06574                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06575                         if (in_def || in_single) {
06576                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06577                         }
06578 
06579                     }
06580     break;
06581 
06582   case 109:
06583 
06584 /* Line 1806 of yacc.c  */
06585 #line 1792 "ripper.y"
06586     {
06587 #if 0
06588                         rb_backref_error((yyvsp[(1) - (1)].val));
06589                         (yyval.val) = NEW_BEGIN(0);
06590 #endif
06591                         (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
06592 
06593                     }
06594     break;
06595 
06596   case 110:
06597 
06598 /* Line 1806 of yacc.c  */
06599 #line 1803 "ripper.y"
06600     {
06601 #if 0
06602                         yyerror("class/module name must be CONSTANT");
06603 #endif
06604                         (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
06605 
06606                     }
06607     break;
06608 
06609   case 112:
06610 
06611 /* Line 1806 of yacc.c  */
06612 #line 1814 "ripper.y"
06613     {
06614 #if 0
06615                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
06616 #endif
06617                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
06618 
06619                     }
06620     break;
06621 
06622   case 113:
06623 
06624 /* Line 1806 of yacc.c  */
06625 #line 1822 "ripper.y"
06626     {
06627 #if 0
06628                         (yyval.val) = NEW_COLON2(0, (yyval.val));
06629 #endif
06630                         (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
06631 
06632                     }
06633     break;
06634 
06635   case 114:
06636 
06637 /* Line 1806 of yacc.c  */
06638 #line 1830 "ripper.y"
06639     {
06640 #if 0
06641                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06642 #endif
06643                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06644 
06645                     }
06646     break;
06647 
06648   case 118:
06649 
06650 /* Line 1806 of yacc.c  */
06651 #line 1843 "ripper.y"
06652     {
06653                         lex_state = EXPR_ENDFN;
06654                         (yyval.val) = (yyvsp[(1) - (1)].val);
06655                     }
06656     break;
06657 
06658   case 119:
06659 
06660 /* Line 1806 of yacc.c  */
06661 #line 1848 "ripper.y"
06662     {
06663                         lex_state = EXPR_ENDFN;
06664 #if 0
06665                         (yyval.val) = (yyvsp[(1) - (1)].id);
06666 #endif
06667                         (yyval.val) = (yyvsp[(1) - (1)].val);
06668 
06669                     }
06670     break;
06671 
06672   case 122:
06673 
06674 /* Line 1806 of yacc.c  */
06675 #line 1863 "ripper.y"
06676     {
06677 #if 0
06678                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
06679 #endif
06680                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
06681 
06682                     }
06683     break;
06684 
06685   case 124:
06686 
06687 /* Line 1806 of yacc.c  */
06688 #line 1874 "ripper.y"
06689     {
06690 #if 0
06691                         (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
06692 #endif
06693                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
06694 
06695                     }
06696     break;
06697 
06698   case 125:
06699 
06700 /* Line 1806 of yacc.c  */
06701 #line 1881 "ripper.y"
06702     {lex_state = EXPR_FNAME;}
06703     break;
06704 
06705   case 126:
06706 
06707 /* Line 1806 of yacc.c  */
06708 #line 1882 "ripper.y"
06709     {
06710 #if 0
06711                         (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
06712 #endif
06713                         rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06714 
06715                     }
06716     break;
06717 
06718   case 127:
06719 
06720 /* Line 1806 of yacc.c  */
06721 #line 1891 "ripper.y"
06722     { ifndef_ripper((yyval.val) = '|'); }
06723     break;
06724 
06725   case 128:
06726 
06727 /* Line 1806 of yacc.c  */
06728 #line 1892 "ripper.y"
06729     { ifndef_ripper((yyval.val) = '^'); }
06730     break;
06731 
06732   case 129:
06733 
06734 /* Line 1806 of yacc.c  */
06735 #line 1893 "ripper.y"
06736     { ifndef_ripper((yyval.val) = '&'); }
06737     break;
06738 
06739   case 130:
06740 
06741 /* Line 1806 of yacc.c  */
06742 #line 1894 "ripper.y"
06743     { ifndef_ripper((yyval.val) = tCMP); }
06744     break;
06745 
06746   case 131:
06747 
06748 /* Line 1806 of yacc.c  */
06749 #line 1895 "ripper.y"
06750     { ifndef_ripper((yyval.val) = tEQ); }
06751     break;
06752 
06753   case 132:
06754 
06755 /* Line 1806 of yacc.c  */
06756 #line 1896 "ripper.y"
06757     { ifndef_ripper((yyval.val) = tEQQ); }
06758     break;
06759 
06760   case 133:
06761 
06762 /* Line 1806 of yacc.c  */
06763 #line 1897 "ripper.y"
06764     { ifndef_ripper((yyval.val) = tMATCH); }
06765     break;
06766 
06767   case 134:
06768 
06769 /* Line 1806 of yacc.c  */
06770 #line 1898 "ripper.y"
06771     { ifndef_ripper((yyval.val) = tNMATCH); }
06772     break;
06773 
06774   case 135:
06775 
06776 /* Line 1806 of yacc.c  */
06777 #line 1899 "ripper.y"
06778     { ifndef_ripper((yyval.val) = '>'); }
06779     break;
06780 
06781   case 136:
06782 
06783 /* Line 1806 of yacc.c  */
06784 #line 1900 "ripper.y"
06785     { ifndef_ripper((yyval.val) = tGEQ); }
06786     break;
06787 
06788   case 137:
06789 
06790 /* Line 1806 of yacc.c  */
06791 #line 1901 "ripper.y"
06792     { ifndef_ripper((yyval.val) = '<'); }
06793     break;
06794 
06795   case 138:
06796 
06797 /* Line 1806 of yacc.c  */
06798 #line 1902 "ripper.y"
06799     { ifndef_ripper((yyval.val) = tLEQ); }
06800     break;
06801 
06802   case 139:
06803 
06804 /* Line 1806 of yacc.c  */
06805 #line 1903 "ripper.y"
06806     { ifndef_ripper((yyval.val) = tNEQ); }
06807     break;
06808 
06809   case 140:
06810 
06811 /* Line 1806 of yacc.c  */
06812 #line 1904 "ripper.y"
06813     { ifndef_ripper((yyval.val) = tLSHFT); }
06814     break;
06815 
06816   case 141:
06817 
06818 /* Line 1806 of yacc.c  */
06819 #line 1905 "ripper.y"
06820     { ifndef_ripper((yyval.val) = tRSHFT); }
06821     break;
06822 
06823   case 142:
06824 
06825 /* Line 1806 of yacc.c  */
06826 #line 1906 "ripper.y"
06827     { ifndef_ripper((yyval.val) = '+'); }
06828     break;
06829 
06830   case 143:
06831 
06832 /* Line 1806 of yacc.c  */
06833 #line 1907 "ripper.y"
06834     { ifndef_ripper((yyval.val) = '-'); }
06835     break;
06836 
06837   case 144:
06838 
06839 /* Line 1806 of yacc.c  */
06840 #line 1908 "ripper.y"
06841     { ifndef_ripper((yyval.val) = '*'); }
06842     break;
06843 
06844   case 145:
06845 
06846 /* Line 1806 of yacc.c  */
06847 #line 1909 "ripper.y"
06848     { ifndef_ripper((yyval.val) = '*'); }
06849     break;
06850 
06851   case 146:
06852 
06853 /* Line 1806 of yacc.c  */
06854 #line 1910 "ripper.y"
06855     { ifndef_ripper((yyval.val) = '/'); }
06856     break;
06857 
06858   case 147:
06859 
06860 /* Line 1806 of yacc.c  */
06861 #line 1911 "ripper.y"
06862     { ifndef_ripper((yyval.val) = '%'); }
06863     break;
06864 
06865   case 148:
06866 
06867 /* Line 1806 of yacc.c  */
06868 #line 1912 "ripper.y"
06869     { ifndef_ripper((yyval.val) = tPOW); }
06870     break;
06871 
06872   case 149:
06873 
06874 /* Line 1806 of yacc.c  */
06875 #line 1913 "ripper.y"
06876     { ifndef_ripper((yyval.val) = tDSTAR); }
06877     break;
06878 
06879   case 150:
06880 
06881 /* Line 1806 of yacc.c  */
06882 #line 1914 "ripper.y"
06883     { ifndef_ripper((yyval.val) = '!'); }
06884     break;
06885 
06886   case 151:
06887 
06888 /* Line 1806 of yacc.c  */
06889 #line 1915 "ripper.y"
06890     { ifndef_ripper((yyval.val) = '~'); }
06891     break;
06892 
06893   case 152:
06894 
06895 /* Line 1806 of yacc.c  */
06896 #line 1916 "ripper.y"
06897     { ifndef_ripper((yyval.val) = tUPLUS); }
06898     break;
06899 
06900   case 153:
06901 
06902 /* Line 1806 of yacc.c  */
06903 #line 1917 "ripper.y"
06904     { ifndef_ripper((yyval.val) = tUMINUS); }
06905     break;
06906 
06907   case 154:
06908 
06909 /* Line 1806 of yacc.c  */
06910 #line 1918 "ripper.y"
06911     { ifndef_ripper((yyval.val) = tAREF); }
06912     break;
06913 
06914   case 155:
06915 
06916 /* Line 1806 of yacc.c  */
06917 #line 1919 "ripper.y"
06918     { ifndef_ripper((yyval.val) = tASET); }
06919     break;
06920 
06921   case 156:
06922 
06923 /* Line 1806 of yacc.c  */
06924 #line 1920 "ripper.y"
06925     { ifndef_ripper((yyval.val) = '`'); }
06926     break;
06927 
06928   case 198:
06929 
06930 /* Line 1806 of yacc.c  */
06931 #line 1938 "ripper.y"
06932     {
06933 #if 0
06934                         value_expr((yyvsp[(3) - (3)].val));
06935                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06936 #endif
06937                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06938 
06939                     }
06940     break;
06941 
06942   case 199:
06943 
06944 /* Line 1806 of yacc.c  */
06945 #line 1947 "ripper.y"
06946     {
06947 #if 0
06948                         value_expr((yyvsp[(3) - (5)].val));
06949                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06950                         (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06951 #endif
06952                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
06953 
06954                     }
06955     break;
06956 
06957   case 200:
06958 
06959 /* Line 1806 of yacc.c  */
06960 #line 1957 "ripper.y"
06961     {
06962                         value_expr((yyvsp[(3) - (3)].val));
06963                         (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06964                     }
06965     break;
06966 
06967   case 201:
06968 
06969 /* Line 1806 of yacc.c  */
06970 #line 1962 "ripper.y"
06971     {
06972 #if 0
06973                         value_expr((yyvsp[(3) - (5)].val));
06974                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06975 #endif
06976                         (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
06977 
06978                         (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
06979                     }
06980     break;
06981 
06982   case 202:
06983 
06984 /* Line 1806 of yacc.c  */
06985 #line 1972 "ripper.y"
06986     {
06987 #if 0
06988                         NODE *args;
06989 
06990                         value_expr((yyvsp[(6) - (6)].val));
06991                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
06992                         if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
06993                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06994                         }
06995                         else {
06996                             args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06997                         }
06998                         if ((yyvsp[(5) - (6)].val) == tOROP) {
06999                             (yyvsp[(5) - (6)].val) = 0;
07000                         }
07001                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
07002                             (yyvsp[(5) - (6)].val) = 1;
07003                         }
07004                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
07005                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07006 #endif
07007                         (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
07008                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
07009 
07010                     }
07011     break;
07012 
07013   case 203:
07014 
07015 /* Line 1806 of yacc.c  */
07016 #line 1998 "ripper.y"
07017     {
07018                         value_expr((yyvsp[(5) - (5)].val));
07019                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
07020                     }
07021     break;
07022 
07023   case 204:
07024 
07025 /* Line 1806 of yacc.c  */
07026 #line 2003 "ripper.y"
07027     {
07028                         value_expr((yyvsp[(5) - (5)].val));
07029                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
07030                     }
07031     break;
07032 
07033   case 205:
07034 
07035 /* Line 1806 of yacc.c  */
07036 #line 2008 "ripper.y"
07037     {
07038                         value_expr((yyvsp[(5) - (5)].val));
07039                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
07040                     }
07041     break;
07042 
07043   case 206:
07044 
07045 /* Line 1806 of yacc.c  */
07046 #line 2013 "ripper.y"
07047     {
07048 #if 0
07049                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
07050                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
07051 #endif
07052                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
07053                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
07054 
07055                     }
07056     break;
07057 
07058   case 207:
07059 
07060 /* Line 1806 of yacc.c  */
07061 #line 2023 "ripper.y"
07062     {
07063 #if 0
07064                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
07065                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
07066 #endif
07067                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
07068                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
07069 
07070                     }
07071     break;
07072 
07073   case 208:
07074 
07075 /* Line 1806 of yacc.c  */
07076 #line 2033 "ripper.y"
07077     {
07078 #if 0
07079                         rb_backref_error((yyvsp[(1) - (3)].val));
07080                         (yyval.val) = NEW_BEGIN(0);
07081 #endif
07082                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
07083                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
07084                         (yyval.val) = dispatch1(assign_error, (yyval.val));
07085 
07086                     }
07087     break;
07088 
07089   case 209:
07090 
07091 /* Line 1806 of yacc.c  */
07092 #line 2044 "ripper.y"
07093     {
07094 #if 0
07095                         value_expr((yyvsp[(1) - (3)].val));
07096                         value_expr((yyvsp[(3) - (3)].val));
07097                         (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07098                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
07099                             (yyvsp[(3) - (3)].val) && nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
07100                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
07101                         }
07102 #endif
07103                         (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07104 
07105                     }
07106     break;
07107 
07108   case 210:
07109 
07110 /* Line 1806 of yacc.c  */
07111 #line 2058 "ripper.y"
07112     {
07113 #if 0
07114                         value_expr((yyvsp[(1) - (3)].val));
07115                         value_expr((yyvsp[(3) - (3)].val));
07116                         (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07117                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
07118                             (yyvsp[(3) - (3)].val) && nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
07119                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
07120                         }
07121 #endif
07122                         (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07123 
07124                     }
07125     break;
07126 
07127   case 211:
07128 
07129 /* Line 1806 of yacc.c  */
07130 #line 2072 "ripper.y"
07131     {
07132 #if 0
07133                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
07134 #endif
07135                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
07136 
07137                     }
07138     break;
07139 
07140   case 212:
07141 
07142 /* Line 1806 of yacc.c  */
07143 #line 2080 "ripper.y"
07144     {
07145 #if 0
07146                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
07147 #endif
07148                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
07149 
07150                     }
07151     break;
07152 
07153   case 213:
07154 
07155 /* Line 1806 of yacc.c  */
07156 #line 2088 "ripper.y"
07157     {
07158 #if 0
07159                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
07160 #endif
07161                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
07162 
07163                     }
07164     break;
07165 
07166   case 214:
07167 
07168 /* Line 1806 of yacc.c  */
07169 #line 2096 "ripper.y"
07170     {
07171 #if 0
07172                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
07173 #endif
07174                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
07175 
07176                     }
07177     break;
07178 
07179   case 215:
07180 
07181 /* Line 1806 of yacc.c  */
07182 #line 2104 "ripper.y"
07183     {
07184 #if 0
07185                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
07186 #endif
07187                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
07188 
07189                     }
07190     break;
07191 
07192   case 216:
07193 
07194 /* Line 1806 of yacc.c  */
07195 #line 2112 "ripper.y"
07196     {
07197 #if 0
07198                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
07199 #endif
07200                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
07201 
07202                     }
07203     break;
07204 
07205   case 217:
07206 
07207 /* Line 1806 of yacc.c  */
07208 #line 2120 "ripper.y"
07209     {
07210 #if 0
07211                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
07212 #endif
07213                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
07214                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
07215 
07216                     }
07217     break;
07218 
07219   case 218:
07220 
07221 /* Line 1806 of yacc.c  */
07222 #line 2129 "ripper.y"
07223     {
07224 #if 0
07225                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
07226 #endif
07227                         (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
07228 
07229                     }
07230     break;
07231 
07232   case 219:
07233 
07234 /* Line 1806 of yacc.c  */
07235 #line 2137 "ripper.y"
07236     {
07237 #if 0
07238                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
07239 #endif
07240                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
07241 
07242                     }
07243     break;
07244 
07245   case 220:
07246 
07247 /* Line 1806 of yacc.c  */
07248 #line 2145 "ripper.y"
07249     {
07250 #if 0
07251                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
07252 #endif
07253                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
07254 
07255                     }
07256     break;
07257 
07258   case 221:
07259 
07260 /* Line 1806 of yacc.c  */
07261 #line 2153 "ripper.y"
07262     {
07263 #if 0
07264                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
07265 #endif
07266                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
07267 
07268                     }
07269     break;
07270 
07271   case 222:
07272 
07273 /* Line 1806 of yacc.c  */
07274 #line 2161 "ripper.y"
07275     {
07276 #if 0
07277                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
07278 #endif
07279                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
07280 
07281                     }
07282     break;
07283 
07284   case 223:
07285 
07286 /* Line 1806 of yacc.c  */
07287 #line 2169 "ripper.y"
07288     {
07289 #if 0
07290                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
07291 #endif
07292                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
07293 
07294                     }
07295     break;
07296 
07297   case 224:
07298 
07299 /* Line 1806 of yacc.c  */
07300 #line 2177 "ripper.y"
07301     {
07302 #if 0
07303                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
07304 #endif
07305                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
07306 
07307                     }
07308     break;
07309 
07310   case 225:
07311 
07312 /* Line 1806 of yacc.c  */
07313 #line 2185 "ripper.y"
07314     {
07315 #if 0
07316                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
07317 #endif
07318                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
07319 
07320                     }
07321     break;
07322 
07323   case 226:
07324 
07325 /* Line 1806 of yacc.c  */
07326 #line 2193 "ripper.y"
07327     {
07328 #if 0
07329                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
07330 #endif
07331                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
07332 
07333                     }
07334     break;
07335 
07336   case 227:
07337 
07338 /* Line 1806 of yacc.c  */
07339 #line 2201 "ripper.y"
07340     {
07341 #if 0
07342                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
07343 #endif
07344                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
07345 
07346                     }
07347     break;
07348 
07349   case 228:
07350 
07351 /* Line 1806 of yacc.c  */
07352 #line 2209 "ripper.y"
07353     {
07354 #if 0
07355                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
07356 #endif
07357                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
07358 
07359                     }
07360     break;
07361 
07362   case 229:
07363 
07364 /* Line 1806 of yacc.c  */
07365 #line 2217 "ripper.y"
07366     {
07367 #if 0
07368                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
07369 #endif
07370                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
07371 
07372                     }
07373     break;
07374 
07375   case 230:
07376 
07377 /* Line 1806 of yacc.c  */
07378 #line 2225 "ripper.y"
07379     {
07380 #if 0
07381                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
07382 #endif
07383                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
07384 
07385                     }
07386     break;
07387 
07388   case 231:
07389 
07390 /* Line 1806 of yacc.c  */
07391 #line 2233 "ripper.y"
07392     {
07393 #if 0
07394                         (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07395                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
07396                             (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
07397                         }
07398 #endif
07399                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
07400 
07401                     }
07402     break;
07403 
07404   case 232:
07405 
07406 /* Line 1806 of yacc.c  */
07407 #line 2244 "ripper.y"
07408     {
07409 #if 0
07410                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
07411 #endif
07412                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
07413 
07414                     }
07415     break;
07416 
07417   case 233:
07418 
07419 /* Line 1806 of yacc.c  */
07420 #line 2252 "ripper.y"
07421     {
07422 #if 0
07423                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
07424 #endif
07425                         (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
07426 
07427                     }
07428     break;
07429 
07430   case 234:
07431 
07432 /* Line 1806 of yacc.c  */
07433 #line 2260 "ripper.y"
07434     {
07435 #if 0
07436                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
07437 #endif
07438                         (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
07439 
07440                     }
07441     break;
07442 
07443   case 235:
07444 
07445 /* Line 1806 of yacc.c  */
07446 #line 2268 "ripper.y"
07447     {
07448 #if 0
07449                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
07450 #endif
07451                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
07452 
07453                     }
07454     break;
07455 
07456   case 236:
07457 
07458 /* Line 1806 of yacc.c  */
07459 #line 2276 "ripper.y"
07460     {
07461 #if 0
07462                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
07463 #endif
07464                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
07465 
07466                     }
07467     break;
07468 
07469   case 237:
07470 
07471 /* Line 1806 of yacc.c  */
07472 #line 2284 "ripper.y"
07473     {
07474 #if 0
07475                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07476 #endif
07477                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
07478 
07479                     }
07480     break;
07481 
07482   case 238:
07483 
07484 /* Line 1806 of yacc.c  */
07485 #line 2292 "ripper.y"
07486     {
07487 #if 0
07488                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07489 #endif
07490                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
07491 
07492                     }
07493     break;
07494 
07495   case 239:
07496 
07497 /* Line 1806 of yacc.c  */
07498 #line 2299 "ripper.y"
07499     {in_defined = 1;}
07500     break;
07501 
07502   case 240:
07503 
07504 /* Line 1806 of yacc.c  */
07505 #line 2300 "ripper.y"
07506     {
07507 #if 0
07508                         in_defined = 0;
07509                         (yyval.val) = new_defined((yyvsp[(4) - (4)].val));
07510 #endif
07511                         in_defined = 0;
07512                         (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
07513 
07514                     }
07515     break;
07516 
07517   case 241:
07518 
07519 /* Line 1806 of yacc.c  */
07520 #line 2310 "ripper.y"
07521     {
07522 #if 0
07523                         value_expr((yyvsp[(1) - (6)].val));
07524                         (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07525                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07526 #endif
07527                         (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07528 
07529                     }
07530     break;
07531 
07532   case 242:
07533 
07534 /* Line 1806 of yacc.c  */
07535 #line 2320 "ripper.y"
07536     {
07537                         (yyval.val) = (yyvsp[(1) - (1)].val);
07538                     }
07539     break;
07540 
07541   case 243:
07542 
07543 /* Line 1806 of yacc.c  */
07544 #line 2326 "ripper.y"
07545     {
07546 #if 0
07547                         value_expr((yyvsp[(1) - (1)].val));
07548                         (yyval.val) = (yyvsp[(1) - (1)].val);
07549                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
07550 #endif
07551                         (yyval.val) = (yyvsp[(1) - (1)].val);
07552 
07553                     }
07554     break;
07555 
07556   case 245:
07557 
07558 /* Line 1806 of yacc.c  */
07559 #line 2339 "ripper.y"
07560     {
07561                         (yyval.val) = (yyvsp[(1) - (2)].val);
07562                     }
07563     break;
07564 
07565   case 246:
07566 
07567 /* Line 1806 of yacc.c  */
07568 #line 2343 "ripper.y"
07569     {
07570 #if 0
07571                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07572 #endif
07573                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07574 
07575                     }
07576     break;
07577 
07578   case 247:
07579 
07580 /* Line 1806 of yacc.c  */
07581 #line 2351 "ripper.y"
07582     {
07583 #if 0
07584                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07585 #endif
07586                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07587 
07588                     }
07589     break;
07590 
07591   case 248:
07592 
07593 /* Line 1806 of yacc.c  */
07594 #line 2361 "ripper.y"
07595     {
07596 #if 0
07597                         (yyval.val) = (yyvsp[(2) - (3)].val);
07598 #endif
07599                         (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
07600 
07601                     }
07602     break;
07603 
07604   case 253:
07605 
07606 /* Line 1806 of yacc.c  */
07607 #line 2377 "ripper.y"
07608     {
07609                       (yyval.val) = (yyvsp[(1) - (2)].val);
07610                     }
07611     break;
07612 
07613   case 254:
07614 
07615 /* Line 1806 of yacc.c  */
07616 #line 2381 "ripper.y"
07617     {
07618 #if 0
07619                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07620 #endif
07621                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07622 
07623                     }
07624     break;
07625 
07626   case 255:
07627 
07628 /* Line 1806 of yacc.c  */
07629 #line 2389 "ripper.y"
07630     {
07631 #if 0
07632                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07633 #endif
07634                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07635 
07636                     }
07637     break;
07638 
07639   case 256:
07640 
07641 /* Line 1806 of yacc.c  */
07642 #line 2399 "ripper.y"
07643     {
07644 #if 0
07645                         value_expr((yyvsp[(1) - (1)].val));
07646                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07647 #endif
07648                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07649 
07650                     }
07651     break;
07652 
07653   case 257:
07654 
07655 /* Line 1806 of yacc.c  */
07656 #line 2408 "ripper.y"
07657     {
07658 #if 0
07659                         (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07660 #endif
07661                         (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07662 
07663                     }
07664     break;
07665 
07666   case 258:
07667 
07668 /* Line 1806 of yacc.c  */
07669 #line 2416 "ripper.y"
07670     {
07671 #if 0
07672                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07673                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
07674 #endif
07675                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07676                         (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
07677 
07678                     }
07679     break;
07680 
07681   case 259:
07682 
07683 /* Line 1806 of yacc.c  */
07684 #line 2426 "ripper.y"
07685     {
07686 #if 0
07687                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07688                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
07689 #endif
07690                         (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
07691 
07692                     }
07693     break;
07694 
07695   case 260:
07696 
07697 /* Line 1806 of yacc.c  */
07698 #line 2437 "ripper.y"
07699     {
07700                         (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
07701                     }
07702     break;
07703 
07704   case 261:
07705 
07706 /* Line 1806 of yacc.c  */
07707 #line 2443 "ripper.y"
07708     {
07709                         (yyval.val) = cmdarg_stack;
07710                         CMDARG_PUSH(1);
07711                     }
07712     break;
07713 
07714   case 262:
07715 
07716 /* Line 1806 of yacc.c  */
07717 #line 2448 "ripper.y"
07718     {
07719                         /* CMDARG_POP() */
07720                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07721                         (yyval.val) = (yyvsp[(2) - (2)].val);
07722                     }
07723     break;
07724 
07725   case 263:
07726 
07727 /* Line 1806 of yacc.c  */
07728 #line 2456 "ripper.y"
07729     {
07730 #if 0
07731                         (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
07732 #endif
07733                         (yyval.val) = (yyvsp[(2) - (2)].val);
07734 
07735                     }
07736     break;
07737 
07738   case 264:
07739 
07740 /* Line 1806 of yacc.c  */
07741 #line 2466 "ripper.y"
07742     {
07743                         (yyval.val) = (yyvsp[(2) - (2)].val);
07744                     }
07745     break;
07746 
07747   case 265:
07748 
07749 /* Line 1806 of yacc.c  */
07750 #line 2470 "ripper.y"
07751     {
07752                         (yyval.val) = 0;
07753                     }
07754     break;
07755 
07756   case 266:
07757 
07758 /* Line 1806 of yacc.c  */
07759 #line 2476 "ripper.y"
07760     {
07761 #if 0
07762                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07763 #endif
07764                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07765 
07766                     }
07767     break;
07768 
07769   case 267:
07770 
07771 /* Line 1806 of yacc.c  */
07772 #line 2484 "ripper.y"
07773     {
07774 #if 0
07775                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07776 #endif
07777                         (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
07778 
07779                     }
07780     break;
07781 
07782   case 268:
07783 
07784 /* Line 1806 of yacc.c  */
07785 #line 2492 "ripper.y"
07786     {
07787 #if 0
07788                         NODE *n1;
07789                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07790                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07791                         }
07792                         else {
07793                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07794                         }
07795 #endif
07796                         (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07797 
07798                     }
07799     break;
07800 
07801   case 269:
07802 
07803 /* Line 1806 of yacc.c  */
07804 #line 2506 "ripper.y"
07805     {
07806 #if 0
07807                         NODE *n1;
07808                         if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07809                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07810                         }
07811                         else {
07812                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07813                         }
07814 #endif
07815                         (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07816 
07817                     }
07818     break;
07819 
07820   case 272:
07821 
07822 /* Line 1806 of yacc.c  */
07823 #line 2526 "ripper.y"
07824     {
07825 #if 0
07826                         NODE *n1;
07827                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07828                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07829                         }
07830                         else {
07831                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07832                         }
07833 #endif
07834                         (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
07835 
07836                     }
07837     break;
07838 
07839   case 273:
07840 
07841 /* Line 1806 of yacc.c  */
07842 #line 2540 "ripper.y"
07843     {
07844 #if 0
07845                         NODE *n1;
07846                         if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
07847                             (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07848                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07849                         }
07850                         else {
07851                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07852                         }
07853 #endif
07854                         (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
07855 
07856                     }
07857     break;
07858 
07859   case 274:
07860 
07861 /* Line 1806 of yacc.c  */
07862 #line 2555 "ripper.y"
07863     {
07864 #if 0
07865                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07866 #endif
07867                         (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
07868 
07869                     }
07870     break;
07871 
07872   case 285:
07873 
07874 /* Line 1806 of yacc.c  */
07875 #line 2575 "ripper.y"
07876     {
07877 #if 0
07878                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
07879 #endif
07880                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
07881 
07882                     }
07883     break;
07884 
07885   case 286:
07886 
07887 /* Line 1806 of yacc.c  */
07888 #line 2583 "ripper.y"
07889     {
07890                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07891                         cmdarg_stack = 0;
07892 #if 0
07893                         (yyval.num) = ruby_sourceline;
07894 #endif
07895 
07896                     }
07897     break;
07898 
07899   case 287:
07900 
07901 /* Line 1806 of yacc.c  */
07902 #line 2593 "ripper.y"
07903     {
07904                         cmdarg_stack = (yyvsp[(1) - (4)].val);
07905 #if 0
07906                         if ((yyvsp[(3) - (4)].val) == NULL) {
07907                             (yyval.val) = NEW_NIL();
07908                         }
07909                         else {
07910                             if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
07911                                 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
07912                                 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
07913                             (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
07914                         }
07915                         nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
07916 #endif
07917                         (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
07918 
07919                     }
07920     break;
07921 
07922   case 288:
07923 
07924 /* Line 1806 of yacc.c  */
07925 #line 2610 "ripper.y"
07926     {lex_state = EXPR_ENDARG;}
07927     break;
07928 
07929   case 289:
07930 
07931 /* Line 1806 of yacc.c  */
07932 #line 2611 "ripper.y"
07933     {
07934 #if 0
07935                         (yyval.val) = 0;
07936 #endif
07937                         (yyval.val) = dispatch1(paren, 0);
07938 
07939                     }
07940     break;
07941 
07942   case 290:
07943 
07944 /* Line 1806 of yacc.c  */
07945 #line 2619 "ripper.y"
07946     {
07947                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07948                         cmdarg_stack = 0;
07949                     }
07950     break;
07951 
07952   case 291:
07953 
07954 /* Line 1806 of yacc.c  */
07955 #line 2623 "ripper.y"
07956     {lex_state = EXPR_ENDARG;}
07957     break;
07958 
07959   case 292:
07960 
07961 /* Line 1806 of yacc.c  */
07962 #line 2624 "ripper.y"
07963     {
07964                         cmdarg_stack = (yyvsp[(1) - (5)].val);
07965 #if 0
07966                         (yyval.val) = (yyvsp[(3) - (5)].val);
07967 #endif
07968                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val));
07969 
07970                     }
07971     break;
07972 
07973   case 293:
07974 
07975 /* Line 1806 of yacc.c  */
07976 #line 2633 "ripper.y"
07977     {
07978 #if 0
07979                         (yyval.val) = (yyvsp[(2) - (3)].val);
07980 #endif
07981                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
07982 
07983                     }
07984     break;
07985 
07986   case 294:
07987 
07988 /* Line 1806 of yacc.c  */
07989 #line 2641 "ripper.y"
07990     {
07991 #if 0
07992                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07993 #endif
07994                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07995 
07996                     }
07997     break;
07998 
07999   case 295:
08000 
08001 /* Line 1806 of yacc.c  */
08002 #line 2649 "ripper.y"
08003     {
08004 #if 0
08005                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
08006 #endif
08007                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
08008 
08009                     }
08010     break;
08011 
08012   case 296:
08013 
08014 /* Line 1806 of yacc.c  */
08015 #line 2657 "ripper.y"
08016     {
08017 #if 0
08018                         if ((yyvsp[(2) - (3)].val) == 0) {
08019                             (yyval.val) = NEW_ZARRAY(); /* zero length array*/
08020                         }
08021                         else {
08022                             (yyval.val) = (yyvsp[(2) - (3)].val);
08023                         }
08024 #endif
08025                         (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
08026 
08027                     }
08028     break;
08029 
08030   case 297:
08031 
08032 /* Line 1806 of yacc.c  */
08033 #line 2670 "ripper.y"
08034     {
08035 #if 0
08036                         (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
08037 #endif
08038                         (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
08039 
08040                     }
08041     break;
08042 
08043   case 298:
08044 
08045 /* Line 1806 of yacc.c  */
08046 #line 2678 "ripper.y"
08047     {
08048 #if 0
08049                         (yyval.val) = NEW_RETURN(0);
08050 #endif
08051                         (yyval.val) = dispatch0(return0);
08052 
08053                     }
08054     break;
08055 
08056   case 299:
08057 
08058 /* Line 1806 of yacc.c  */
08059 #line 2686 "ripper.y"
08060     {
08061 #if 0
08062                         (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
08063 #endif
08064                         (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
08065 
08066                     }
08067     break;
08068 
08069   case 300:
08070 
08071 /* Line 1806 of yacc.c  */
08072 #line 2694 "ripper.y"
08073     {
08074 #if 0
08075                         (yyval.val) = NEW_YIELD(0);
08076 #endif
08077                         (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
08078 
08079                     }
08080     break;
08081 
08082   case 301:
08083 
08084 /* Line 1806 of yacc.c  */
08085 #line 2702 "ripper.y"
08086     {
08087 #if 0
08088                         (yyval.val) = NEW_YIELD(0);
08089 #endif
08090                         (yyval.val) = dispatch0(yield0);
08091 
08092                     }
08093     break;
08094 
08095   case 302:
08096 
08097 /* Line 1806 of yacc.c  */
08098 #line 2709 "ripper.y"
08099     {in_defined = 1;}
08100     break;
08101 
08102   case 303:
08103 
08104 /* Line 1806 of yacc.c  */
08105 #line 2710 "ripper.y"
08106     {
08107 #if 0
08108                         in_defined = 0;
08109                         (yyval.val) = new_defined((yyvsp[(5) - (6)].val));
08110 #endif
08111                         in_defined = 0;
08112                         (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
08113 
08114                     }
08115     break;
08116 
08117   case 304:
08118 
08119 /* Line 1806 of yacc.c  */
08120 #line 2720 "ripper.y"
08121     {
08122 #if 0
08123                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
08124 #endif
08125                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
08126 
08127                     }
08128     break;
08129 
08130   case 305:
08131 
08132 /* Line 1806 of yacc.c  */
08133 #line 2728 "ripper.y"
08134     {
08135 #if 0
08136                         (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
08137 #endif
08138                         (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
08139 
08140                     }
08141     break;
08142 
08143   case 306:
08144 
08145 /* Line 1806 of yacc.c  */
08146 #line 2736 "ripper.y"
08147     {
08148 #if 0
08149                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
08150                         (yyval.val) = (yyvsp[(2) - (2)].val);
08151 #endif
08152                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
08153                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
08154 
08155                     }
08156     break;
08157 
08158   case 308:
08159 
08160 /* Line 1806 of yacc.c  */
08161 #line 2747 "ripper.y"
08162     {
08163 #if 0
08164                         block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
08165                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
08166                         (yyval.val) = (yyvsp[(2) - (2)].val);
08167 #endif
08168                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08169 
08170                     }
08171     break;
08172 
08173   case 309:
08174 
08175 /* Line 1806 of yacc.c  */
08176 #line 2757 "ripper.y"
08177     {
08178                         (yyval.val) = (yyvsp[(2) - (2)].val);
08179                     }
08180     break;
08181 
08182   case 310:
08183 
08184 /* Line 1806 of yacc.c  */
08185 #line 2764 "ripper.y"
08186     {
08187 #if 0
08188                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08189                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
08190 #endif
08191                         (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
08192 
08193                     }
08194     break;
08195 
08196   case 311:
08197 
08198 /* Line 1806 of yacc.c  */
08199 #line 2776 "ripper.y"
08200     {
08201 #if 0
08202                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08203                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
08204 #endif
08205                         (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
08206 
08207                     }
08208     break;
08209 
08210   case 312:
08211 
08212 /* Line 1806 of yacc.c  */
08213 #line 2784 "ripper.y"
08214     {COND_PUSH(1);}
08215     break;
08216 
08217   case 313:
08218 
08219 /* Line 1806 of yacc.c  */
08220 #line 2784 "ripper.y"
08221     {COND_POP();}
08222     break;
08223 
08224   case 314:
08225 
08226 /* Line 1806 of yacc.c  */
08227 #line 2787 "ripper.y"
08228     {
08229 #if 0
08230                         (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
08231                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
08232 #endif
08233                         (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
08234 
08235                     }
08236     break;
08237 
08238   case 315:
08239 
08240 /* Line 1806 of yacc.c  */
08241 #line 2795 "ripper.y"
08242     {COND_PUSH(1);}
08243     break;
08244 
08245   case 316:
08246 
08247 /* Line 1806 of yacc.c  */
08248 #line 2795 "ripper.y"
08249     {COND_POP();}
08250     break;
08251 
08252   case 317:
08253 
08254 /* Line 1806 of yacc.c  */
08255 #line 2798 "ripper.y"
08256     {
08257 #if 0
08258                         (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
08259                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
08260 #endif
08261                         (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
08262 
08263                     }
08264     break;
08265 
08266   case 318:
08267 
08268 /* Line 1806 of yacc.c  */
08269 #line 2809 "ripper.y"
08270     {
08271 #if 0
08272                         (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08273                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08274 #endif
08275                         (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08276 
08277                     }
08278     break;
08279 
08280   case 319:
08281 
08282 /* Line 1806 of yacc.c  */
08283 #line 2818 "ripper.y"
08284     {
08285 #if 0
08286                         (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
08287 #endif
08288                         (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
08289 
08290                     }
08291     break;
08292 
08293   case 320:
08294 
08295 /* Line 1806 of yacc.c  */
08296 #line 2826 "ripper.y"
08297     {COND_PUSH(1);}
08298     break;
08299 
08300   case 321:
08301 
08302 /* Line 1806 of yacc.c  */
08303 #line 2828 "ripper.y"
08304     {COND_POP();}
08305     break;
08306 
08307   case 322:
08308 
08309 /* Line 1806 of yacc.c  */
08310 #line 2831 "ripper.y"
08311     {
08312 #if 0
08313                         /*
08314                          *  for a, b, c in e
08315                          *  #=>
08316                          *  e.each{|*x| a, b, c = x
08317                          *
08318                          *  for a in e
08319                          *  #=>
08320                          *  e.each{|x| a, = x}
08321                          */
08322                         ID id = internal_id();
08323                         ID *tbl = ALLOC_N(ID, 2);
08324                         NODE *m = NEW_ARGS_AUX(0, 0);
08325                         NODE *args, *scope;
08326 
08327                         if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
08328                             /* if args.length == 1 && args[0].kind_of?(Array)
08329                              *   args = args[0]
08330                              * end
08331                              */
08332                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
08333                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
08334                             m->nd_next = block_append(
08335                                 NEW_IF(
08336                                     NEW_NODE(NODE_AND,
08337                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
08338                                                       idEq, one),
08339                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
08340                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
08341                                              0),
08342                                     NEW_DASGN_CURR(id,
08343                                                    NEW_CALL(NEW_DVAR(id), idAREF, zero)),
08344                                     0),
08345                                 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
08346 
08347                             args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08348                         }
08349                         else {
08350                             if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
08351                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
08352                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
08353                                 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
08354                                 m->nd_plen = 1;
08355                                 m->nd_next = (yyvsp[(2) - (9)].val);
08356                                 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
08357                             }
08358                             else {
08359                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
08360                                 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
08361                             }
08362                         }
08363                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
08364                         tbl[0] = 1; tbl[1] = id;
08365                         (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
08366                         fixpos((yyval.val), (yyvsp[(2) - (9)].val));
08367 #endif
08368                         (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
08369 
08370                     }
08371     break;
08372 
08373   case 323:
08374 
08375 /* Line 1806 of yacc.c  */
08376 #line 2892 "ripper.y"
08377     {
08378                         if (in_def || in_single)
08379                             yyerror("class definition in method body");
08380                         local_push(0);
08381 #if 0
08382                         (yyval.num) = ruby_sourceline;
08383 #endif
08384 
08385                     }
08386     break;
08387 
08388   case 324:
08389 
08390 /* Line 1806 of yacc.c  */
08391 #line 2903 "ripper.y"
08392     {
08393 #if 0
08394                         (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
08395                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
08396 #endif
08397                         (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
08398 
08399                         local_pop();
08400                     }
08401     break;
08402 
08403   case 325:
08404 
08405 /* Line 1806 of yacc.c  */
08406 #line 2913 "ripper.y"
08407     {
08408                         (yyval.num) = in_def;
08409                         in_def = 0;
08410                     }
08411     break;
08412 
08413   case 326:
08414 
08415 /* Line 1806 of yacc.c  */
08416 #line 2918 "ripper.y"
08417     {
08418                         (yyval.num) = in_single;
08419                         in_single = 0;
08420                         local_push(0);
08421                     }
08422     break;
08423 
08424   case 327:
08425 
08426 /* Line 1806 of yacc.c  */
08427 #line 2925 "ripper.y"
08428     {
08429 #if 0
08430                         (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08431                         fixpos((yyval.val), (yyvsp[(3) - (8)].val));
08432 #endif
08433                         (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08434 
08435                         local_pop();
08436                         in_def = (yyvsp[(4) - (8)].num);
08437                         in_single = (yyvsp[(6) - (8)].num);
08438                     }
08439     break;
08440 
08441   case 328:
08442 
08443 /* Line 1806 of yacc.c  */
08444 #line 2937 "ripper.y"
08445     {
08446                         if (in_def || in_single)
08447                             yyerror("module definition in method body");
08448                         local_push(0);
08449 #if 0
08450                         (yyval.num) = ruby_sourceline;
08451 #endif
08452 
08453                     }
08454     break;
08455 
08456   case 329:
08457 
08458 /* Line 1806 of yacc.c  */
08459 #line 2948 "ripper.y"
08460     {
08461 #if 0
08462                         (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08463                         nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
08464 #endif
08465                         (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08466 
08467                         local_pop();
08468                     }
08469     break;
08470 
08471   case 330:
08472 
08473 /* Line 1806 of yacc.c  */
08474 #line 2958 "ripper.y"
08475     {
08476                         (yyval.id) = cur_mid;
08477                         cur_mid = (yyvsp[(2) - (2)].val);
08478                         in_def++;
08479                         local_push(0);
08480                     }
08481     break;
08482 
08483   case 331:
08484 
08485 /* Line 1806 of yacc.c  */
08486 #line 2967 "ripper.y"
08487     {
08488 #if 0
08489                         NODE *body = remove_begin((yyvsp[(5) - (6)].val));
08490                         reduce_nodes(&body);
08491                         (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
08492                         nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
08493 #endif
08494                         (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08495 
08496                         local_pop();
08497                         in_def--;
08498                         cur_mid = (yyvsp[(3) - (6)].id);
08499                     }
08500     break;
08501 
08502   case 332:
08503 
08504 /* Line 1806 of yacc.c  */
08505 #line 2980 "ripper.y"
08506     {lex_state = EXPR_FNAME;}
08507     break;
08508 
08509   case 333:
08510 
08511 /* Line 1806 of yacc.c  */
08512 #line 2981 "ripper.y"
08513     {
08514                         in_single++;
08515                         lex_state = EXPR_ENDFN; /* force for args */
08516                         local_push(0);
08517                     }
08518     break;
08519 
08520   case 334:
08521 
08522 /* Line 1806 of yacc.c  */
08523 #line 2989 "ripper.y"
08524     {
08525 #if 0
08526                         NODE *body = remove_begin((yyvsp[(8) - (9)].val));
08527                         reduce_nodes(&body);
08528                         (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
08529                         nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
08530 #endif
08531                         (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
08532 
08533                         local_pop();
08534                         in_single--;
08535                     }
08536     break;
08537 
08538   case 335:
08539 
08540 /* Line 1806 of yacc.c  */
08541 #line 3002 "ripper.y"
08542     {
08543 #if 0
08544                         (yyval.val) = NEW_BREAK(0);
08545 #endif
08546                         (yyval.val) = dispatch1(break, arg_new());
08547 
08548                     }
08549     break;
08550 
08551   case 336:
08552 
08553 /* Line 1806 of yacc.c  */
08554 #line 3010 "ripper.y"
08555     {
08556 #if 0
08557                         (yyval.val) = NEW_NEXT(0);
08558 #endif
08559                         (yyval.val) = dispatch1(next, arg_new());
08560 
08561                     }
08562     break;
08563 
08564   case 337:
08565 
08566 /* Line 1806 of yacc.c  */
08567 #line 3018 "ripper.y"
08568     {
08569 #if 0
08570                         (yyval.val) = NEW_REDO();
08571 #endif
08572                         (yyval.val) = dispatch0(redo);
08573 
08574                     }
08575     break;
08576 
08577   case 338:
08578 
08579 /* Line 1806 of yacc.c  */
08580 #line 3026 "ripper.y"
08581     {
08582 #if 0
08583                         (yyval.val) = NEW_RETRY();
08584 #endif
08585                         (yyval.val) = dispatch0(retry);
08586 
08587                     }
08588     break;
08589 
08590   case 339:
08591 
08592 /* Line 1806 of yacc.c  */
08593 #line 3036 "ripper.y"
08594     {
08595 #if 0
08596                         value_expr((yyvsp[(1) - (1)].val));
08597                         (yyval.val) = (yyvsp[(1) - (1)].val);
08598                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
08599 #endif
08600                         (yyval.val) = (yyvsp[(1) - (1)].val);
08601 
08602                     }
08603     break;
08604 
08605   case 340:
08606 
08607 /* Line 1806 of yacc.c  */
08608 #line 3048 "ripper.y"
08609     {
08610                         token_info_push("begin");
08611                     }
08612     break;
08613 
08614   case 341:
08615 
08616 /* Line 1806 of yacc.c  */
08617 #line 3054 "ripper.y"
08618     {
08619                         token_info_push("if");
08620                     }
08621     break;
08622 
08623   case 342:
08624 
08625 /* Line 1806 of yacc.c  */
08626 #line 3060 "ripper.y"
08627     {
08628                         token_info_push("unless");
08629                     }
08630     break;
08631 
08632   case 343:
08633 
08634 /* Line 1806 of yacc.c  */
08635 #line 3066 "ripper.y"
08636     {
08637                         token_info_push("while");
08638                     }
08639     break;
08640 
08641   case 344:
08642 
08643 /* Line 1806 of yacc.c  */
08644 #line 3072 "ripper.y"
08645     {
08646                         token_info_push("until");
08647                     }
08648     break;
08649 
08650   case 345:
08651 
08652 /* Line 1806 of yacc.c  */
08653 #line 3078 "ripper.y"
08654     {
08655                         token_info_push("case");
08656                     }
08657     break;
08658 
08659   case 346:
08660 
08661 /* Line 1806 of yacc.c  */
08662 #line 3084 "ripper.y"
08663     {
08664                         token_info_push("for");
08665                     }
08666     break;
08667 
08668   case 347:
08669 
08670 /* Line 1806 of yacc.c  */
08671 #line 3090 "ripper.y"
08672     {
08673                         token_info_push("class");
08674                     }
08675     break;
08676 
08677   case 348:
08678 
08679 /* Line 1806 of yacc.c  */
08680 #line 3096 "ripper.y"
08681     {
08682                         token_info_push("module");
08683                     }
08684     break;
08685 
08686   case 349:
08687 
08688 /* Line 1806 of yacc.c  */
08689 #line 3102 "ripper.y"
08690     {
08691                         token_info_push("def");
08692 #if 0
08693                         (yyval.num) = ruby_sourceline;
08694 #endif
08695 
08696                     }
08697     break;
08698 
08699   case 350:
08700 
08701 /* Line 1806 of yacc.c  */
08702 #line 3112 "ripper.y"
08703     {
08704                         token_info_pop("end");
08705                     }
08706     break;
08707 
08708   case 351:
08709 
08710 /* Line 1806 of yacc.c  */
08711 #line 3120 "ripper.y"
08712     { (yyval.val) = Qnil; }
08713     break;
08714 
08715   case 353:
08716 
08717 /* Line 1806 of yacc.c  */
08718 #line 3126 "ripper.y"
08719     { (yyval.val) = (yyvsp[(2) - (2)].val); }
08720     break;
08721 
08722   case 354:
08723 
08724 /* Line 1806 of yacc.c  */
08725 #line 3133 "ripper.y"
08726     { (yyval.val) = Qnil; }
08727     break;
08728 
08729   case 357:
08730 
08731 /* Line 1806 of yacc.c  */
08732 #line 3142 "ripper.y"
08733     {
08734 #if 0
08735                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08736                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08737 #endif
08738                         (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08739 
08740                     }
08741     break;
08742 
08743   case 359:
08744 
08745 /* Line 1806 of yacc.c  */
08746 #line 3154 "ripper.y"
08747     {
08748 #if 0
08749                         (yyval.val) = (yyvsp[(2) - (2)].val);
08750 #endif
08751                         (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
08752 
08753                     }
08754     break;
08755 
08756   case 362:
08757 
08758 /* Line 1806 of yacc.c  */
08759 #line 3168 "ripper.y"
08760     {
08761                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
08762 #if 0
08763 #endif
08764                         (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
08765 
08766                     }
08767     break;
08768 
08769   case 363:
08770 
08771 /* Line 1806 of yacc.c  */
08772 #line 3176 "ripper.y"
08773     {
08774 #if 0
08775                         (yyval.val) = (yyvsp[(2) - (3)].val);
08776 #endif
08777                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
08778 
08779                     }
08780     break;
08781 
08782   case 364:
08783 
08784 /* Line 1806 of yacc.c  */
08785 #line 3186 "ripper.y"
08786     {
08787 #if 0
08788                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
08789 #endif
08790                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
08791 
08792                     }
08793     break;
08794 
08795   case 365:
08796 
08797 /* Line 1806 of yacc.c  */
08798 #line 3194 "ripper.y"
08799     {
08800 #if 0
08801                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08802 #endif
08803                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08804 
08805                     }
08806     break;
08807 
08808   case 366:
08809 
08810 /* Line 1806 of yacc.c  */
08811 #line 3204 "ripper.y"
08812     {
08813 #if 0
08814                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
08815 #endif
08816                         (yyval.val) = (yyvsp[(1) - (1)].val);
08817 
08818                     }
08819     break;
08820 
08821   case 367:
08822 
08823 /* Line 1806 of yacc.c  */
08824 #line 3212 "ripper.y"
08825     {
08826                         (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
08827 #if 0
08828                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
08829 #endif
08830                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
08831 
08832                     }
08833     break;
08834 
08835   case 368:
08836 
08837 /* Line 1806 of yacc.c  */
08838 #line 3221 "ripper.y"
08839     {
08840                         (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
08841 #if 0
08842                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
08843 #endif
08844                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
08845 
08846                     }
08847     break;
08848 
08849   case 369:
08850 
08851 /* Line 1806 of yacc.c  */
08852 #line 3230 "ripper.y"
08853     {
08854 #if 0
08855                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
08856 #endif
08857                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
08858 
08859                     }
08860     break;
08861 
08862   case 370:
08863 
08864 /* Line 1806 of yacc.c  */
08865 #line 3238 "ripper.y"
08866     {
08867 #if 0
08868                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
08869 #endif
08870                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
08871 
08872                     }
08873     break;
08874 
08875   case 371:
08876 
08877 /* Line 1806 of yacc.c  */
08878 #line 3246 "ripper.y"
08879     {
08880                         (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
08881 #if 0
08882                         (yyval.val) = NEW_MASGN(0, (yyval.val));
08883 #endif
08884                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
08885 
08886                     }
08887     break;
08888 
08889   case 372:
08890 
08891 /* Line 1806 of yacc.c  */
08892 #line 3255 "ripper.y"
08893     {
08894                         (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
08895 #if 0
08896                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
08897 #endif
08898                       #if 0
08899                       TODO: Check me
08900                       #endif
08901                         (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
08902 
08903                     }
08904     break;
08905 
08906   case 373:
08907 
08908 /* Line 1806 of yacc.c  */
08909 #line 3267 "ripper.y"
08910     {
08911 #if 0
08912                         (yyval.val) = NEW_MASGN(0, -1);
08913 #endif
08914                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08915 
08916                     }
08917     break;
08918 
08919   case 374:
08920 
08921 /* Line 1806 of yacc.c  */
08922 #line 3275 "ripper.y"
08923     {
08924 #if 0
08925                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
08926 #endif
08927                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08928 
08929                     }
08930     break;
08931 
08932   case 375:
08933 
08934 /* Line 1806 of yacc.c  */
08935 #line 3286 "ripper.y"
08936     {
08937                         (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08938                     }
08939     break;
08940 
08941   case 376:
08942 
08943 /* Line 1806 of yacc.c  */
08944 #line 3290 "ripper.y"
08945     {
08946                         (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
08947                     }
08948     break;
08949 
08950   case 377:
08951 
08952 /* Line 1806 of yacc.c  */
08953 #line 3294 "ripper.y"
08954     {
08955                         (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08956                     }
08957     break;
08958 
08959   case 378:
08960 
08961 /* Line 1806 of yacc.c  */
08962 #line 3298 "ripper.y"
08963     {
08964                         (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
08965                     }
08966     break;
08967 
08968   case 379:
08969 
08970 /* Line 1806 of yacc.c  */
08971 #line 3304 "ripper.y"
08972     {
08973                         (yyval.val) = (yyvsp[(2) - (2)].val);
08974                     }
08975     break;
08976 
08977   case 380:
08978 
08979 /* Line 1806 of yacc.c  */
08980 #line 3308 "ripper.y"
08981     {
08982                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
08983                     }
08984     break;
08985 
08986   case 381:
08987 
08988 /* Line 1806 of yacc.c  */
08989 #line 3314 "ripper.y"
08990     {
08991                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
08992                     }
08993     break;
08994 
08995   case 382:
08996 
08997 /* Line 1806 of yacc.c  */
08998 #line 3318 "ripper.y"
08999     {
09000                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
09001                     }
09002     break;
09003 
09004   case 383:
09005 
09006 /* Line 1806 of yacc.c  */
09007 #line 3322 "ripper.y"
09008     {
09009                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
09010                     }
09011     break;
09012 
09013   case 384:
09014 
09015 /* Line 1806 of yacc.c  */
09016 #line 3326 "ripper.y"
09017     {
09018                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09019                     }
09020     break;
09021 
09022   case 385:
09023 
09024 /* Line 1806 of yacc.c  */
09025 #line 3330 "ripper.y"
09026     {
09027                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
09028                     }
09029     break;
09030 
09031   case 386:
09032 
09033 /* Line 1806 of yacc.c  */
09034 #line 3334 "ripper.y"
09035     {
09036                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
09037 #if 0
09038 #endif
09039                         dispatch1(excessed_comma, (yyval.val));
09040 
09041                     }
09042     break;
09043 
09044   case 387:
09045 
09046 /* Line 1806 of yacc.c  */
09047 #line 3342 "ripper.y"
09048     {
09049                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09050                     }
09051     break;
09052 
09053   case 388:
09054 
09055 /* Line 1806 of yacc.c  */
09056 #line 3346 "ripper.y"
09057     {
09058                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
09059                     }
09060     break;
09061 
09062   case 389:
09063 
09064 /* Line 1806 of yacc.c  */
09065 #line 3350 "ripper.y"
09066     {
09067                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
09068                     }
09069     break;
09070 
09071   case 390:
09072 
09073 /* Line 1806 of yacc.c  */
09074 #line 3354 "ripper.y"
09075     {
09076                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09077                     }
09078     break;
09079 
09080   case 391:
09081 
09082 /* Line 1806 of yacc.c  */
09083 #line 3358 "ripper.y"
09084     {
09085                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
09086                     }
09087     break;
09088 
09089   case 392:
09090 
09091 /* Line 1806 of yacc.c  */
09092 #line 3362 "ripper.y"
09093     {
09094                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09095                     }
09096     break;
09097 
09098   case 393:
09099 
09100 /* Line 1806 of yacc.c  */
09101 #line 3366 "ripper.y"
09102     {
09103                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
09104                     }
09105     break;
09106 
09107   case 394:
09108 
09109 /* Line 1806 of yacc.c  */
09110 #line 3370 "ripper.y"
09111     {
09112                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09113                     }
09114     break;
09115 
09116   case 395:
09117 
09118 /* Line 1806 of yacc.c  */
09119 #line 3374 "ripper.y"
09120     {
09121                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
09122                     }
09123     break;
09124 
09125   case 397:
09126 
09127 /* Line 1806 of yacc.c  */
09128 #line 3381 "ripper.y"
09129     {
09130                         command_start = TRUE;
09131                     }
09132     break;
09133 
09134   case 398:
09135 
09136 /* Line 1806 of yacc.c  */
09137 #line 3387 "ripper.y"
09138     {
09139 #if 0
09140                         (yyval.val) = 0;
09141 #endif
09142                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09143                                           escape_Qundef((yyvsp[(2) - (3)].val)));
09144 
09145                     }
09146     break;
09147 
09148   case 399:
09149 
09150 /* Line 1806 of yacc.c  */
09151 #line 3396 "ripper.y"
09152     {
09153 #if 0
09154                         (yyval.val) = 0;
09155 #endif
09156                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
09157                                           Qnil);
09158 
09159                     }
09160     break;
09161 
09162   case 400:
09163 
09164 /* Line 1806 of yacc.c  */
09165 #line 3405 "ripper.y"
09166     {
09167 #if 0
09168                         (yyval.val) = (yyvsp[(2) - (4)].val);
09169 #endif
09170                         (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
09171 
09172                     }
09173     break;
09174 
09175   case 401:
09176 
09177 /* Line 1806 of yacc.c  */
09178 #line 3416 "ripper.y"
09179     {
09180                       (yyval.val) = 0;
09181                     }
09182     break;
09183 
09184   case 402:
09185 
09186 /* Line 1806 of yacc.c  */
09187 #line 3420 "ripper.y"
09188     {
09189 #if 0
09190                         (yyval.val) = 0;
09191 #endif
09192                         (yyval.val) = (yyvsp[(3) - (4)].val);
09193 
09194                     }
09195     break;
09196 
09197   case 403:
09198 
09199 /* Line 1806 of yacc.c  */
09200 #line 3432 "ripper.y"
09201     {
09202                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09203                     }
09204     break;
09205 
09206   case 404:
09207 
09208 /* Line 1806 of yacc.c  */
09209 #line 3439 "ripper.y"
09210     {
09211                         rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
09212                     }
09213     break;
09214 
09215   case 405:
09216 
09217 /* Line 1806 of yacc.c  */
09218 #line 3446 "ripper.y"
09219     {
09220                         new_bv(get_id((yyvsp[(1) - (1)].val)));
09221 #if 0
09222 #endif
09223                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
09224 
09225                     }
09226     break;
09227 
09228   case 406:
09229 
09230 /* Line 1806 of yacc.c  */
09231 #line 3454 "ripper.y"
09232     {
09233                         (yyval.val) = 0;
09234                     }
09235     break;
09236 
09237   case 407:
09238 
09239 /* Line 1806 of yacc.c  */
09240 #line 3459 "ripper.y"
09241     {
09242                         (yyval.vars) = dyna_push();
09243                     }
09244     break;
09245 
09246   case 408:
09247 
09248 /* Line 1806 of yacc.c  */
09249 #line 3462 "ripper.y"
09250     {
09251                         (yyval.num) = lpar_beg;
09252                         lpar_beg = ++paren_nest;
09253                     }
09254     break;
09255 
09256   case 409:
09257 
09258 /* Line 1806 of yacc.c  */
09259 #line 3467 "ripper.y"
09260     {
09261                         (yyval.num) = ruby_sourceline;
09262                     }
09263     break;
09264 
09265   case 410:
09266 
09267 /* Line 1806 of yacc.c  */
09268 #line 3470 "ripper.y"
09269     {
09270                         (yyval.val) = cmdarg_stack;
09271                         cmdarg_stack = 0;
09272                     }
09273     break;
09274 
09275   case 411:
09276 
09277 /* Line 1806 of yacc.c  */
09278 #line 3475 "ripper.y"
09279     {
09280                         lpar_beg = (yyvsp[(2) - (6)].num);
09281                         cmdarg_stack = (yyvsp[(5) - (6)].val);
09282                         CMDARG_LEXPOP();
09283 #if 0
09284                         (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
09285                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
09286 #endif
09287                         (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
09288 
09289                         dyna_pop((yyvsp[(1) - (6)].vars));
09290                     }
09291     break;
09292 
09293   case 412:
09294 
09295 /* Line 1806 of yacc.c  */
09296 #line 3490 "ripper.y"
09297     {
09298 #if 0
09299                         (yyval.val) = (yyvsp[(2) - (4)].val);
09300 #endif
09301                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
09302 
09303                     }
09304     break;
09305 
09306   case 413:
09307 
09308 /* Line 1806 of yacc.c  */
09309 #line 3498 "ripper.y"
09310     {
09311                         (yyval.val) = (yyvsp[(1) - (1)].val);
09312                     }
09313     break;
09314 
09315   case 414:
09316 
09317 /* Line 1806 of yacc.c  */
09318 #line 3504 "ripper.y"
09319     {
09320                         (yyval.val) = (yyvsp[(2) - (3)].val);
09321                     }
09322     break;
09323 
09324   case 415:
09325 
09326 /* Line 1806 of yacc.c  */
09327 #line 3508 "ripper.y"
09328     {
09329                         (yyval.val) = (yyvsp[(2) - (3)].val);
09330                     }
09331     break;
09332 
09333   case 416:
09334 
09335 /* Line 1806 of yacc.c  */
09336 #line 3514 "ripper.y"
09337     {
09338                         (yyvsp[(1) - (1)].vars) = dyna_push();
09339 #if 0
09340                         (yyval.num) = ruby_sourceline;
09341 #endif
09342                     }
09343     break;
09344 
09345   case 417:
09346 
09347 /* Line 1806 of yacc.c  */
09348 #line 3523 "ripper.y"
09349     {
09350 #if 0
09351                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09352                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09353 #endif
09354                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09355 
09356                         dyna_pop((yyvsp[(1) - (5)].vars));
09357                     }
09358     break;
09359 
09360   case 418:
09361 
09362 /* Line 1806 of yacc.c  */
09363 #line 3535 "ripper.y"
09364     {
09365 #if 0
09366                         if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
09367                             compile_error(PARSER_ARG "block given to yield");
09368                         }
09369                         else {
09370                             block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
09371                         }
09372                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
09373                         (yyval.val) = (yyvsp[(2) - (2)].val);
09374                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
09375 #endif
09376                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09377 
09378                     }
09379     break;
09380 
09381   case 419:
09382 
09383 /* Line 1806 of yacc.c  */
09384 #line 3551 "ripper.y"
09385     {
09386 #if 0
09387                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09388 #endif
09389                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
09390                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09391 
09392                     }
09393     break;
09394 
09395   case 420:
09396 
09397 /* Line 1806 of yacc.c  */
09398 #line 3560 "ripper.y"
09399     {
09400 #if 0
09401                         block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09402                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09403                         (yyval.val) = (yyvsp[(5) - (5)].val);
09404                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
09405 #endif
09406                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09407                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
09408 
09409                     }
09410     break;
09411 
09412   case 421:
09413 
09414 /* Line 1806 of yacc.c  */
09415 #line 3572 "ripper.y"
09416     {
09417 #if 0
09418                         block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09419                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09420                         (yyval.val) = (yyvsp[(5) - (5)].val);
09421                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
09422 #endif
09423                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
09424                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
09425 
09426                     }
09427     break;
09428 
09429   case 422:
09430 
09431 /* Line 1806 of yacc.c  */
09432 #line 3586 "ripper.y"
09433     {
09434 #if 0
09435                         (yyval.val) = (yyvsp[(1) - (2)].val);
09436                         (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
09437 #endif
09438                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
09439 
09440                     }
09441     break;
09442 
09443   case 423:
09444 
09445 /* Line 1806 of yacc.c  */
09446 #line 3595 "ripper.y"
09447     {
09448 #if 0
09449                         (yyval.num) = ruby_sourceline;
09450 #endif
09451                     }
09452     break;
09453 
09454   case 424:
09455 
09456 /* Line 1806 of yacc.c  */
09457 #line 3601 "ripper.y"
09458     {
09459 #if 0
09460                         (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
09461                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
09462 #endif
09463                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
09464                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
09465 
09466                     }
09467     break;
09468 
09469   case 425:
09470 
09471 /* Line 1806 of yacc.c  */
09472 #line 3611 "ripper.y"
09473     {
09474 #if 0
09475                         (yyval.num) = ruby_sourceline;
09476 #endif
09477                     }
09478     break;
09479 
09480   case 426:
09481 
09482 /* Line 1806 of yacc.c  */
09483 #line 3617 "ripper.y"
09484     {
09485 #if 0
09486                         (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
09487                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
09488 #endif
09489                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
09490                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
09491 
09492                     }
09493     break;
09494 
09495   case 427:
09496 
09497 /* Line 1806 of yacc.c  */
09498 #line 3627 "ripper.y"
09499     {
09500 #if 0
09501                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
09502 #endif
09503                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
09504 
09505                     }
09506     break;
09507 
09508   case 428:
09509 
09510 /* Line 1806 of yacc.c  */
09511 #line 3635 "ripper.y"
09512     {
09513 #if 0
09514                         (yyval.num) = ruby_sourceline;
09515 #endif
09516                     }
09517     break;
09518 
09519   case 429:
09520 
09521 /* Line 1806 of yacc.c  */
09522 #line 3641 "ripper.y"
09523     {
09524 #if 0
09525                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
09526                         nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
09527 #endif
09528                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
09529                                        ripper_intern("call"));
09530                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09531 
09532                     }
09533     break;
09534 
09535   case 430:
09536 
09537 /* Line 1806 of yacc.c  */
09538 #line 3652 "ripper.y"
09539     {
09540 #if 0
09541                         (yyval.num) = ruby_sourceline;
09542 #endif
09543                     }
09544     break;
09545 
09546   case 431:
09547 
09548 /* Line 1806 of yacc.c  */
09549 #line 3658 "ripper.y"
09550     {
09551 #if 0
09552                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
09553                         nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
09554 #endif
09555                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
09556                                        ripper_intern("call"));
09557                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09558 
09559                     }
09560     break;
09561 
09562   case 432:
09563 
09564 /* Line 1806 of yacc.c  */
09565 #line 3669 "ripper.y"
09566     {
09567 #if 0
09568                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
09569 #endif
09570                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
09571 
09572                     }
09573     break;
09574 
09575   case 433:
09576 
09577 /* Line 1806 of yacc.c  */
09578 #line 3677 "ripper.y"
09579     {
09580 #if 0
09581                         (yyval.val) = NEW_ZSUPER();
09582 #endif
09583                         (yyval.val) = dispatch0(zsuper);
09584 
09585                     }
09586     break;
09587 
09588   case 434:
09589 
09590 /* Line 1806 of yacc.c  */
09591 #line 3685 "ripper.y"
09592     {
09593 #if 0
09594                         if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
09595                             (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
09596                         else
09597                             (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
09598                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09599 #endif
09600                         (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
09601 
09602                     }
09603     break;
09604 
09605   case 435:
09606 
09607 /* Line 1806 of yacc.c  */
09608 #line 3699 "ripper.y"
09609     {
09610                         (yyvsp[(1) - (1)].vars) = dyna_push();
09611 #if 0
09612                         (yyval.num) = ruby_sourceline;
09613 #endif
09614 
09615                     }
09616     break;
09617 
09618   case 436:
09619 
09620 /* Line 1806 of yacc.c  */
09621 #line 3708 "ripper.y"
09622     {
09623 #if 0
09624                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09625                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09626 #endif
09627                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09628 
09629                         dyna_pop((yyvsp[(1) - (5)].vars));
09630                     }
09631     break;
09632 
09633   case 437:
09634 
09635 /* Line 1806 of yacc.c  */
09636 #line 3718 "ripper.y"
09637     {
09638                         (yyvsp[(1) - (1)].vars) = dyna_push();
09639 #if 0
09640                         (yyval.num) = ruby_sourceline;
09641 #endif
09642 
09643                     }
09644     break;
09645 
09646   case 438:
09647 
09648 /* Line 1806 of yacc.c  */
09649 #line 3727 "ripper.y"
09650     {
09651 #if 0
09652                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09653                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09654 #endif
09655                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09656 
09657                         dyna_pop((yyvsp[(1) - (5)].vars));
09658                     }
09659     break;
09660 
09661   case 439:
09662 
09663 /* Line 1806 of yacc.c  */
09664 #line 3741 "ripper.y"
09665     {
09666 #if 0
09667                         (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09668 #endif
09669                         (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
09670 
09671                     }
09672     break;
09673 
09674   case 442:
09675 
09676 /* Line 1806 of yacc.c  */
09677 #line 3757 "ripper.y"
09678     {
09679 #if 0
09680                         if ((yyvsp[(3) - (6)].val)) {
09681                             (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
09682                             (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
09683                         }
09684                         (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09685                         fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
09686 #endif
09687                         (yyval.val) = dispatch4(rescue,
09688                                        escape_Qundef((yyvsp[(2) - (6)].val)),
09689                                        escape_Qundef((yyvsp[(3) - (6)].val)),
09690                                        escape_Qundef((yyvsp[(5) - (6)].val)),
09691                                        escape_Qundef((yyvsp[(6) - (6)].val)));
09692 
09693                     }
09694     break;
09695 
09696   case 444:
09697 
09698 /* Line 1806 of yacc.c  */
09699 #line 3777 "ripper.y"
09700     {
09701 #if 0
09702                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
09703 #endif
09704                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09705 
09706                     }
09707     break;
09708 
09709   case 445:
09710 
09711 /* Line 1806 of yacc.c  */
09712 #line 3785 "ripper.y"
09713     {
09714 #if 0
09715                         if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
09716 #endif
09717                         (yyval.val) = (yyvsp[(1) - (1)].val);
09718 
09719                     }
09720     break;
09721 
09722   case 447:
09723 
09724 /* Line 1806 of yacc.c  */
09725 #line 3796 "ripper.y"
09726     {
09727                         (yyval.val) = (yyvsp[(2) - (2)].val);
09728                     }
09729     break;
09730 
09731   case 449:
09732 
09733 /* Line 1806 of yacc.c  */
09734 #line 3803 "ripper.y"
09735     {
09736 #if 0
09737                         (yyval.val) = (yyvsp[(2) - (2)].val);
09738 #endif
09739                         (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
09740 
09741                     }
09742     break;
09743 
09744   case 452:
09745 
09746 /* Line 1806 of yacc.c  */
09747 #line 3815 "ripper.y"
09748     {
09749 #if 0
09750                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
09751 #endif
09752                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
09753 
09754                     }
09755     break;
09756 
09757   case 454:
09758 
09759 /* Line 1806 of yacc.c  */
09760 #line 3826 "ripper.y"
09761     {
09762 #if 0
09763                         NODE *node = (yyvsp[(1) - (1)].val);
09764                         if (!node) {
09765                             node = NEW_STR(STR_NEW0());
09766                         }
09767                         else {
09768                             node = evstr2dstr(node);
09769                         }
09770                         (yyval.val) = node;
09771 #endif
09772                         (yyval.val) = (yyvsp[(1) - (1)].val);
09773 
09774                     }
09775     break;
09776 
09777   case 457:
09778 
09779 /* Line 1806 of yacc.c  */
09780 #line 3845 "ripper.y"
09781     {
09782 #if 0
09783                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09784 #endif
09785                         (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09786 
09787                     }
09788     break;
09789 
09790   case 458:
09791 
09792 /* Line 1806 of yacc.c  */
09793 #line 3855 "ripper.y"
09794     {
09795 #if 0
09796                         (yyval.val) = (yyvsp[(2) - (3)].val);
09797 #endif
09798                         (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
09799 
09800                     }
09801     break;
09802 
09803   case 459:
09804 
09805 /* Line 1806 of yacc.c  */
09806 #line 3865 "ripper.y"
09807     {
09808 #if 0
09809                         NODE *node = (yyvsp[(2) - (3)].val);
09810                         if (!node) {
09811                             node = NEW_XSTR(STR_NEW0());
09812                         }
09813                         else {
09814                             switch (nd_type(node)) {
09815                               case NODE_STR:
09816                                 nd_set_type(node, NODE_XSTR);
09817                                 break;
09818                               case NODE_DSTR:
09819                                 nd_set_type(node, NODE_DXSTR);
09820                                 break;
09821                               default:
09822                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09823                                 break;
09824                             }
09825                         }
09826                         (yyval.val) = node;
09827 #endif
09828                         (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
09829 
09830                     }
09831     break;
09832 
09833   case 460:
09834 
09835 /* Line 1806 of yacc.c  */
09836 #line 3892 "ripper.y"
09837     {
09838 #if 0
09839                         int options = (yyvsp[(3) - (3)].val);
09840                         NODE *node = (yyvsp[(2) - (3)].val);
09841                         NODE *list, *prev;
09842                         if (!node) {
09843                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09844                         }
09845                         else switch (nd_type(node)) {
09846                           case NODE_STR:
09847                             {
09848                                 VALUE src = node->nd_lit;
09849                                 nd_set_type(node, NODE_LIT);
09850                                 node->nd_lit = reg_compile(src, options);
09851                             }
09852                             break;
09853                           default:
09854                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09855                           case NODE_DSTR:
09856                             if (options & RE_OPTION_ONCE) {
09857                                 nd_set_type(node, NODE_DREGX_ONCE);
09858                             }
09859                             else {
09860                                 nd_set_type(node, NODE_DREGX);
09861                             }
09862                             node->nd_cflag = options & RE_OPTION_MASK;
09863                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09864                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09865                                 if (nd_type(list->nd_head) == NODE_STR) {
09866                                     VALUE tail = list->nd_head->nd_lit;
09867                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09868                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09869                                         if (!literal_concat0(parser, lit, tail)) {
09870                                             node = 0;
09871                                             break;
09872                                         }
09873                                         rb_str_resize(tail, 0);
09874                                         prev->nd_next = list->nd_next;
09875                                         rb_gc_force_recycle((VALUE)list->nd_head);
09876                                         rb_gc_force_recycle((VALUE)list);
09877                                         list = prev;
09878                                     }
09879                                     else {
09880                                         prev = list;
09881                                     }
09882                                 }
09883                                 else {
09884                                     prev = 0;
09885                                 }
09886                             }
09887                             if (!node->nd_next) {
09888                                 VALUE src = node->nd_lit;
09889                                 nd_set_type(node, NODE_LIT);
09890                                 node->nd_lit = reg_compile(src, options);
09891                             }
09892                             break;
09893                         }
09894                         (yyval.val) = node;
09895 #endif
09896                         (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
09897 
09898                     }
09899     break;
09900 
09901   case 461:
09902 
09903 /* Line 1806 of yacc.c  */
09904 #line 3957 "ripper.y"
09905     {
09906 #if 0
09907                         (yyval.val) = NEW_ZARRAY();
09908 #endif
09909                         (yyval.val) = dispatch0(words_new);
09910                         (yyval.val) = dispatch1(array, (yyval.val));
09911 
09912                     }
09913     break;
09914 
09915   case 462:
09916 
09917 /* Line 1806 of yacc.c  */
09918 #line 3966 "ripper.y"
09919     {
09920 #if 0
09921                         (yyval.val) = (yyvsp[(2) - (3)].val);
09922 #endif
09923                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09924 
09925                     }
09926     break;
09927 
09928   case 463:
09929 
09930 /* Line 1806 of yacc.c  */
09931 #line 3976 "ripper.y"
09932     {
09933 #if 0
09934                         (yyval.val) = 0;
09935 #endif
09936                         (yyval.val) = dispatch0(words_new);
09937 
09938                     }
09939     break;
09940 
09941   case 464:
09942 
09943 /* Line 1806 of yacc.c  */
09944 #line 3984 "ripper.y"
09945     {
09946 #if 0
09947                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
09948 #endif
09949                         (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09950 
09951                     }
09952     break;
09953 
09954   case 465:
09955 
09956 /* Line 1806 of yacc.c  */
09957 #line 3996 "ripper.y"
09958     {
09959                         (yyval.val) = dispatch0(word_new);
09960                         (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
09961                     }
09962     break;
09963 
09964   case 466:
09965 
09966 /* Line 1806 of yacc.c  */
09967 #line 4002 "ripper.y"
09968     {
09969 #if 0
09970                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09971 #endif
09972                         (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09973 
09974                     }
09975     break;
09976 
09977   case 467:
09978 
09979 /* Line 1806 of yacc.c  */
09980 #line 4012 "ripper.y"
09981     {
09982 #if 0
09983                         (yyval.val) = NEW_ZARRAY();
09984 #endif
09985                         (yyval.val) = dispatch0(symbols_new);
09986                         (yyval.val) = dispatch1(array, (yyval.val));
09987 
09988                     }
09989     break;
09990 
09991   case 468:
09992 
09993 /* Line 1806 of yacc.c  */
09994 #line 4021 "ripper.y"
09995     {
09996 #if 0
09997                         (yyval.val) = (yyvsp[(2) - (3)].val);
09998 #endif
09999                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10000 
10001                     }
10002     break;
10003 
10004   case 469:
10005 
10006 /* Line 1806 of yacc.c  */
10007 #line 4031 "ripper.y"
10008     {
10009 #if 0
10010                         (yyval.val) = 0;
10011 #endif
10012                         (yyval.val) = dispatch0(symbols_new);
10013 
10014                     }
10015     break;
10016 
10017   case 470:
10018 
10019 /* Line 1806 of yacc.c  */
10020 #line 4039 "ripper.y"
10021     {
10022 #if 0
10023                         (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
10024                         if (nd_type((yyvsp[(2) - (3)].val)) == NODE_DSTR) {
10025                             nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
10026                         }
10027                         else {
10028                             nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10029                             (yyvsp[(2) - (3)].val)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].val)->nd_lit);
10030                         }
10031                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10032 #endif
10033                         (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10034 
10035                     }
10036     break;
10037 
10038   case 471:
10039 
10040 /* Line 1806 of yacc.c  */
10041 #line 4057 "ripper.y"
10042     {
10043 #if 0
10044                         (yyval.val) = NEW_ZARRAY();
10045 #endif
10046                         (yyval.val) = dispatch0(qwords_new);
10047                         (yyval.val) = dispatch1(array, (yyval.val));
10048 
10049                     }
10050     break;
10051 
10052   case 472:
10053 
10054 /* Line 1806 of yacc.c  */
10055 #line 4066 "ripper.y"
10056     {
10057 #if 0
10058                         (yyval.val) = (yyvsp[(2) - (3)].val);
10059 #endif
10060                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10061 
10062                     }
10063     break;
10064 
10065   case 473:
10066 
10067 /* Line 1806 of yacc.c  */
10068 #line 4076 "ripper.y"
10069     {
10070 #if 0
10071                         (yyval.val) = NEW_ZARRAY();
10072 #endif
10073                         (yyval.val) = dispatch0(qsymbols_new);
10074                         (yyval.val) = dispatch1(array, (yyval.val));
10075 
10076                     }
10077     break;
10078 
10079   case 474:
10080 
10081 /* Line 1806 of yacc.c  */
10082 #line 4085 "ripper.y"
10083     {
10084 #if 0
10085                         (yyval.val) = (yyvsp[(2) - (3)].val);
10086 #endif
10087                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10088 
10089                     }
10090     break;
10091 
10092   case 475:
10093 
10094 /* Line 1806 of yacc.c  */
10095 #line 4095 "ripper.y"
10096     {
10097 #if 0
10098                         (yyval.val) = 0;
10099 #endif
10100                         (yyval.val) = dispatch0(qwords_new);
10101 
10102                     }
10103     break;
10104 
10105   case 476:
10106 
10107 /* Line 1806 of yacc.c  */
10108 #line 4103 "ripper.y"
10109     {
10110 #if 0
10111                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10112 #endif
10113                         (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10114 
10115                     }
10116     break;
10117 
10118   case 477:
10119 
10120 /* Line 1806 of yacc.c  */
10121 #line 4113 "ripper.y"
10122     {
10123 #if 0
10124                         (yyval.val) = 0;
10125 #endif
10126                         (yyval.val) = dispatch0(qsymbols_new);
10127 
10128                     }
10129     break;
10130 
10131   case 478:
10132 
10133 /* Line 1806 of yacc.c  */
10134 #line 4121 "ripper.y"
10135     {
10136 #if 0
10137                         VALUE lit;
10138                         lit = (yyvsp[(2) - (3)].val)->nd_lit;
10139                         (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10140                         nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10141                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10142 #endif
10143                         (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10144 
10145                     }
10146     break;
10147 
10148   case 479:
10149 
10150 /* Line 1806 of yacc.c  */
10151 #line 4135 "ripper.y"
10152     {
10153 #if 0
10154                         (yyval.val) = 0;
10155 #endif
10156                         (yyval.val) = dispatch0(string_content);
10157 
10158                     }
10159     break;
10160 
10161   case 480:
10162 
10163 /* Line 1806 of yacc.c  */
10164 #line 4143 "ripper.y"
10165     {
10166 #if 0
10167                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10168 #endif
10169                         (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10170 
10171                     }
10172     break;
10173 
10174   case 481:
10175 
10176 /* Line 1806 of yacc.c  */
10177 #line 4153 "ripper.y"
10178     {
10179 #if 0
10180                         (yyval.val) = 0;
10181 #endif
10182                         (yyval.val) = dispatch0(xstring_new);
10183 
10184                     }
10185     break;
10186 
10187   case 482:
10188 
10189 /* Line 1806 of yacc.c  */
10190 #line 4161 "ripper.y"
10191     {
10192 #if 0
10193                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10194 #endif
10195                         (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10196 
10197                     }
10198     break;
10199 
10200   case 483:
10201 
10202 /* Line 1806 of yacc.c  */
10203 #line 4171 "ripper.y"
10204     {
10205 #if 0
10206                         (yyval.val) = 0;
10207 #endif
10208                         (yyval.val) = dispatch0(regexp_new);
10209 
10210                     }
10211     break;
10212 
10213   case 484:
10214 
10215 /* Line 1806 of yacc.c  */
10216 #line 4179 "ripper.y"
10217     {
10218 #if 0
10219                         NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10220                         if (!head) {
10221                             (yyval.val) = tail;
10222                         }
10223                         else if (!tail) {
10224                             (yyval.val) = head;
10225                         }
10226                         else {
10227                             switch (nd_type(head)) {
10228                               case NODE_STR:
10229                                 nd_set_type(head, NODE_DSTR);
10230                                 break;
10231                               case NODE_DSTR:
10232                                 break;
10233                               default:
10234                                 head = list_append(NEW_DSTR(Qnil), head);
10235                                 break;
10236                             }
10237                             (yyval.val) = list_append(head, tail);
10238                         }
10239 #endif
10240                         (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10241 
10242                     }
10243     break;
10244 
10245   case 486:
10246 
10247 /* Line 1806 of yacc.c  */
10248 #line 4209 "ripper.y"
10249     {
10250                         (yyval.node) = lex_strterm;
10251                         lex_strterm = 0;
10252                         lex_state = EXPR_BEG;
10253                     }
10254     break;
10255 
10256   case 487:
10257 
10258 /* Line 1806 of yacc.c  */
10259 #line 4215 "ripper.y"
10260     {
10261 #if 0
10262                         lex_strterm = (yyvsp[(2) - (3)].node);
10263                         (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10264 #endif
10265                         lex_strterm = (yyvsp[(2) - (3)].node);
10266                         (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10267 
10268                     }
10269     break;
10270 
10271   case 488:
10272 
10273 /* Line 1806 of yacc.c  */
10274 #line 4225 "ripper.y"
10275     {
10276                         (yyvsp[(1) - (1)].val) = cond_stack;
10277                         (yyval.val) = cmdarg_stack;
10278                         cond_stack = 0;
10279                         cmdarg_stack = 0;
10280                     }
10281     break;
10282 
10283   case 489:
10284 
10285 /* Line 1806 of yacc.c  */
10286 #line 4231 "ripper.y"
10287     {
10288                         (yyval.node) = lex_strterm;
10289                         lex_strterm = 0;
10290                         lex_state = EXPR_BEG;
10291                     }
10292     break;
10293 
10294   case 490:
10295 
10296 /* Line 1806 of yacc.c  */
10297 #line 4236 "ripper.y"
10298     {
10299                         (yyval.num) = brace_nest;
10300                         brace_nest = 0;
10301                     }
10302     break;
10303 
10304   case 491:
10305 
10306 /* Line 1806 of yacc.c  */
10307 #line 4241 "ripper.y"
10308     {
10309                         cond_stack = (yyvsp[(1) - (6)].val);
10310                         cmdarg_stack = (yyvsp[(2) - (6)].val);
10311                         lex_strterm = (yyvsp[(3) - (6)].node);
10312                         brace_nest = (yyvsp[(4) - (6)].num);
10313 #if 0
10314                         if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10315                         (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10316 #endif
10317                         (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10318 
10319                     }
10320     break;
10321 
10322   case 492:
10323 
10324 /* Line 1806 of yacc.c  */
10325 #line 4256 "ripper.y"
10326     {
10327 #if 0
10328                         (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10329 #endif
10330                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10331 
10332                     }
10333     break;
10334 
10335   case 493:
10336 
10337 /* Line 1806 of yacc.c  */
10338 #line 4264 "ripper.y"
10339     {
10340 #if 0
10341                         (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10342 #endif
10343                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10344 
10345                     }
10346     break;
10347 
10348   case 494:
10349 
10350 /* Line 1806 of yacc.c  */
10351 #line 4272 "ripper.y"
10352     {
10353 #if 0
10354                         (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10355 #endif
10356                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10357 
10358                     }
10359     break;
10360 
10361   case 496:
10362 
10363 /* Line 1806 of yacc.c  */
10364 #line 4283 "ripper.y"
10365     {
10366                         lex_state = EXPR_END;
10367 #if 0
10368                         (yyval.val) = (yyvsp[(2) - (2)].val);
10369 #endif
10370                         (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10371 
10372                     }
10373     break;
10374 
10375   case 501:
10376 
10377 /* Line 1806 of yacc.c  */
10378 #line 4300 "ripper.y"
10379     {
10380                         lex_state = EXPR_END;
10381 #if 0
10382                         (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10383 #endif
10384                         (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10385 
10386                     }
10387     break;
10388 
10389   case 503:
10390 
10391 /* Line 1806 of yacc.c  */
10392 #line 4312 "ripper.y"
10393     {
10394 #if 0
10395                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10396 #endif
10397                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10398 
10399                     }
10400     break;
10401 
10402   case 513:
10403 
10404 /* Line 1806 of yacc.c  */
10405 #line 4334 "ripper.y"
10406     {ifndef_ripper((yyval.val) = keyword_nil);}
10407     break;
10408 
10409   case 514:
10410 
10411 /* Line 1806 of yacc.c  */
10412 #line 4335 "ripper.y"
10413     {ifndef_ripper((yyval.val) = keyword_self);}
10414     break;
10415 
10416   case 515:
10417 
10418 /* Line 1806 of yacc.c  */
10419 #line 4336 "ripper.y"
10420     {ifndef_ripper((yyval.val) = keyword_true);}
10421     break;
10422 
10423   case 516:
10424 
10425 /* Line 1806 of yacc.c  */
10426 #line 4337 "ripper.y"
10427     {ifndef_ripper((yyval.val) = keyword_false);}
10428     break;
10429 
10430   case 517:
10431 
10432 /* Line 1806 of yacc.c  */
10433 #line 4338 "ripper.y"
10434     {ifndef_ripper((yyval.val) = keyword__FILE__);}
10435     break;
10436 
10437   case 518:
10438 
10439 /* Line 1806 of yacc.c  */
10440 #line 4339 "ripper.y"
10441     {ifndef_ripper((yyval.val) = keyword__LINE__);}
10442     break;
10443 
10444   case 519:
10445 
10446 /* Line 1806 of yacc.c  */
10447 #line 4340 "ripper.y"
10448     {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10449     break;
10450 
10451   case 520:
10452 
10453 /* Line 1806 of yacc.c  */
10454 #line 4344 "ripper.y"
10455     {
10456 #if 0
10457                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10458 #endif
10459                         if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10460                             (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10461                         }
10462                         else {
10463                             (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10464                         }
10465 
10466                     }
10467     break;
10468 
10469   case 521:
10470 
10471 /* Line 1806 of yacc.c  */
10472 #line 4357 "ripper.y"
10473     {
10474 #if 0
10475                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10476 #endif
10477                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10478 
10479                     }
10480     break;
10481 
10482   case 522:
10483 
10484 /* Line 1806 of yacc.c  */
10485 #line 4367 "ripper.y"
10486     {
10487                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10488 #if 0
10489 #endif
10490                         (yyval.val) = dispatch1(var_field, (yyval.val));
10491 
10492                     }
10493     break;
10494 
10495   case 523:
10496 
10497 /* Line 1806 of yacc.c  */
10498 #line 4375 "ripper.y"
10499     {
10500                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10501 #if 0
10502 #endif
10503                         (yyval.val) = dispatch1(var_field, (yyval.val));
10504 
10505                     }
10506     break;
10507 
10508   case 526:
10509 
10510 /* Line 1806 of yacc.c  */
10511 #line 4389 "ripper.y"
10512     {
10513 #if 0
10514                         (yyval.val) = 0;
10515 #endif
10516                         (yyval.val) = Qnil;
10517 
10518                     }
10519     break;
10520 
10521   case 527:
10522 
10523 /* Line 1806 of yacc.c  */
10524 #line 4397 "ripper.y"
10525     {
10526                         lex_state = EXPR_BEG;
10527                         command_start = TRUE;
10528                     }
10529     break;
10530 
10531   case 528:
10532 
10533 /* Line 1806 of yacc.c  */
10534 #line 4402 "ripper.y"
10535     {
10536                         (yyval.val) = (yyvsp[(3) - (4)].val);
10537                     }
10538     break;
10539 
10540   case 529:
10541 
10542 /* Line 1806 of yacc.c  */
10543 #line 4406 "ripper.y"
10544     {
10545 #if 0
10546                         yyerrok;
10547                         (yyval.val) = 0;
10548 #endif
10549                         yyerrok;
10550                         (yyval.val) = Qnil;
10551 
10552                     }
10553     break;
10554 
10555   case 530:
10556 
10557 /* Line 1806 of yacc.c  */
10558 #line 4418 "ripper.y"
10559     {
10560 #if 0
10561                         (yyval.val) = (yyvsp[(2) - (3)].val);
10562 #endif
10563                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10564 
10565                         lex_state = EXPR_BEG;
10566                         command_start = TRUE;
10567                     }
10568     break;
10569 
10570   case 531:
10571 
10572 /* Line 1806 of yacc.c  */
10573 #line 4427 "ripper.y"
10574     {
10575                         (yyval.num) = parser->parser_in_kwarg;
10576                         parser->parser_in_kwarg = 1;
10577                     }
10578     break;
10579 
10580   case 532:
10581 
10582 /* Line 1806 of yacc.c  */
10583 #line 4432 "ripper.y"
10584     {
10585                         parser->parser_in_kwarg = (yyvsp[(1) - (3)].num);
10586                         (yyval.val) = (yyvsp[(2) - (3)].val);
10587                         lex_state = EXPR_BEG;
10588                         command_start = TRUE;
10589                     }
10590     break;
10591 
10592   case 533:
10593 
10594 /* Line 1806 of yacc.c  */
10595 #line 4441 "ripper.y"
10596     {
10597                         (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10598                     }
10599     break;
10600 
10601   case 534:
10602 
10603 /* Line 1806 of yacc.c  */
10604 #line 4445 "ripper.y"
10605     {
10606                         (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10607                     }
10608     break;
10609 
10610   case 535:
10611 
10612 /* Line 1806 of yacc.c  */
10613 #line 4449 "ripper.y"
10614     {
10615                         (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10616                     }
10617     break;
10618 
10619   case 536:
10620 
10621 /* Line 1806 of yacc.c  */
10622 #line 4453 "ripper.y"
10623     {
10624                         (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10625                     }
10626     break;
10627 
10628   case 537:
10629 
10630 /* Line 1806 of yacc.c  */
10631 #line 4459 "ripper.y"
10632     {
10633                         (yyval.val) = (yyvsp[(2) - (2)].val);
10634                     }
10635     break;
10636 
10637   case 538:
10638 
10639 /* Line 1806 of yacc.c  */
10640 #line 4463 "ripper.y"
10641     {
10642                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10643                     }
10644     break;
10645 
10646   case 539:
10647 
10648 /* Line 1806 of yacc.c  */
10649 #line 4469 "ripper.y"
10650     {
10651                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10652                     }
10653     break;
10654 
10655   case 540:
10656 
10657 /* Line 1806 of yacc.c  */
10658 #line 4473 "ripper.y"
10659     {
10660                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10661                     }
10662     break;
10663 
10664   case 541:
10665 
10666 /* Line 1806 of yacc.c  */
10667 #line 4477 "ripper.y"
10668     {
10669                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10670                     }
10671     break;
10672 
10673   case 542:
10674 
10675 /* Line 1806 of yacc.c  */
10676 #line 4481 "ripper.y"
10677     {
10678                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10679                     }
10680     break;
10681 
10682   case 543:
10683 
10684 /* Line 1806 of yacc.c  */
10685 #line 4485 "ripper.y"
10686     {
10687                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10688                     }
10689     break;
10690 
10691   case 544:
10692 
10693 /* Line 1806 of yacc.c  */
10694 #line 4489 "ripper.y"
10695     {
10696                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10697                     }
10698     break;
10699 
10700   case 545:
10701 
10702 /* Line 1806 of yacc.c  */
10703 #line 4493 "ripper.y"
10704     {
10705                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10706                     }
10707     break;
10708 
10709   case 546:
10710 
10711 /* Line 1806 of yacc.c  */
10712 #line 4497 "ripper.y"
10713     {
10714                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10715                     }
10716     break;
10717 
10718   case 547:
10719 
10720 /* Line 1806 of yacc.c  */
10721 #line 4501 "ripper.y"
10722     {
10723                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10724                     }
10725     break;
10726 
10727   case 548:
10728 
10729 /* Line 1806 of yacc.c  */
10730 #line 4505 "ripper.y"
10731     {
10732                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10733                     }
10734     break;
10735 
10736   case 549:
10737 
10738 /* Line 1806 of yacc.c  */
10739 #line 4509 "ripper.y"
10740     {
10741                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10742                     }
10743     break;
10744 
10745   case 550:
10746 
10747 /* Line 1806 of yacc.c  */
10748 #line 4513 "ripper.y"
10749     {
10750                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10751                     }
10752     break;
10753 
10754   case 551:
10755 
10756 /* Line 1806 of yacc.c  */
10757 #line 4517 "ripper.y"
10758     {
10759                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10760                     }
10761     break;
10762 
10763   case 552:
10764 
10765 /* Line 1806 of yacc.c  */
10766 #line 4521 "ripper.y"
10767     {
10768                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10769                     }
10770     break;
10771 
10772   case 553:
10773 
10774 /* Line 1806 of yacc.c  */
10775 #line 4525 "ripper.y"
10776     {
10777                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10778                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10779                     }
10780     break;
10781 
10782   case 554:
10783 
10784 /* Line 1806 of yacc.c  */
10785 #line 4532 "ripper.y"
10786     {
10787 #if 0
10788                         yyerror("formal argument cannot be a constant");
10789                         (yyval.val) = 0;
10790 #endif
10791                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10792 
10793                     }
10794     break;
10795 
10796   case 555:
10797 
10798 /* Line 1806 of yacc.c  */
10799 #line 4541 "ripper.y"
10800     {
10801 #if 0
10802                         yyerror("formal argument cannot be an instance variable");
10803                         (yyval.val) = 0;
10804 #endif
10805                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10806 
10807                     }
10808     break;
10809 
10810   case 556:
10811 
10812 /* Line 1806 of yacc.c  */
10813 #line 4550 "ripper.y"
10814     {
10815 #if 0
10816                         yyerror("formal argument cannot be a global variable");
10817                         (yyval.val) = 0;
10818 #endif
10819                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10820 
10821                     }
10822     break;
10823 
10824   case 557:
10825 
10826 /* Line 1806 of yacc.c  */
10827 #line 4559 "ripper.y"
10828     {
10829 #if 0
10830                         yyerror("formal argument cannot be a class variable");
10831                         (yyval.val) = 0;
10832 #endif
10833                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10834 
10835                     }
10836     break;
10837 
10838   case 559:
10839 
10840 /* Line 1806 of yacc.c  */
10841 #line 4571 "ripper.y"
10842     {
10843                         formal_argument(get_id((yyvsp[(1) - (1)].val)));
10844                         (yyval.val) = (yyvsp[(1) - (1)].val);
10845                     }
10846     break;
10847 
10848   case 560:
10849 
10850 /* Line 1806 of yacc.c  */
10851 #line 4578 "ripper.y"
10852     {
10853                         arg_var(get_id((yyvsp[(1) - (1)].val)));
10854 #if 0
10855                         (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10856 #endif
10857                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10858 
10859                     }
10860     break;
10861 
10862   case 561:
10863 
10864 /* Line 1806 of yacc.c  */
10865 #line 4587 "ripper.y"
10866     {
10867                         ID tid = internal_id();
10868                         arg_var(tid);
10869 #if 0
10870                         if (dyna_in_block()) {
10871                             (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10872                         }
10873                         else {
10874                             (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10875                         }
10876                         (yyval.val) = NEW_ARGS_AUX(tid, 1);
10877                         (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10878 #endif
10879                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10880 
10881                     }
10882     break;
10883 
10884   case 562:
10885 
10886 /* Line 1806 of yacc.c  */
10887 #line 4608 "ripper.y"
10888     {
10889                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10890                     }
10891     break;
10892 
10893   case 563:
10894 
10895 /* Line 1806 of yacc.c  */
10896 #line 4613 "ripper.y"
10897     {
10898 #if 0
10899                         (yyval.val) = (yyvsp[(1) - (3)].val);
10900                         (yyval.val)->nd_plen++;
10901                         (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10902                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10903 #endif
10904                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10905 
10906                     }
10907     break;
10908 
10909   case 564:
10910 
10911 /* Line 1806 of yacc.c  */
10912 #line 4627 "ripper.y"
10913     {
10914                         arg_var(formal_argument(get_id((yyvsp[(1) - (1)].val))));
10915                         (yyval.val) = (yyvsp[(1) - (1)].val);
10916                     }
10917     break;
10918 
10919   case 565:
10920 
10921 /* Line 1806 of yacc.c  */
10922 #line 4634 "ripper.y"
10923     {
10924                         (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10925 #if 0
10926                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10927 #endif
10928                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10929 
10930                     }
10931     break;
10932 
10933   case 566:
10934 
10935 /* Line 1806 of yacc.c  */
10936 #line 4643 "ripper.y"
10937     {
10938                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1);
10939 #if 0
10940                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10941 #endif
10942                         (yyval.val) = rb_assoc_new((yyval.val), 0);
10943 
10944                     }
10945     break;
10946 
10947   case 567:
10948 
10949 /* Line 1806 of yacc.c  */
10950 #line 4654 "ripper.y"
10951     {
10952                         (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10953 #if 0
10954                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10955 #endif
10956                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10957 
10958                     }
10959     break;
10960 
10961   case 568:
10962 
10963 /* Line 1806 of yacc.c  */
10964 #line 4663 "ripper.y"
10965     {
10966                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1);
10967 #if 0
10968                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10969 #endif
10970                         (yyval.val) = rb_assoc_new((yyval.val), 0);
10971 
10972                     }
10973     break;
10974 
10975   case 569:
10976 
10977 /* Line 1806 of yacc.c  */
10978 #line 4674 "ripper.y"
10979     {
10980 #if 0
10981                         (yyval.val) = (yyvsp[(1) - (1)].val);
10982 #endif
10983                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10984 
10985                     }
10986     break;
10987 
10988   case 570:
10989 
10990 /* Line 1806 of yacc.c  */
10991 #line 4682 "ripper.y"
10992     {
10993 #if 0
10994                         NODE *kws = (yyvsp[(1) - (3)].val);
10995 
10996                         while (kws->nd_next) {
10997                             kws = kws->nd_next;
10998                         }
10999                         kws->nd_next = (yyvsp[(3) - (3)].val);
11000                         (yyval.val) = (yyvsp[(1) - (3)].val);
11001 #endif
11002                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11003 
11004                     }
11005     break;
11006 
11007   case 571:
11008 
11009 /* Line 1806 of yacc.c  */
11010 #line 4699 "ripper.y"
11011     {
11012 #if 0
11013                         (yyval.val) = (yyvsp[(1) - (1)].val);
11014 #endif
11015                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11016 
11017                     }
11018     break;
11019 
11020   case 572:
11021 
11022 /* Line 1806 of yacc.c  */
11023 #line 4707 "ripper.y"
11024     {
11025 #if 0
11026                         NODE *kws = (yyvsp[(1) - (3)].val);
11027 
11028                         while (kws->nd_next) {
11029                             kws = kws->nd_next;
11030                         }
11031                         kws->nd_next = (yyvsp[(3) - (3)].val);
11032                         (yyval.val) = (yyvsp[(1) - (3)].val);
11033 #endif
11034                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11035 
11036                     }
11037     break;
11038 
11039   case 575:
11040 
11041 /* Line 1806 of yacc.c  */
11042 #line 4727 "ripper.y"
11043     {
11044                         shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
11045                         (yyval.val) = (yyvsp[(2) - (2)].val);
11046                     }
11047     break;
11048 
11049   case 576:
11050 
11051 /* Line 1806 of yacc.c  */
11052 #line 4732 "ripper.y"
11053     {
11054                         (yyval.val) = internal_id();
11055                     }
11056     break;
11057 
11058   case 577:
11059 
11060 /* Line 1806 of yacc.c  */
11061 #line 4738 "ripper.y"
11062     {
11063                         arg_var(get_id((yyvsp[(1) - (3)].val)));
11064                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11065 #if 0
11066                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11067 #endif
11068                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11069 
11070                     }
11071     break;
11072 
11073   case 578:
11074 
11075 /* Line 1806 of yacc.c  */
11076 #line 4750 "ripper.y"
11077     {
11078                         arg_var(get_id((yyvsp[(1) - (3)].val)));
11079                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11080 #if 0
11081                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11082 #endif
11083                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11084 
11085                     }
11086     break;
11087 
11088   case 579:
11089 
11090 /* Line 1806 of yacc.c  */
11091 #line 4762 "ripper.y"
11092     {
11093 #if 0
11094                         (yyval.val) = (yyvsp[(1) - (1)].val);
11095 #endif
11096                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11097 
11098                     }
11099     break;
11100 
11101   case 580:
11102 
11103 /* Line 1806 of yacc.c  */
11104 #line 4770 "ripper.y"
11105     {
11106 #if 0
11107                         NODE *opts = (yyvsp[(1) - (3)].val);
11108 
11109                         while (opts->nd_next) {
11110                             opts = opts->nd_next;
11111                         }
11112                         opts->nd_next = (yyvsp[(3) - (3)].val);
11113                         (yyval.val) = (yyvsp[(1) - (3)].val);
11114 #endif
11115                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11116 
11117                     }
11118     break;
11119 
11120   case 581:
11121 
11122 /* Line 1806 of yacc.c  */
11123 #line 4786 "ripper.y"
11124     {
11125 #if 0
11126                         (yyval.val) = (yyvsp[(1) - (1)].val);
11127 #endif
11128                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11129 
11130                     }
11131     break;
11132 
11133   case 582:
11134 
11135 /* Line 1806 of yacc.c  */
11136 #line 4794 "ripper.y"
11137     {
11138 #if 0
11139                         NODE *opts = (yyvsp[(1) - (3)].val);
11140 
11141                         while (opts->nd_next) {
11142                             opts = opts->nd_next;
11143                         }
11144                         opts->nd_next = (yyvsp[(3) - (3)].val);
11145                         (yyval.val) = (yyvsp[(1) - (3)].val);
11146 #endif
11147                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11148 
11149                     }
11150     break;
11151 
11152   case 585:
11153 
11154 /* Line 1806 of yacc.c  */
11155 #line 4814 "ripper.y"
11156     {
11157 #if 0
11158                         if (!is_local_id((yyvsp[(2) - (2)].val)))
11159                             yyerror("rest argument must be local variable");
11160 #endif
11161                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11162 #if 0
11163                         (yyval.val) = (yyvsp[(2) - (2)].val);
11164 #endif
11165                         (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11166 
11167                     }
11168     break;
11169 
11170   case 586:
11171 
11172 /* Line 1806 of yacc.c  */
11173 #line 4827 "ripper.y"
11174     {
11175 #if 0
11176                         (yyval.val) = internal_id();
11177                         arg_var((yyval.val));
11178 #endif
11179                         (yyval.val) = dispatch1(rest_param, Qnil);
11180 
11181                     }
11182     break;
11183 
11184   case 589:
11185 
11186 /* Line 1806 of yacc.c  */
11187 #line 4842 "ripper.y"
11188     {
11189 #if 0
11190                         if (!is_local_id((yyvsp[(2) - (2)].val)))
11191                             yyerror("block argument must be local variable");
11192                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11193                             yyerror("duplicated block argument name");
11194 #endif
11195                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11196 #if 0
11197                         (yyval.val) = (yyvsp[(2) - (2)].val);
11198 #endif
11199                         (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11200 
11201                     }
11202     break;
11203 
11204   case 590:
11205 
11206 /* Line 1806 of yacc.c  */
11207 #line 4859 "ripper.y"
11208     {
11209                         (yyval.val) = (yyvsp[(2) - (2)].val);
11210                     }
11211     break;
11212 
11213   case 591:
11214 
11215 /* Line 1806 of yacc.c  */
11216 #line 4863 "ripper.y"
11217     {
11218 #if 0
11219                         (yyval.val) = 0;
11220 #endif
11221                         (yyval.val) = Qundef;
11222 
11223                     }
11224     break;
11225 
11226   case 592:
11227 
11228 /* Line 1806 of yacc.c  */
11229 #line 4873 "ripper.y"
11230     {
11231 #if 0
11232                         value_expr((yyvsp[(1) - (1)].val));
11233                         (yyval.val) = (yyvsp[(1) - (1)].val);
11234                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
11235 #endif
11236                         (yyval.val) = (yyvsp[(1) - (1)].val);
11237 
11238                     }
11239     break;
11240 
11241   case 593:
11242 
11243 /* Line 1806 of yacc.c  */
11244 #line 4882 "ripper.y"
11245     {lex_state = EXPR_BEG;}
11246     break;
11247 
11248   case 594:
11249 
11250 /* Line 1806 of yacc.c  */
11251 #line 4883 "ripper.y"
11252     {
11253 #if 0
11254                         if ((yyvsp[(3) - (4)].val) == 0) {
11255                             yyerror("can't define singleton method for ().");
11256                         }
11257                         else {
11258                             switch (nd_type((yyvsp[(3) - (4)].val))) {
11259                               case NODE_STR:
11260                               case NODE_DSTR:
11261                               case NODE_XSTR:
11262                               case NODE_DXSTR:
11263                               case NODE_DREGX:
11264                               case NODE_LIT:
11265                               case NODE_ARRAY:
11266                               case NODE_ZARRAY:
11267                                 yyerror("can't define singleton method for literals");
11268                               default:
11269                                 value_expr((yyvsp[(3) - (4)].val));
11270                                 break;
11271                             }
11272                         }
11273                         (yyval.val) = (yyvsp[(3) - (4)].val);
11274 #endif
11275                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11276 
11277                     }
11278     break;
11279 
11280   case 596:
11281 
11282 /* Line 1806 of yacc.c  */
11283 #line 4913 "ripper.y"
11284     {
11285 #if 0
11286                         (yyval.val) = (yyvsp[(1) - (2)].val);
11287 #endif
11288                         (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11289 
11290                     }
11291     break;
11292 
11293   case 597:
11294 
11295 /* Line 1806 of yacc.c  */
11296 #line 4925 "ripper.y"
11297     {
11298                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11299                     }
11300     break;
11301 
11302   case 598:
11303 
11304 /* Line 1806 of yacc.c  */
11305 #line 4930 "ripper.y"
11306     {
11307 #if 0
11308                         (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11309 #endif
11310                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11311 
11312                     }
11313     break;
11314 
11315   case 599:
11316 
11317 /* Line 1806 of yacc.c  */
11318 #line 4940 "ripper.y"
11319     {
11320 #if 0
11321                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_STR) {
11322                             nd_set_type((yyvsp[(1) - (3)].val), NODE_LIT);
11323                             (yyvsp[(1) - (3)].val)->nd_lit = rb_fstring((yyvsp[(1) - (3)].val)->nd_lit);
11324                         }
11325                         (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11326 #endif
11327                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11328 
11329                     }
11330     break;
11331 
11332   case 600:
11333 
11334 /* Line 1806 of yacc.c  */
11335 #line 4952 "ripper.y"
11336     {
11337 #if 0
11338                         (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11339 #endif
11340                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11341 
11342                     }
11343     break;
11344 
11345   case 601:
11346 
11347 /* Line 1806 of yacc.c  */
11348 #line 4960 "ripper.y"
11349     {
11350 #if 0
11351                         (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11352 #endif
11353                         (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11354 
11355                     }
11356     break;
11357 
11358   case 612:
11359 
11360 /* Line 1806 of yacc.c  */
11361 #line 4990 "ripper.y"
11362     { (yyval.val) = (yyvsp[(1) - (1)].val); }
11363     break;
11364 
11365   case 613:
11366 
11367 /* Line 1806 of yacc.c  */
11368 #line 4995 "ripper.y"
11369     { (yyval.val) = (yyvsp[(1) - (1)].val); }
11370     break;
11371 
11372   case 623:
11373 
11374 /* Line 1806 of yacc.c  */
11375 #line 5018 "ripper.y"
11376     {yyerrok;}
11377     break;
11378 
11379   case 626:
11380 
11381 /* Line 1806 of yacc.c  */
11382 #line 5023 "ripper.y"
11383     {yyerrok;}
11384     break;
11385 
11386   case 627:
11387 
11388 /* Line 1806 of yacc.c  */
11389 #line 5027 "ripper.y"
11390     {
11391 #if 0
11392                         (yyval.val) = 0;
11393 #endif
11394                         (yyval.val) = Qundef;
11395 
11396                     }
11397     break;
11398 
11399 
11400 
11401 /* Line 1806 of yacc.c  */
11402 #line 11401 "parse.c"
11403       default: break;
11404     }
11405   /* User semantic actions sometimes alter yychar, and that requires
11406      that yytoken be updated with the new translation.  We take the
11407      approach of translating immediately before every use of yytoken.
11408      One alternative is translating here after every semantic action,
11409      but that translation would be missed if the semantic action invokes
11410      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11411      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
11412      incorrect destructor might then be invoked immediately.  In the
11413      case of YYERROR or YYBACKUP, subsequent parser actions might lead
11414      to an incorrect destructor call or verbose syntax error message
11415      before the lookahead is translated.  */
11416   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11417 
11418   YYPOPSTACK (yylen);
11419   yylen = 0;
11420   YY_STACK_PRINT (yyss, yyssp);
11421 
11422   *++yyvsp = yyval;
11423 
11424   /* Now `shift' the result of the reduction.  Determine what state
11425      that goes to, based on the state we popped back to and the rule
11426      number reduced by.  */
11427 
11428   yyn = yyr1[yyn];
11429 
11430   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11431   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11432     yystate = yytable[yystate];
11433   else
11434     yystate = yydefgoto[yyn - YYNTOKENS];
11435 
11436   goto yynewstate;
11437 
11438 
11439 /*------------------------------------.
11440 | yyerrlab -- here on detecting error |
11441 `------------------------------------*/
11442 yyerrlab:
11443   /* Make sure we have latest lookahead translation.  See comments at
11444      user semantic actions for why this is necessary.  */
11445   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11446 
11447   /* If not already recovering from an error, report this error.  */
11448   if (!yyerrstatus)
11449     {
11450       ++yynerrs;
11451 #if ! YYERROR_VERBOSE
11452       parser_yyerror (parser, YY_("syntax error"));
11453 #else
11454 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11455                                         yyssp, yytoken)
11456       {
11457         char const *yymsgp = YY_("syntax error");
11458         int yysyntax_error_status;
11459         yysyntax_error_status = YYSYNTAX_ERROR;
11460         if (yysyntax_error_status == 0)
11461           yymsgp = yymsg;
11462         else if (yysyntax_error_status == 1)
11463           {
11464             if (yymsg != yymsgbuf)
11465               YYSTACK_FREE (yymsg);
11466             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11467             if (!yymsg)
11468               {
11469                 yymsg = yymsgbuf;
11470                 yymsg_alloc = sizeof yymsgbuf;
11471                 yysyntax_error_status = 2;
11472               }
11473             else
11474               {
11475                 yysyntax_error_status = YYSYNTAX_ERROR;
11476                 yymsgp = yymsg;
11477               }
11478           }
11479         parser_yyerror (parser, yymsgp);
11480         if (yysyntax_error_status == 2)
11481           goto yyexhaustedlab;
11482       }
11483 # undef YYSYNTAX_ERROR
11484 #endif
11485     }
11486 
11487 
11488 
11489   if (yyerrstatus == 3)
11490     {
11491       /* If just tried and failed to reuse lookahead token after an
11492          error, discard it.  */
11493 
11494       if (yychar <= YYEOF)
11495         {
11496           /* Return failure if at end of input.  */
11497           if (yychar == YYEOF)
11498             YYABORT;
11499         }
11500       else
11501         {
11502           yydestruct ("Error: discarding",
11503                       yytoken, &yylval, parser);
11504           yychar = YYEMPTY;
11505         }
11506     }
11507 
11508   /* Else will try to reuse lookahead token after shifting the error
11509      token.  */
11510   goto yyerrlab1;
11511 
11512 
11513 /*---------------------------------------------------.
11514 | yyerrorlab -- error raised explicitly by YYERROR.  |
11515 `---------------------------------------------------*/
11516 yyerrorlab:
11517 
11518   /* Pacify compilers like GCC when the user code never invokes
11519      YYERROR and the label yyerrorlab therefore never appears in user
11520      code.  */
11521   if (/*CONSTCOND*/ 0)
11522      goto yyerrorlab;
11523 
11524   /* Do not reclaim the symbols of the rule which action triggered
11525      this YYERROR.  */
11526   YYPOPSTACK (yylen);
11527   yylen = 0;
11528   YY_STACK_PRINT (yyss, yyssp);
11529   yystate = *yyssp;
11530   goto yyerrlab1;
11531 
11532 
11533 /*-------------------------------------------------------------.
11534 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
11535 `-------------------------------------------------------------*/
11536 yyerrlab1:
11537   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
11538 
11539   for (;;)
11540     {
11541       yyn = yypact[yystate];
11542       if (!yypact_value_is_default (yyn))
11543         {
11544           yyn += YYTERROR;
11545           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11546             {
11547               yyn = yytable[yyn];
11548               if (0 < yyn)
11549                 break;
11550             }
11551         }
11552 
11553       /* Pop the current state because it cannot handle the error token.  */
11554       if (yyssp == yyss)
11555         YYABORT;
11556 
11557 
11558       yydestruct ("Error: popping",
11559                   yystos[yystate], yyvsp, parser);
11560       YYPOPSTACK (1);
11561       yystate = *yyssp;
11562       YY_STACK_PRINT (yyss, yyssp);
11563     }
11564 
11565   *++yyvsp = yylval;
11566 
11567 
11568   /* Shift the error token.  */
11569   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11570 
11571   yystate = yyn;
11572   goto yynewstate;
11573 
11574 
11575 /*-------------------------------------.
11576 | yyacceptlab -- YYACCEPT comes here.  |
11577 `-------------------------------------*/
11578 yyacceptlab:
11579   yyresult = 0;
11580   goto yyreturn;
11581 
11582 /*-----------------------------------.
11583 | yyabortlab -- YYABORT comes here.  |
11584 `-----------------------------------*/
11585 yyabortlab:
11586   yyresult = 1;
11587   goto yyreturn;
11588 
11589 #if !defined(yyoverflow) || YYERROR_VERBOSE
11590 /*-------------------------------------------------.
11591 | yyexhaustedlab -- memory exhaustion comes here.  |
11592 `-------------------------------------------------*/
11593 yyexhaustedlab:
11594   parser_yyerror (parser, YY_("memory exhausted"));
11595   yyresult = 2;
11596   /* Fall through.  */
11597 #endif
11598 
11599 yyreturn:
11600   if (yychar != YYEMPTY)
11601     {
11602       /* Make sure we have latest lookahead translation.  See comments at
11603          user semantic actions for why this is necessary.  */
11604       yytoken = YYTRANSLATE (yychar);
11605       yydestruct ("Cleanup: discarding lookahead",
11606                   yytoken, &yylval, parser);
11607     }
11608   /* Do not reclaim the symbols of the rule which action triggered
11609      this YYABORT or YYACCEPT.  */
11610   YYPOPSTACK (yylen);
11611   YY_STACK_PRINT (yyss, yyssp);
11612   while (yyssp != yyss)
11613     {
11614       yydestruct ("Cleanup: popping",
11615                   yystos[*yyssp], yyvsp, parser);
11616       YYPOPSTACK (1);
11617     }
11618 #ifndef yyoverflow
11619   if (yyss != yyssa)
11620     YYSTACK_FREE (yyss);
11621 #endif
11622 #if YYERROR_VERBOSE
11623   if (yymsg != yymsgbuf)
11624     YYSTACK_FREE (yymsg);
11625 #endif
11626   /* Make sure YYID is used.  */
11627   return YYID (yyresult);
11628 }
11629 
11630 
11631 
11632 /* Line 2067 of yacc.c  */
11633 #line 5035 "ripper.y"
11634 
11635 # undef parser
11636 # undef yylex
11637 # undef yylval
11638 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
11639 
11640 static int parser_regx_options(struct parser_params*);
11641 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11642 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11643 static int parser_parse_string(struct parser_params*,NODE*);
11644 static int parser_here_document(struct parser_params*,NODE*);
11645 
11646 
11647 # define nextc()                      parser_nextc(parser)
11648 # define pushback(c)                  parser_pushback(parser, (c))
11649 # define newtok()                     parser_newtok(parser)
11650 # define tokspace(n)                  parser_tokspace(parser, (n))
11651 # define tokadd(c)                    parser_tokadd(parser, (c))
11652 # define tok_hex(numlen)              parser_tok_hex(parser, (numlen))
11653 # define read_escape(flags,e)         parser_read_escape(parser, (flags), (e))
11654 # define tokadd_escape(e)             parser_tokadd_escape(parser, (e))
11655 # define regx_options()               parser_regx_options(parser)
11656 # define tokadd_string(f,t,p,n,e)     parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11657 # define parse_string(n)              parser_parse_string(parser,(n))
11658 # define tokaddmbc(c, enc)            parser_tokaddmbc(parser, (c), (enc))
11659 # define here_document(n)             parser_here_document(parser,(n))
11660 # define heredoc_identifier()         parser_heredoc_identifier(parser)
11661 # define heredoc_restore(n)           parser_heredoc_restore(parser,(n))
11662 # define whole_match_p(e,l,i)         parser_whole_match_p(parser,(e),(l),(i))
11663 # define number_literal_suffix(f)     parser_number_literal_suffix(parser, (f))
11664 # define set_number_literal(v, t, f)  parser_set_number_literal(parser, (v), (t), (f))
11665 # define set_integer_literal(v, f)    parser_set_integer_literal(parser, (v), (f))
11666 
11667 #ifndef RIPPER
11668 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11669 # define set_yylval_num(x) (yylval.num = (x))
11670 # define set_yylval_id(x)  (yylval.id = (x))
11671 # define set_yylval_name(x)  (yylval.id = (x))
11672 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11673 # define set_yylval_node(x) (yylval.node = (x))
11674 # define yylval_id() (yylval.id)
11675 #else
11676 static inline VALUE
11677 ripper_yylval_id(ID x)
11678 {
11679     return (VALUE)NEW_LASGN(x, ID2SYM(x));
11680 }
11681 # define set_yylval_str(x) (void)(x)
11682 # define set_yylval_num(x) (void)(x)
11683 # define set_yylval_id(x)  (void)(x)
11684 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11685 # define set_yylval_literal(x) (void)(x)
11686 # define set_yylval_node(x) (void)(x)
11687 # define yylval_id() yylval.id
11688 #endif
11689 
11690 #ifndef RIPPER
11691 #define ripper_flush(p) (void)(p)
11692 #else
11693 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11694 
11695 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11696 
11697 static int
11698 ripper_has_scan_event(struct parser_params *parser)
11699 {
11700 
11701     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11702     return lex_p > parser->tokp;
11703 }
11704 
11705 static VALUE
11706 ripper_scan_event_val(struct parser_params *parser, int t)
11707 {
11708     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11709     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11710     ripper_flush(parser);
11711     return rval;
11712 }
11713 
11714 static void
11715 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11716 {
11717     if (!ripper_has_scan_event(parser)) return;
11718     yylval_rval = ripper_scan_event_val(parser, t);
11719 }
11720 
11721 static void
11722 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11723 {
11724     if (!ripper_has_scan_event(parser)) return;
11725     (void)ripper_scan_event_val(parser, t);
11726 }
11727 
11728 static void
11729 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11730 {
11731     int saved_line = ruby_sourceline;
11732     const char *saved_tokp = parser->tokp;
11733 
11734     ruby_sourceline = parser->delayed_line;
11735     parser->tokp = lex_pbeg + parser->delayed_col;
11736     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11737     parser->delayed = Qnil;
11738     ruby_sourceline = saved_line;
11739     parser->tokp = saved_tokp;
11740 }
11741 #endif /* RIPPER */
11742 
11743 #include "ruby/regex.h"
11744 #include "ruby/util.h"
11745 
11746 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11747    since ours (we hope) works properly with all combinations of
11748    machines, compilers, `char' and `unsigned char' argument types.
11749    (Per Bothner suggested the basic approach.)  */
11750 #undef SIGN_EXTEND_CHAR
11751 #if __STDC__
11752 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11753 #else  /* not __STDC__ */
11754 /* As in Harbison and Steele.  */
11755 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11756 #endif
11757 
11758 #define parser_encoding_name()  (current_enc->name)
11759 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,current_enc)
11760 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11761 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11762 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11763 
11764 #define parser_isascii() ISASCII(*(lex_p-1))
11765 
11766 #ifndef RIPPER
11767 static int
11768 token_info_get_column(struct parser_params *parser, const char *token)
11769 {
11770     int column = 1;
11771     const char *p, *pend = lex_p - strlen(token);
11772     for (p = lex_pbeg; p < pend; p++) {
11773         if (*p == '\t') {
11774             column = (((column - 1) / 8) + 1) * 8;
11775         }
11776         column++;
11777     }
11778     return column;
11779 }
11780 
11781 static int
11782 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11783 {
11784     const char *p, *pend = lex_p - strlen(token);
11785     for (p = lex_pbeg; p < pend; p++) {
11786         if (*p != ' ' && *p != '\t') {
11787             return 1;
11788         }
11789     }
11790     return 0;
11791 }
11792 
11793 #undef token_info_push
11794 static void
11795 token_info_push(struct parser_params *parser, const char *token)
11796 {
11797     token_info *ptinfo;
11798 
11799     if (!parser->parser_token_info_enabled) return;
11800     ptinfo = ALLOC(token_info);
11801     ptinfo->token = token;
11802     ptinfo->linenum = ruby_sourceline;
11803     ptinfo->column = token_info_get_column(parser, token);
11804     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11805     ptinfo->next = parser->parser_token_info;
11806 
11807     parser->parser_token_info = ptinfo;
11808 }
11809 
11810 #undef token_info_pop
11811 static void
11812 token_info_pop(struct parser_params *parser, const char *token)
11813 {
11814     int linenum;
11815     token_info *ptinfo = parser->parser_token_info;
11816 
11817     if (!ptinfo) return;
11818     parser->parser_token_info = ptinfo->next;
11819     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11820         goto finish;
11821     }
11822     linenum = ruby_sourceline;
11823     if (linenum == ptinfo->linenum) { /* SKIP */
11824         goto finish;
11825     }
11826     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11827         goto finish;
11828     }
11829     if (parser->parser_token_info_enabled) {
11830         rb_compile_warn(ruby_sourcefile, linenum,
11831                         "mismatched indentations at '%s' with '%s' at %d",
11832                         token, ptinfo->token, ptinfo->linenum);
11833     }
11834 
11835   finish:
11836     xfree(ptinfo);
11837 }
11838 #endif  /* RIPPER */
11839 
11840 static int
11841 parser_yyerror(struct parser_params *parser, const char *msg)
11842 {
11843 #ifndef RIPPER
11844     const int max_line_margin = 30;
11845     const char *p, *pe;
11846     char *buf;
11847     long len;
11848     int i;
11849 
11850     compile_error(PARSER_ARG "%s", msg);
11851     p = lex_p;
11852     while (lex_pbeg <= p) {
11853         if (*p == '\n') break;
11854         p--;
11855     }
11856     p++;
11857 
11858     pe = lex_p;
11859     while (pe < lex_pend) {
11860         if (*pe == '\n') break;
11861         pe++;
11862     }
11863 
11864     len = pe - p;
11865     if (len > 4) {
11866         char *p2;
11867         const char *pre = "", *post = "";
11868 
11869         if (len > max_line_margin * 2 + 10) {
11870             if (lex_p - p > max_line_margin) {
11871                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11872                 pre = "...";
11873             }
11874             if (pe - lex_p > max_line_margin) {
11875                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11876                 post = "...";
11877             }
11878             len = pe - p;
11879         }
11880         buf = ALLOCA_N(char, len+2);
11881         MEMCPY(buf, p, char, len);
11882         buf[len] = '\0';
11883         rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11884 
11885         i = (int)(lex_p - p);
11886         p2 = buf; pe = buf + len;
11887 
11888         while (p2 < pe) {
11889             if (*p2 != '\t') *p2 = ' ';
11890             p2++;
11891         }
11892         buf[i] = '^';
11893         buf[i+1] = '\0';
11894         rb_compile_error_append("%s%s", pre, buf);
11895     }
11896 #else
11897     dispatch1(parse_error, STR_NEW2(msg));
11898 #endif /* !RIPPER */
11899     return 0;
11900 }
11901 
11902 static void parser_prepare(struct parser_params *parser);
11903 
11904 #ifndef RIPPER
11905 static VALUE
11906 debug_lines(VALUE fname)
11907 {
11908     ID script_lines;
11909     CONST_ID(script_lines, "SCRIPT_LINES__");
11910     if (rb_const_defined_at(rb_cObject, script_lines)) {
11911         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11912         if (RB_TYPE_P(hash, T_HASH)) {
11913             VALUE lines = rb_ary_new();
11914             rb_hash_aset(hash, fname, lines);
11915             return lines;
11916         }
11917     }
11918     return 0;
11919 }
11920 
11921 static VALUE
11922 coverage(VALUE fname, int n)
11923 {
11924     VALUE coverages = rb_get_coverages();
11925     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11926         VALUE lines = rb_ary_new2(n);
11927         int i;
11928         RBASIC_CLEAR_CLASS(lines);
11929         for (i = 0; i < n; i++) RARRAY_ASET(lines, i, Qnil);
11930         RARRAY(lines)->as.heap.len = n;
11931         rb_hash_aset(coverages, fname, lines);
11932         return lines;
11933     }
11934     return 0;
11935 }
11936 
11937 static int
11938 e_option_supplied(struct parser_params *parser)
11939 {
11940     return strcmp(ruby_sourcefile, "-e") == 0;
11941 }
11942 
11943 static VALUE
11944 yycompile0(VALUE arg)
11945 {
11946     int n;
11947     NODE *tree;
11948     struct parser_params *parser = (struct parser_params *)arg;
11949 
11950     if (!compile_for_eval && rb_safe_level() == 0) {
11951         ruby_debug_lines = debug_lines(ruby_sourcefile_string);
11952         if (ruby_debug_lines && ruby_sourceline > 0) {
11953             VALUE str = STR_NEW0();
11954             n = ruby_sourceline;
11955             do {
11956                 rb_ary_push(ruby_debug_lines, str);
11957             } while (--n);
11958         }
11959 
11960         if (!e_option_supplied(parser)) {
11961             ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
11962         }
11963     }
11964     parser->last_cr_line = ruby_sourceline - 1;
11965 
11966     parser_prepare(parser);
11967     deferred_nodes = 0;
11968 #ifndef RIPPER
11969     parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
11970 #endif
11971 #ifndef RIPPER
11972     if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
11973         RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
11974                                 parser->parser_ruby_sourceline);
11975     }
11976 #endif
11977     n = yyparse((void*)parser);
11978 #ifndef RIPPER
11979     if (RUBY_DTRACE_PARSE_END_ENABLED()) {
11980         RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
11981                               parser->parser_ruby_sourceline);
11982     }
11983 #endif
11984     ruby_debug_lines = 0;
11985     ruby_coverage = 0;
11986     compile_for_eval = 0;
11987 
11988     lex_strterm = 0;
11989     lex_p = lex_pbeg = lex_pend = 0;
11990     lex_lastline = lex_nextline = 0;
11991     if (parser->nerr) {
11992         return 0;
11993     }
11994     tree = ruby_eval_tree;
11995     if (!tree) {
11996         tree = NEW_NIL();
11997     }
11998     else if (ruby_eval_tree_begin) {
11999         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
12000     }
12001     return (VALUE)tree;
12002 }
12003 
12004 static NODE*
12005 yycompile(struct parser_params *parser, VALUE fname, int line)
12006 {
12007     ruby_sourcefile_string = rb_str_new_frozen(fname);
12008     ruby_sourcefile = RSTRING_PTR(fname);
12009     ruby_sourceline = line - 1;
12010     return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
12011 }
12012 #endif /* !RIPPER */
12013 
12014 static rb_encoding *
12015 must_be_ascii_compatible(VALUE s)
12016 {
12017     rb_encoding *enc = rb_enc_get(s);
12018     if (!rb_enc_asciicompat(enc)) {
12019         rb_raise(rb_eArgError, "invalid source encoding");
12020     }
12021     return enc;
12022 }
12023 
12024 static VALUE
12025 lex_get_str(struct parser_params *parser, VALUE s)
12026 {
12027     char *beg, *end, *pend;
12028     rb_encoding *enc = must_be_ascii_compatible(s);
12029 
12030     beg = RSTRING_PTR(s);
12031     if (lex_gets_ptr) {
12032         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
12033         beg += lex_gets_ptr;
12034     }
12035     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
12036     end = beg;
12037     while (end < pend) {
12038         if (*end++ == '\n') break;
12039     }
12040     lex_gets_ptr = end - RSTRING_PTR(s);
12041     return rb_enc_str_new(beg, end - beg, enc);
12042 }
12043 
12044 static VALUE
12045 lex_getline(struct parser_params *parser)
12046 {
12047     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
12048     if (NIL_P(line)) return line;
12049     must_be_ascii_compatible(line);
12050 #ifndef RIPPER
12051     if (ruby_debug_lines) {
12052         rb_enc_associate(line, current_enc);
12053         rb_ary_push(ruby_debug_lines, line);
12054     }
12055     if (ruby_coverage) {
12056         rb_ary_push(ruby_coverage, Qnil);
12057     }
12058 #endif
12059     return line;
12060 }
12061 
12062 #ifdef RIPPER
12063 static rb_data_type_t parser_data_type;
12064 #else
12065 static const rb_data_type_t parser_data_type;
12066 
12067 static NODE*
12068 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
12069 {
12070     struct parser_params *parser;
12071     NODE *node;
12072 
12073     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12074     lex_gets = lex_get_str;
12075     lex_gets_ptr = 0;
12076     lex_input = s;
12077     lex_pbeg = lex_p = lex_pend = 0;
12078     compile_for_eval = rb_parse_in_eval();
12079 
12080     node = yycompile(parser, fname, line);
12081     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12082 
12083     return node;
12084 }
12085 
12086 NODE*
12087 rb_compile_string(const char *f, VALUE s, int line)
12088 {
12089     must_be_ascii_compatible(s);
12090     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
12091 }
12092 
12093 NODE*
12094 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12095 {
12096     return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12097 }
12098 
12099 NODE*
12100 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
12101 {
12102     must_be_ascii_compatible(s);
12103     return parser_compile_string(vparser, f, s, line);
12104 }
12105 
12106 NODE*
12107 rb_compile_cstr(const char *f, const char *s, int len, int line)
12108 {
12109     VALUE str = rb_str_new(s, len);
12110     return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
12111 }
12112 
12113 NODE*
12114 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12115 {
12116     VALUE str = rb_str_new(s, len);
12117     return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12118 }
12119 
12120 static VALUE
12121 lex_io_gets(struct parser_params *parser, VALUE io)
12122 {
12123     return rb_io_gets(io);
12124 }
12125 
12126 NODE*
12127 rb_compile_file(const char *f, VALUE file, int start)
12128 {
12129     VALUE volatile vparser = rb_parser_new();
12130 
12131     return rb_parser_compile_file(vparser, f, file, start);
12132 }
12133 
12134 NODE*
12135 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12136 {
12137     return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12138 }
12139 
12140 NODE*
12141 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12142 {
12143     struct parser_params *parser;
12144     NODE *node;
12145 
12146     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12147     lex_gets = lex_io_gets;
12148     lex_input = file;
12149     lex_pbeg = lex_p = lex_pend = 0;
12150     compile_for_eval = rb_parse_in_eval();
12151 
12152     node = yycompile(parser, fname, start);
12153     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12154 
12155     return node;
12156 }
12157 #endif  /* !RIPPER */
12158 
12159 #define STR_FUNC_ESCAPE 0x01
12160 #define STR_FUNC_EXPAND 0x02
12161 #define STR_FUNC_REGEXP 0x04
12162 #define STR_FUNC_QWORDS 0x08
12163 #define STR_FUNC_SYMBOL 0x10
12164 #define STR_FUNC_INDENT 0x20
12165 
12166 enum string_type {
12167     str_squote = (0),
12168     str_dquote = (STR_FUNC_EXPAND),
12169     str_xquote = (STR_FUNC_EXPAND),
12170     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
12171     str_sword  = (STR_FUNC_QWORDS),
12172     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
12173     str_ssym   = (STR_FUNC_SYMBOL),
12174     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
12175 };
12176 
12177 static VALUE
12178 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12179 {
12180     VALUE str;
12181 
12182     str = rb_enc_str_new(p, n, enc);
12183     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12184         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
12185         }
12186         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12187             rb_enc_associate(str, rb_ascii8bit_encoding());
12188         }
12189     }
12190 
12191     return str;
12192 }
12193 
12194 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12195 #define lex_eol_p() (lex_p >= lex_pend)
12196 #define peek(c) peek_n((c), 0)
12197 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12198 
12199 static inline int
12200 parser_nextc(struct parser_params *parser)
12201 {
12202     int c;
12203 
12204     if (lex_p == lex_pend) {
12205         VALUE v = lex_nextline;
12206         lex_nextline = 0;
12207         if (!v) {
12208             if (parser->eofp)
12209                 return -1;
12210 
12211             if (!lex_input || NIL_P(v = lex_getline(parser))) {
12212                 parser->eofp = Qtrue;
12213                 lex_goto_eol(parser);
12214                 return -1;
12215             }
12216         }
12217         {
12218 #ifdef RIPPER
12219             if (parser->tokp < lex_pend) {
12220                 if (NIL_P(parser->delayed)) {
12221                     parser->delayed = rb_str_buf_new(1024);
12222                     rb_enc_associate(parser->delayed, current_enc);
12223                     rb_str_buf_cat(parser->delayed,
12224                                    parser->tokp, lex_pend - parser->tokp);
12225                     parser->delayed_line = ruby_sourceline;
12226                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12227                 }
12228                 else {
12229                     rb_str_buf_cat(parser->delayed,
12230                                    parser->tokp, lex_pend - parser->tokp);
12231                 }
12232             }
12233 #endif
12234             if (heredoc_end > 0) {
12235                 ruby_sourceline = heredoc_end;
12236                 heredoc_end = 0;
12237             }
12238             ruby_sourceline++;
12239             parser->line_count++;
12240             lex_pbeg = lex_p = RSTRING_PTR(v);
12241             lex_pend = lex_p + RSTRING_LEN(v);
12242             ripper_flush(parser);
12243             lex_lastline = v;
12244         }
12245     }
12246     c = (unsigned char)*lex_p++;
12247     if (c == '\r') {
12248         if (peek('\n')) {
12249             lex_p++;
12250             c = '\n';
12251         }
12252         else if (ruby_sourceline > parser->last_cr_line) {
12253             parser->last_cr_line = ruby_sourceline;
12254             rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space");
12255         }
12256     }
12257 
12258     return c;
12259 }
12260 
12261 static void
12262 parser_pushback(struct parser_params *parser, int c)
12263 {
12264     if (c == -1) return;
12265     lex_p--;
12266     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12267         lex_p--;
12268     }
12269 }
12270 
12271 #define was_bol() (lex_p == lex_pbeg + 1)
12272 
12273 #define tokfix() (tokenbuf[tokidx]='\0')
12274 #define tok() tokenbuf
12275 #define toklen() tokidx
12276 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12277 
12278 static char*
12279 parser_newtok(struct parser_params *parser)
12280 {
12281     tokidx = 0;
12282     tokline = ruby_sourceline;
12283     if (!tokenbuf) {
12284         toksiz = 60;
12285         tokenbuf = ALLOC_N(char, 60);
12286     }
12287     if (toksiz > 4096) {
12288         toksiz = 60;
12289         REALLOC_N(tokenbuf, char, 60);
12290     }
12291     return tokenbuf;
12292 }
12293 
12294 static char *
12295 parser_tokspace(struct parser_params *parser, int n)
12296 {
12297     tokidx += n;
12298 
12299     if (tokidx >= toksiz) {
12300         do {toksiz *= 2;} while (toksiz < tokidx);
12301         REALLOC_N(tokenbuf, char, toksiz);
12302     }
12303     return &tokenbuf[tokidx-n];
12304 }
12305 
12306 static void
12307 parser_tokadd(struct parser_params *parser, int c)
12308 {
12309     tokenbuf[tokidx++] = (char)c;
12310     if (tokidx >= toksiz) {
12311         toksiz *= 2;
12312         REALLOC_N(tokenbuf, char, toksiz);
12313     }
12314 }
12315 
12316 static int
12317 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12318 {
12319     int c;
12320 
12321     c = scan_hex(lex_p, 2, numlen);
12322     if (!*numlen) {
12323         yyerror("invalid hex escape");
12324         return 0;
12325     }
12326     lex_p += *numlen;
12327     return c;
12328 }
12329 
12330 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12331 
12332 /* return value is for ?\u3042 */
12333 static int
12334 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
12335                    int string_literal, int symbol_literal, int regexp_literal)
12336 {
12337     /*
12338      * If string_literal is true, then we allow multiple codepoints
12339      * in \u{}, and add the codepoints to the current token.
12340      * Otherwise we're parsing a character literal and return a single
12341      * codepoint without adding it
12342      */
12343 
12344     int codepoint;
12345     size_t numlen;
12346 
12347     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12348 
12349     if (peek('{')) {  /* handle \u{...} form */
12350         do {
12351             if (regexp_literal) { tokadd(*lex_p); }
12352             nextc();
12353             codepoint = scan_hex(lex_p, 6, &numlen);
12354             if (numlen == 0)  {
12355                 yyerror("invalid Unicode escape");
12356                 return 0;
12357             }
12358             if (codepoint > 0x10ffff) {
12359                 yyerror("invalid Unicode codepoint (too large)");
12360                 return 0;
12361             }
12362             lex_p += numlen;
12363             if (regexp_literal) {
12364                 tokcopy((int)numlen);
12365             }
12366             else if (codepoint >= 0x80) {
12367                 *encp = rb_utf8_encoding();
12368                 if (string_literal) tokaddmbc(codepoint, *encp);
12369             }
12370             else if (string_literal) {
12371                 tokadd(codepoint);
12372             }
12373         } while (string_literal && (peek(' ') || peek('\t')));
12374 
12375         if (!peek('}')) {
12376             yyerror("unterminated Unicode escape");
12377             return 0;
12378         }
12379 
12380         if (regexp_literal) { tokadd('}'); }
12381         nextc();
12382     }
12383     else {                      /* handle \uxxxx form */
12384         codepoint = scan_hex(lex_p, 4, &numlen);
12385         if (numlen < 4) {
12386             yyerror("invalid Unicode escape");
12387             return 0;
12388         }
12389         lex_p += 4;
12390         if (regexp_literal) {
12391             tokcopy(4);
12392         }
12393         else if (codepoint >= 0x80) {
12394             *encp = rb_utf8_encoding();
12395             if (string_literal) tokaddmbc(codepoint, *encp);
12396         }
12397         else if (string_literal) {
12398             tokadd(codepoint);
12399         }
12400     }
12401 
12402     return codepoint;
12403 }
12404 
12405 #define ESCAPE_CONTROL 1
12406 #define ESCAPE_META    2
12407 
12408 static int
12409 parser_read_escape(struct parser_params *parser, int flags,
12410                    rb_encoding **encp)
12411 {
12412     int c;
12413     size_t numlen;
12414 
12415     switch (c = nextc()) {
12416       case '\\':        /* Backslash */
12417         return c;
12418 
12419       case 'n': /* newline */
12420         return '\n';
12421 
12422       case 't': /* horizontal tab */
12423         return '\t';
12424 
12425       case 'r': /* carriage-return */
12426         return '\r';
12427 
12428       case 'f': /* form-feed */
12429         return '\f';
12430 
12431       case 'v': /* vertical tab */
12432         return '\13';
12433 
12434       case 'a': /* alarm(bell) */
12435         return '\007';
12436 
12437       case 'e': /* escape */
12438         return 033;
12439 
12440       case '0': case '1': case '2': case '3': /* octal constant */
12441       case '4': case '5': case '6': case '7':
12442         pushback(c);
12443         c = scan_oct(lex_p, 3, &numlen);
12444         lex_p += numlen;
12445         return c;
12446 
12447       case 'x': /* hex constant */
12448         c = tok_hex(&numlen);
12449         if (numlen == 0) return 0;
12450         return c;
12451 
12452       case 'b': /* backspace */
12453         return '\010';
12454 
12455       case 's': /* space */
12456         return ' ';
12457 
12458       case 'M':
12459         if (flags & ESCAPE_META) goto eof;
12460         if ((c = nextc()) != '-') {
12461             pushback(c);
12462             goto eof;
12463         }
12464         if ((c = nextc()) == '\\') {
12465             if (peek('u')) goto eof;
12466             return read_escape(flags|ESCAPE_META, encp) | 0x80;
12467         }
12468         else if (c == -1 || !ISASCII(c)) goto eof;
12469         else {
12470             return ((c & 0xff) | 0x80);
12471         }
12472 
12473       case 'C':
12474         if ((c = nextc()) != '-') {
12475             pushback(c);
12476             goto eof;
12477         }
12478       case 'c':
12479         if (flags & ESCAPE_CONTROL) goto eof;
12480         if ((c = nextc())== '\\') {
12481             if (peek('u')) goto eof;
12482             c = read_escape(flags|ESCAPE_CONTROL, encp);
12483         }
12484         else if (c == '?')
12485             return 0177;
12486         else if (c == -1 || !ISASCII(c)) goto eof;
12487         return c & 0x9f;
12488 
12489       eof:
12490       case -1:
12491         yyerror("Invalid escape character syntax");
12492         return '\0';
12493 
12494       default:
12495         return c;
12496     }
12497 }
12498 
12499 static void
12500 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
12501 {
12502     int len = rb_enc_codelen(c, enc);
12503     rb_enc_mbcput(c, tokspace(len), enc);
12504 }
12505 
12506 static int
12507 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
12508 {
12509     int c;
12510     int flags = 0;
12511     size_t numlen;
12512 
12513   first:
12514     switch (c = nextc()) {
12515       case '\n':
12516         return 0;               /* just ignore */
12517 
12518       case '0': case '1': case '2': case '3': /* octal constant */
12519       case '4': case '5': case '6': case '7':
12520         {
12521             ruby_scan_oct(--lex_p, 3, &numlen);
12522             if (numlen == 0) goto eof;
12523             lex_p += numlen;
12524             tokcopy((int)numlen + 1);
12525         }
12526         return 0;
12527 
12528       case 'x': /* hex constant */
12529         {
12530             tok_hex(&numlen);
12531             if (numlen == 0) return -1;
12532             tokcopy((int)numlen + 2);
12533         }
12534         return 0;
12535 
12536       case 'M':
12537         if (flags & ESCAPE_META) goto eof;
12538         if ((c = nextc()) != '-') {
12539             pushback(c);
12540             goto eof;
12541         }
12542         tokcopy(3);
12543         flags |= ESCAPE_META;
12544         goto escaped;
12545 
12546       case 'C':
12547         if (flags & ESCAPE_CONTROL) goto eof;
12548         if ((c = nextc()) != '-') {
12549             pushback(c);
12550             goto eof;
12551         }
12552         tokcopy(3);
12553         goto escaped;
12554 
12555       case 'c':
12556         if (flags & ESCAPE_CONTROL) goto eof;
12557         tokcopy(2);
12558         flags |= ESCAPE_CONTROL;
12559       escaped:
12560         if ((c = nextc()) == '\\') {
12561             goto first;
12562         }
12563         else if (c == -1) goto eof;
12564         tokadd(c);
12565         return 0;
12566 
12567       eof:
12568       case -1:
12569         yyerror("Invalid escape character syntax");
12570         return -1;
12571 
12572       default:
12573         tokadd('\\');
12574         tokadd(c);
12575     }
12576     return 0;
12577 }
12578 
12579 static int
12580 parser_regx_options(struct parser_params *parser)
12581 {
12582     int kcode = 0;
12583     int kopt = 0;
12584     int options = 0;
12585     int c, opt, kc;
12586 
12587     newtok();
12588     while (c = nextc(), ISALPHA(c)) {
12589         if (c == 'o') {
12590             options |= RE_OPTION_ONCE;
12591         }
12592         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12593             if (kc >= 0) {
12594                 if (kc != rb_ascii8bit_encindex()) kcode = c;
12595                 kopt = opt;
12596             }
12597             else {
12598                 options |= opt;
12599             }
12600         }
12601         else {
12602             tokadd(c);
12603         }
12604     }
12605     options |= kopt;
12606     pushback(c);
12607     if (toklen()) {
12608         tokfix();
12609         compile_error(PARSER_ARG "unknown regexp option%s - %s",
12610                       toklen() > 1 ? "s" : "", tok());
12611     }
12612     return options | RE_OPTION_ENCODING(kcode);
12613 }
12614 
12615 static void
12616 dispose_string(VALUE str)
12617 {
12618     rb_str_free(str);
12619     rb_gc_force_recycle(str);
12620 }
12621 
12622 static int
12623 parser_tokadd_mbchar(struct parser_params *parser, int c)
12624 {
12625     int len = parser_precise_mbclen();
12626     if (!MBCLEN_CHARFOUND_P(len)) {
12627         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12628         return -1;
12629     }
12630     tokadd(c);
12631     lex_p += --len;
12632     if (len > 0) tokcopy(len);
12633     return c;
12634 }
12635 
12636 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12637 
12638 static inline int
12639 simple_re_meta(int c)
12640 {
12641     switch (c) {
12642       case '$': case '*': case '+': case '.':
12643       case '?': case '^': case '|':
12644       case ')': case ']': case '}': case '>':
12645         return TRUE;
12646       default:
12647         return FALSE;
12648     }
12649 }
12650 
12651 static int
12652 parser_tokadd_string(struct parser_params *parser,
12653                      int func, int term, int paren, long *nest,
12654                      rb_encoding **encp)
12655 {
12656     int c;
12657     int has_nonascii = 0;
12658     rb_encoding *enc = *encp;
12659     char *errbuf = 0;
12660     static const char mixed_msg[] = "%s mixed within %s source";
12661 
12662 #define mixed_error(enc1, enc2) if (!errbuf) {  \
12663         size_t len = sizeof(mixed_msg) - 4;     \
12664         len += strlen(rb_enc_name(enc1));       \
12665         len += strlen(rb_enc_name(enc2));       \
12666         errbuf = ALLOCA_N(char, len);           \
12667         snprintf(errbuf, len, mixed_msg,        \
12668                  rb_enc_name(enc1),             \
12669                  rb_enc_name(enc2));            \
12670         yyerror(errbuf);                        \
12671     }
12672 #define mixed_escape(beg, enc1, enc2) do {      \
12673         const char *pos = lex_p;                \
12674         lex_p = (beg);                          \
12675         mixed_error((enc1), (enc2));            \
12676         lex_p = pos;                            \
12677     } while (0)
12678 
12679     while ((c = nextc()) != -1) {
12680         if (paren && c == paren) {
12681             ++*nest;
12682         }
12683         else if (c == term) {
12684             if (!nest || !*nest) {
12685                 pushback(c);
12686                 break;
12687             }
12688             --*nest;
12689         }
12690         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12691             int c2 = *lex_p;
12692             if (c2 == '$' || c2 == '@' || c2 == '{') {
12693                 pushback(c);
12694                 break;
12695             }
12696         }
12697         else if (c == '\\') {
12698             const char *beg = lex_p - 1;
12699             c = nextc();
12700             switch (c) {
12701               case '\n':
12702                 if (func & STR_FUNC_QWORDS) break;
12703                 if (func & STR_FUNC_EXPAND) continue;
12704                 tokadd('\\');
12705                 break;
12706 
12707               case '\\':
12708                 if (func & STR_FUNC_ESCAPE) tokadd(c);
12709                 break;
12710 
12711               case 'u':
12712                 if ((func & STR_FUNC_EXPAND) == 0) {
12713                     tokadd('\\');
12714                     break;
12715                 }
12716                 parser_tokadd_utf8(parser, &enc, 1,
12717                                    func & STR_FUNC_SYMBOL,
12718                                    func & STR_FUNC_REGEXP);
12719                 if (has_nonascii && enc != *encp) {
12720                     mixed_escape(beg, enc, *encp);
12721                 }
12722                 continue;
12723 
12724               default:
12725                 if (c == -1) return -1;
12726                 if (!ISASCII(c)) {
12727                     if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12728                     goto non_ascii;
12729                 }
12730                 if (func & STR_FUNC_REGEXP) {
12731                     if (c == term && !simple_re_meta(c)) {
12732                         tokadd(c);
12733                         continue;
12734                     }
12735                     pushback(c);
12736                     if ((c = tokadd_escape(&enc)) < 0)
12737                         return -1;
12738                     if (has_nonascii && enc != *encp) {
12739                         mixed_escape(beg, enc, *encp);
12740                     }
12741                     continue;
12742                 }
12743                 else if (func & STR_FUNC_EXPAND) {
12744                     pushback(c);
12745                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
12746                     c = read_escape(0, &enc);
12747                 }
12748                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12749                     /* ignore backslashed spaces in %w */
12750                 }
12751                 else if (c != term && !(paren && c == paren)) {
12752                     tokadd('\\');
12753                     pushback(c);
12754                     continue;
12755                 }
12756             }
12757         }
12758         else if (!parser_isascii()) {
12759           non_ascii:
12760             has_nonascii = 1;
12761             if (enc != *encp) {
12762                 mixed_error(enc, *encp);
12763                 continue;
12764             }
12765             if (tokadd_mbchar(c) == -1) return -1;
12766             continue;
12767         }
12768         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12769             pushback(c);
12770             break;
12771         }
12772         if (c & 0x80) {
12773             has_nonascii = 1;
12774             if (enc != *encp) {
12775                 mixed_error(enc, *encp);
12776                 continue;
12777             }
12778         }
12779         tokadd(c);
12780     }
12781     *encp = enc;
12782     return c;
12783 }
12784 
12785 #define NEW_STRTERM(func, term, paren) \
12786         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12787 
12788 #ifdef RIPPER
12789 static void
12790 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12791 {
12792     if (!NIL_P(parser->delayed)) {
12793         ptrdiff_t len = lex_p - parser->tokp;
12794         if (len > 0) {
12795             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12796         }
12797         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12798         parser->tokp = lex_p;
12799     }
12800 }
12801 
12802 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12803 #else
12804 #define flush_string_content(enc) ((void)(enc))
12805 #endif
12806 
12807 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12808 /* this can be shared with ripper, since it's independent from struct
12809  * parser_params. */
12810 #ifndef RIPPER
12811 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12812 #define SPECIAL_PUNCT(idx) ( \
12813         BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12814         BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12815         BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12816         BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12817         BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12818         BIT('0', idx))
12819 const unsigned int ruby_global_name_punct_bits[] = {
12820     SPECIAL_PUNCT(0),
12821     SPECIAL_PUNCT(1),
12822     SPECIAL_PUNCT(2),
12823 };
12824 #undef BIT
12825 #undef SPECIAL_PUNCT
12826 #endif
12827 
12828 static inline int
12829 is_global_name_punct(const int c)
12830 {
12831     if (c <= 0x20 || 0x7e < c) return 0;
12832     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12833 }
12834 
12835 static int
12836 parser_peek_variable_name(struct parser_params *parser)
12837 {
12838     int c;
12839     const char *p = lex_p;
12840 
12841     if (p + 1 >= lex_pend) return 0;
12842     c = *p++;
12843     switch (c) {
12844       case '$':
12845         if ((c = *p) == '-') {
12846             if (++p >= lex_pend) return 0;
12847             c = *p;
12848         }
12849         else if (is_global_name_punct(c) || ISDIGIT(c)) {
12850             return tSTRING_DVAR;
12851         }
12852         break;
12853       case '@':
12854         if ((c = *p) == '@') {
12855             if (++p >= lex_pend) return 0;
12856             c = *p;
12857         }
12858         break;
12859       case '{':
12860         lex_p = p;
12861         command_start = TRUE;
12862         return tSTRING_DBEG;
12863       default:
12864         return 0;
12865     }
12866     if (!ISASCII(c) || c == '_' || ISALPHA(c))
12867         return tSTRING_DVAR;
12868     return 0;
12869 }
12870 
12871 static int
12872 parser_parse_string(struct parser_params *parser, NODE *quote)
12873 {
12874     int func = (int)quote->nd_func;
12875     int term = nd_term(quote);
12876     int paren = nd_paren(quote);
12877     int c, space = 0;
12878     rb_encoding *enc = current_enc;
12879 
12880     if (func == -1) return tSTRING_END;
12881     c = nextc();
12882     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12883         do {c = nextc();} while (ISSPACE(c));
12884         space = 1;
12885     }
12886     if (c == term && !quote->nd_nest) {
12887         if (func & STR_FUNC_QWORDS) {
12888             quote->nd_func = -1;
12889             return ' ';
12890         }
12891         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12892         set_yylval_num(regx_options());
12893         return tREGEXP_END;
12894     }
12895     if (space) {
12896         pushback(c);
12897         return ' ';
12898     }
12899     newtok();
12900     if ((func & STR_FUNC_EXPAND) && c == '#') {
12901         int t = parser_peek_variable_name(parser);
12902         if (t) return t;
12903         tokadd('#');
12904         c = nextc();
12905     }
12906     pushback(c);
12907     if (tokadd_string(func, term, paren, &quote->nd_nest,
12908                       &enc) == -1) {
12909         ruby_sourceline = nd_line(quote);
12910         if (func & STR_FUNC_REGEXP) {
12911             if (parser->eofp)
12912                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
12913             return tREGEXP_END;
12914         }
12915         else {
12916             if (parser->eofp)
12917                 compile_error(PARSER_ARG "unterminated string meets end of file");
12918             return tSTRING_END;
12919         }
12920     }
12921 
12922     tokfix();
12923     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12924     flush_string_content(enc);
12925 
12926     return tSTRING_CONTENT;
12927 }
12928 
12929 static int
12930 parser_heredoc_identifier(struct parser_params *parser)
12931 {
12932     int c = nextc(), term, func = 0;
12933     long len;
12934 
12935     if (c == '-') {
12936         c = nextc();
12937         func = STR_FUNC_INDENT;
12938     }
12939     switch (c) {
12940       case '\'':
12941         func |= str_squote; goto quoted;
12942       case '"':
12943         func |= str_dquote; goto quoted;
12944       case '`':
12945         func |= str_xquote;
12946       quoted:
12947         newtok();
12948         tokadd(func);
12949         term = c;
12950         while ((c = nextc()) != -1 && c != term) {
12951             if (tokadd_mbchar(c) == -1) return 0;
12952         }
12953         if (c == -1) {
12954             compile_error(PARSER_ARG "unterminated here document identifier");
12955             return 0;
12956         }
12957         break;
12958 
12959       default:
12960         if (!parser_is_identchar()) {
12961             pushback(c);
12962             if (func & STR_FUNC_INDENT) {
12963                 pushback('-');
12964             }
12965             return 0;
12966         }
12967         newtok();
12968         term = '"';
12969         tokadd(func |= str_dquote);
12970         do {
12971             if (tokadd_mbchar(c) == -1) return 0;
12972         } while ((c = nextc()) != -1 && parser_is_identchar());
12973         pushback(c);
12974         break;
12975     }
12976 
12977     tokfix();
12978 #ifdef RIPPER
12979     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12980 #endif
12981     len = lex_p - lex_pbeg;
12982     lex_goto_eol(parser);
12983     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12984                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12985                                   len,                          /* nd_nth */
12986                                   lex_lastline);                /* nd_orig */
12987     nd_set_line(lex_strterm, ruby_sourceline);
12988     ripper_flush(parser);
12989     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12990 }
12991 
12992 static void
12993 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12994 {
12995     VALUE line;
12996 
12997     lex_strterm = 0;
12998     line = here->nd_orig;
12999     lex_lastline = line;
13000     lex_pbeg = RSTRING_PTR(line);
13001     lex_pend = lex_pbeg + RSTRING_LEN(line);
13002     lex_p = lex_pbeg + here->nd_nth;
13003     heredoc_end = ruby_sourceline;
13004     ruby_sourceline = nd_line(here);
13005     dispose_string(here->nd_lit);
13006     rb_gc_force_recycle((VALUE)here);
13007     ripper_flush(parser);
13008 }
13009 
13010 static int
13011 parser_whole_match_p(struct parser_params *parser,
13012     const char *eos, long len, int indent)
13013 {
13014     const char *p = lex_pbeg;
13015     long n;
13016 
13017     if (indent) {
13018         while (*p && ISSPACE(*p)) p++;
13019     }
13020     n = lex_pend - (p + len);
13021     if (n < 0) return FALSE;
13022     if (n > 0 && p[len] != '\n') {
13023         if (p[len] != '\r') return FALSE;
13024         if (n <= 1 || p[len+1] != '\n') return FALSE;
13025     }
13026     return strncmp(eos, p, len) == 0;
13027 }
13028 
13029 #define NUM_SUFFIX_R   (1<<0)
13030 #define NUM_SUFFIX_I   (1<<1)
13031 #define NUM_SUFFIX_ALL 3
13032 
13033 static int
13034 parser_number_literal_suffix(struct parser_params *parser, int mask)
13035 {
13036     int c, result = 0;
13037     const char *lastp = lex_p;
13038 
13039     while ((c = nextc()) != -1) {
13040         if ((mask & NUM_SUFFIX_I) && c == 'i') {
13041             result |= (mask & NUM_SUFFIX_I);
13042             mask &= ~NUM_SUFFIX_I;
13043             /* r after i, rational of complex is disallowed */
13044             mask &= ~NUM_SUFFIX_R;
13045             continue;
13046         }
13047         if ((mask & NUM_SUFFIX_R) && c == 'r') {
13048             result |= (mask & NUM_SUFFIX_R);
13049             mask &= ~NUM_SUFFIX_R;
13050             continue;
13051         }
13052         if (!ISASCII(c) || ISALPHA(c) || c == '_') {
13053             lex_p = lastp;
13054             return 0;
13055         }
13056         pushback(c);
13057         break;
13058     }
13059     return result;
13060 }
13061 
13062 static int
13063 parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
13064 {
13065     if (suffix & NUM_SUFFIX_I) {
13066         v = rb_complex_raw(INT2FIX(0), v);
13067         type = tIMAGINARY;
13068     }
13069     set_yylval_literal(v);
13070     return type;
13071 }
13072 
13073 static int
13074 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
13075 {
13076     int type = tINTEGER;
13077     if (suffix & NUM_SUFFIX_R) {
13078         v = rb_rational_raw1(v);
13079         type = tRATIONAL;
13080     }
13081     return set_number_literal(v, type, suffix);
13082 }
13083 
13084 #ifdef RIPPER
13085 static void
13086 ripper_dispatch_heredoc_end(struct parser_params *parser)
13087 {
13088     if (!NIL_P(parser->delayed))
13089         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13090     lex_goto_eol(parser);
13091     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
13092 }
13093 
13094 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
13095 #else
13096 #define dispatch_heredoc_end() ((void)0)
13097 #endif
13098 
13099 static int
13100 parser_here_document(struct parser_params *parser, NODE *here)
13101 {
13102     int c, func, indent = 0;
13103     const char *eos, *p, *pend;
13104     long len;
13105     VALUE str = 0;
13106     rb_encoding *enc = current_enc;
13107 
13108     eos = RSTRING_PTR(here->nd_lit);
13109     len = RSTRING_LEN(here->nd_lit) - 1;
13110     indent = (func = *eos++) & STR_FUNC_INDENT;
13111 
13112     if ((c = nextc()) == -1) {
13113       error:
13114         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
13115 #ifdef RIPPER
13116         if (NIL_P(parser->delayed)) {
13117             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
13118         }
13119         else {
13120             if (str ||
13121                 ((len = lex_p - parser->tokp) > 0 &&
13122                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
13123                 rb_str_append(parser->delayed, str);
13124             }
13125             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13126         }
13127         lex_goto_eol(parser);
13128 #endif
13129       restore:
13130         heredoc_restore(lex_strterm);
13131         return 0;
13132     }
13133     if (was_bol() && whole_match_p(eos, len, indent)) {
13134         dispatch_heredoc_end();
13135         heredoc_restore(lex_strterm);
13136         return tSTRING_END;
13137     }
13138 
13139     if (!(func & STR_FUNC_EXPAND)) {
13140         do {
13141             p = RSTRING_PTR(lex_lastline);
13142             pend = lex_pend;
13143             if (pend > p) {
13144                 switch (pend[-1]) {
13145                   case '\n':
13146                     if (--pend == p || pend[-1] != '\r') {
13147                         pend++;
13148                         break;
13149                     }
13150                   case '\r':
13151                     --pend;
13152                 }
13153             }
13154             if (str)
13155                 rb_str_cat(str, p, pend - p);
13156             else
13157                 str = STR_NEW(p, pend - p);
13158             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13159             lex_goto_eol(parser);
13160             if (nextc() == -1) {
13161                 if (str) {
13162                     dispose_string(str);
13163                     str = 0;
13164                 }
13165                 goto error;
13166             }
13167         } while (!whole_match_p(eos, len, indent));
13168     }
13169     else {
13170         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13171         newtok();
13172         if (c == '#') {
13173             int t = parser_peek_variable_name(parser);
13174             if (t) return t;
13175             tokadd('#');
13176             c = nextc();
13177         }
13178         do {
13179             pushback(c);
13180             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13181                 if (parser->eofp) goto error;
13182                 goto restore;
13183             }
13184             if (c != '\n') {
13185                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13186                 flush_string_content(enc);
13187                 return tSTRING_CONTENT;
13188             }
13189             tokadd(nextc());
13190             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13191             if ((c = nextc()) == -1) goto error;
13192         } while (!whole_match_p(eos, len, indent));
13193         str = STR_NEW3(tok(), toklen(), enc, func);
13194     }
13195     dispatch_heredoc_end();
13196     heredoc_restore(lex_strterm);
13197     lex_strterm = NEW_STRTERM(-1, 0, 0);
13198     set_yylval_str(str);
13199     return tSTRING_CONTENT;
13200 }
13201 
13202 #include "lex.c"
13203 
13204 static void
13205 arg_ambiguous_gen(struct parser_params *parser)
13206 {
13207 #ifndef RIPPER
13208     rb_warning0("ambiguous first argument; put parentheses or even spaces");
13209 #else
13210     dispatch0(arg_ambiguous);
13211 #endif
13212 }
13213 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13214 
13215 static ID
13216 formal_argument_gen(struct parser_params *parser, ID lhs)
13217 {
13218 #ifndef RIPPER
13219     if (!is_local_id(lhs))
13220         yyerror("formal argument must be local variable");
13221 #endif
13222     shadowing_lvar(lhs);
13223     return lhs;
13224 }
13225 
13226 static int
13227 lvar_defined_gen(struct parser_params *parser, ID id)
13228 {
13229     return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13230 }
13231 
13232 /* emacsen -*- hack */
13233 static long
13234 parser_encode_length(struct parser_params *parser, const char *name, long len)
13235 {
13236     long nlen;
13237 
13238     if (len > 5 && name[nlen = len - 5] == '-') {
13239         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13240             return nlen;
13241     }
13242     if (len > 4 && name[nlen = len - 4] == '-') {
13243         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13244             return nlen;
13245         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13246             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13247             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13248             return nlen;
13249     }
13250     return len;
13251 }
13252 
13253 static void
13254 parser_set_encode(struct parser_params *parser, const char *name)
13255 {
13256     int idx = rb_enc_find_index(name);
13257     rb_encoding *enc;
13258     VALUE excargs[3];
13259 
13260     if (idx < 0) {
13261         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13262       error:
13263         excargs[0] = rb_eArgError;
13264         excargs[2] = rb_make_backtrace();
13265         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13266         rb_exc_raise(rb_make_exception(3, excargs));
13267     }
13268     enc = rb_enc_from_index(idx);
13269     if (!rb_enc_asciicompat(enc)) {
13270         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13271         goto error;
13272     }
13273     parser->enc = enc;
13274 #ifndef RIPPER
13275     if (ruby_debug_lines) {
13276         VALUE lines = ruby_debug_lines;
13277         long i, n = RARRAY_LEN(lines);
13278         for (i = 0; i < n; ++i) {
13279             rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13280         }
13281     }
13282 #endif
13283 }
13284 
13285 static int
13286 comment_at_top(struct parser_params *parser)
13287 {
13288     const char *p = lex_pbeg, *pend = lex_p - 1;
13289     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13290     while (p < pend) {
13291         if (!ISSPACE(*p)) return 0;
13292         p++;
13293     }
13294     return 1;
13295 }
13296 
13297 #ifndef RIPPER
13298 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13299 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13300 
13301 static void
13302 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13303 {
13304     if (!comment_at_top(parser)) {
13305         return;
13306     }
13307     parser_set_encode(parser, val);
13308 }
13309 
13310 static void
13311 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13312 {
13313     int *p = &parser->parser_token_info_enabled;
13314 
13315     switch (*val) {
13316       case 't': case 'T':
13317         if (strcasecmp(val, "true") == 0) {
13318             *p = TRUE;
13319             return;
13320         }
13321         break;
13322       case 'f': case 'F':
13323         if (strcasecmp(val, "false") == 0) {
13324             *p = FALSE;
13325             return;
13326         }
13327         break;
13328     }
13329     rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13330 }
13331 
13332 struct magic_comment {
13333     const char *name;
13334     rb_magic_comment_setter_t func;
13335     rb_magic_comment_length_t length;
13336 };
13337 
13338 static const struct magic_comment magic_comments[] = {
13339     {"coding", magic_comment_encoding, parser_encode_length},
13340     {"encoding", magic_comment_encoding, parser_encode_length},
13341     {"warn_indent", parser_set_token_info},
13342 };
13343 #endif
13344 
13345 static const char *
13346 magic_comment_marker(const char *str, long len)
13347 {
13348     long i = 2;
13349 
13350     while (i < len) {
13351         switch (str[i]) {
13352           case '-':
13353             if (str[i-1] == '*' && str[i-2] == '-') {
13354                 return str + i + 1;
13355             }
13356             i += 2;
13357             break;
13358           case '*':
13359             if (i + 1 >= len) return 0;
13360             if (str[i+1] != '-') {
13361                 i += 4;
13362             }
13363             else if (str[i-1] != '-') {
13364                 i += 2;
13365             }
13366             else {
13367                 return str + i + 2;
13368             }
13369             break;
13370           default:
13371             i += 3;
13372             break;
13373         }
13374     }
13375     return 0;
13376 }
13377 
13378 static int
13379 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13380 {
13381     VALUE name = 0, val = 0;
13382     const char *beg, *end, *vbeg, *vend;
13383 #define str_copy(_s, _p, _n) ((_s) \
13384         ? (void)(rb_str_resize((_s), (_n)), \
13385            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13386         : (void)((_s) = STR_NEW((_p), (_n))))
13387 
13388     if (len <= 7) return FALSE;
13389     if (!(beg = magic_comment_marker(str, len))) return FALSE;
13390     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13391     str = beg;
13392     len = end - beg - 3;
13393 
13394     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13395     while (len > 0) {
13396 #ifndef RIPPER
13397         const struct magic_comment *p = magic_comments;
13398 #endif
13399         char *s;
13400         int i;
13401         long n = 0;
13402 
13403         for (; len > 0 && *str; str++, --len) {
13404             switch (*str) {
13405               case '\'': case '"': case ':': case ';':
13406                 continue;
13407             }
13408             if (!ISSPACE(*str)) break;
13409         }
13410         for (beg = str; len > 0; str++, --len) {
13411             switch (*str) {
13412               case '\'': case '"': case ':': case ';':
13413                 break;
13414               default:
13415                 if (ISSPACE(*str)) break;
13416                 continue;
13417             }
13418             break;
13419         }
13420         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13421         if (!len) break;
13422         if (*str != ':') continue;
13423 
13424         do str++; while (--len > 0 && ISSPACE(*str));
13425         if (!len) break;
13426         if (*str == '"') {
13427             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13428                 if (*str == '\\') {
13429                     --len;
13430                     ++str;
13431                 }
13432             }
13433             vend = str;
13434             if (len) {
13435                 --len;
13436                 ++str;
13437             }
13438         }
13439         else {
13440             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13441             vend = str;
13442         }
13443         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13444 
13445         n = end - beg;
13446         str_copy(name, beg, n);
13447         s = RSTRING_PTR(name);
13448         for (i = 0; i < n; ++i) {
13449             if (s[i] == '-') s[i] = '_';
13450         }
13451 #ifndef RIPPER
13452         do {
13453             if (STRNCASECMP(p->name, s, n) == 0) {
13454                 n = vend - vbeg;
13455                 if (p->length) {
13456                     n = (*p->length)(parser, vbeg, n);
13457                 }
13458                 str_copy(val, vbeg, n);
13459                 (*p->func)(parser, s, RSTRING_PTR(val));
13460                 break;
13461             }
13462         } while (++p < magic_comments + numberof(magic_comments));
13463 #else
13464         str_copy(val, vbeg, vend - vbeg);
13465         dispatch2(magic_comment, name, val);
13466 #endif
13467     }
13468 
13469     return TRUE;
13470 }
13471 
13472 static void
13473 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13474 {
13475     int sep = 0;
13476     const char *beg = str;
13477     VALUE s;
13478 
13479     for (;;) {
13480         if (send - str <= 6) return;
13481         switch (str[6]) {
13482           case 'C': case 'c': str += 6; continue;
13483           case 'O': case 'o': str += 5; continue;
13484           case 'D': case 'd': str += 4; continue;
13485           case 'I': case 'i': str += 3; continue;
13486           case 'N': case 'n': str += 2; continue;
13487           case 'G': case 'g': str += 1; continue;
13488           case '=': case ':':
13489             sep = 1;
13490             str += 6;
13491             break;
13492           default:
13493             str += 6;
13494             if (ISSPACE(*str)) break;
13495             continue;
13496         }
13497         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13498     }
13499     for (;;) {
13500         do {
13501             if (++str >= send) return;
13502         } while (ISSPACE(*str));
13503         if (sep) break;
13504         if (*str != '=' && *str != ':') return;
13505         sep = 1;
13506         str++;
13507     }
13508     beg = str;
13509     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13510     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13511     parser_set_encode(parser, RSTRING_PTR(s));
13512     rb_str_resize(s, 0);
13513 }
13514 
13515 static void
13516 parser_prepare(struct parser_params *parser)
13517 {
13518     int c = nextc();
13519     switch (c) {
13520       case '#':
13521         if (peek('!')) parser->has_shebang = 1;
13522         break;
13523       case 0xef:                /* UTF-8 BOM marker */
13524         if (lex_pend - lex_p >= 2 &&
13525             (unsigned char)lex_p[0] == 0xbb &&
13526             (unsigned char)lex_p[1] == 0xbf) {
13527             parser->enc = rb_utf8_encoding();
13528             lex_p += 2;
13529             lex_pbeg = lex_p;
13530             return;
13531         }
13532         break;
13533       case EOF:
13534         return;
13535     }
13536     pushback(c);
13537     parser->enc = rb_enc_get(lex_lastline);
13538 }
13539 
13540 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13541 #define IS_END() IS_lex_state(EXPR_END_ANY)
13542 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13543 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13544 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13545 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13546 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13547 
13548 #ifndef RIPPER
13549 #define ambiguous_operator(op, syn) ( \
13550     rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13551     rb_warning0("even though it seems like "syn""))
13552 #else
13553 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13554 #endif
13555 #define warn_balanced(op, syn) ((void) \
13556     (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13557      space_seen && !ISSPACE(c) && \
13558      (ambiguous_operator(op, syn), 0)))
13559 
13560 static int
13561 parse_numvar(struct parser_params *parser)
13562 {
13563     size_t len;
13564     int overflow;
13565     unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow);
13566     const unsigned long nth_ref_max =
13567         ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
13568     /* NTH_REF is left-shifted to be ORed with back-ref flag and
13569      * turned into a Fixnum, in compile.c */
13570 
13571     if (overflow || n > nth_ref_max) {
13572         /* compile_error()? */
13573         rb_warnS("`%s' is too big for a number variable, always nil", tok());
13574         return 0;               /* $0 is $PROGRAM_NAME, not NTH_REF */
13575     }
13576     else {
13577         return (int)n;
13578     }
13579 }
13580 
13581 static int
13582 parser_yylex(struct parser_params *parser)
13583 {
13584     register int c;
13585     int space_seen = 0;
13586     int cmd_state;
13587     enum lex_state_e last_state;
13588     rb_encoding *enc;
13589     int mb;
13590 #ifdef RIPPER
13591     int fallthru = FALSE;
13592 #endif
13593 
13594     if (lex_strterm) {
13595         int token;
13596         if (nd_type(lex_strterm) == NODE_HEREDOC) {
13597             token = here_document(lex_strterm);
13598             if (token == tSTRING_END) {
13599                 lex_strterm = 0;
13600                 lex_state = EXPR_END;
13601             }
13602         }
13603         else {
13604             token = parse_string(lex_strterm);
13605             if (token == tSTRING_END || token == tREGEXP_END) {
13606                 rb_gc_force_recycle((VALUE)lex_strterm);
13607                 lex_strterm = 0;
13608                 lex_state = EXPR_END;
13609             }
13610         }
13611         return token;
13612     }
13613     cmd_state = command_start;
13614     command_start = FALSE;
13615   retry:
13616     last_state = lex_state;
13617     switch (c = nextc()) {
13618       case '\0':                /* NUL */
13619       case '\004':              /* ^D */
13620       case '\032':              /* ^Z */
13621       case -1:                  /* end of script. */
13622         return 0;
13623 
13624         /* white spaces */
13625       case ' ': case '\t': case '\f': case '\r':
13626       case '\13': /* '\v' */
13627         space_seen = 1;
13628 #ifdef RIPPER
13629         while ((c = nextc())) {
13630             switch (c) {
13631               case ' ': case '\t': case '\f': case '\r':
13632               case '\13': /* '\v' */
13633                 break;
13634               default:
13635                 goto outofloop;
13636             }
13637         }
13638       outofloop:
13639         pushback(c);
13640         ripper_dispatch_scan_event(parser, tSP);
13641 #endif
13642         goto retry;
13643 
13644       case '#':         /* it's a comment */
13645         /* no magic_comment in shebang line */
13646         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13647             if (comment_at_top(parser)) {
13648                 set_file_encoding(parser, lex_p, lex_pend);
13649             }
13650         }
13651         lex_p = lex_pend;
13652 #ifdef RIPPER
13653         ripper_dispatch_scan_event(parser, tCOMMENT);
13654         fallthru = TRUE;
13655 #endif
13656         /* fall through */
13657       case '\n':
13658         if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
13659 #ifdef RIPPER
13660             if (!fallthru) {
13661                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
13662             }
13663             fallthru = FALSE;
13664 #endif
13665             if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
13666                 goto normal_newline;
13667             }
13668             goto retry;
13669         }
13670         while ((c = nextc())) {
13671             switch (c) {
13672               case ' ': case '\t': case '\f': case '\r':
13673               case '\13': /* '\v' */
13674                 space_seen = 1;
13675                 break;
13676               case '.': {
13677                   if ((c = nextc()) != '.') {
13678                       pushback(c);
13679                       pushback('.');
13680                       goto retry;
13681                   }
13682               }
13683               default:
13684                 --ruby_sourceline;
13685                 lex_nextline = lex_lastline;
13686               case -1:          /* EOF no decrement*/
13687                 lex_goto_eol(parser);
13688 #ifdef RIPPER
13689                 if (c != -1) {
13690                     parser->tokp = lex_p;
13691                 }
13692 #endif
13693                 goto normal_newline;
13694             }
13695         }
13696       normal_newline:
13697         command_start = TRUE;
13698         lex_state = EXPR_BEG;
13699         return '\n';
13700 
13701       case '*':
13702         if ((c = nextc()) == '*') {
13703             if ((c = nextc()) == '=') {
13704                 set_yylval_id(tPOW);
13705                 lex_state = EXPR_BEG;
13706                 return tOP_ASGN;
13707             }
13708             pushback(c);
13709             if (IS_SPCARG(c)) {
13710                 rb_warning0("`**' interpreted as argument prefix");
13711                 c = tDSTAR;
13712             }
13713             else if (IS_BEG()) {
13714                 c = tDSTAR;
13715             }
13716             else {
13717                 warn_balanced("**", "argument prefix");
13718                 c = tPOW;
13719             }
13720         }
13721         else {
13722             if (c == '=') {
13723                 set_yylval_id('*');
13724                 lex_state = EXPR_BEG;
13725                 return tOP_ASGN;
13726             }
13727             pushback(c);
13728             if (IS_SPCARG(c)) {
13729                 rb_warning0("`*' interpreted as argument prefix");
13730                 c = tSTAR;
13731             }
13732             else if (IS_BEG()) {
13733                 c = tSTAR;
13734             }
13735             else {
13736                 warn_balanced("*", "argument prefix");
13737                 c = '*';
13738             }
13739         }
13740         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13741         return c;
13742 
13743       case '!':
13744         c = nextc();
13745         if (IS_AFTER_OPERATOR()) {
13746             lex_state = EXPR_ARG;
13747             if (c == '@') {
13748                 return '!';
13749             }
13750         }
13751         else {
13752             lex_state = EXPR_BEG;
13753         }
13754         if (c == '=') {
13755             return tNEQ;
13756         }
13757         if (c == '~') {
13758             return tNMATCH;
13759         }
13760         pushback(c);
13761         return '!';
13762 
13763       case '=':
13764         if (was_bol()) {
13765             /* skip embedded rd document */
13766             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13767 #ifdef RIPPER
13768                 int first_p = TRUE;
13769 
13770                 lex_goto_eol(parser);
13771                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13772 #endif
13773                 for (;;) {
13774                     lex_goto_eol(parser);
13775 #ifdef RIPPER
13776                     if (!first_p) {
13777                         ripper_dispatch_scan_event(parser, tEMBDOC);
13778                     }
13779                     first_p = FALSE;
13780 #endif
13781                     c = nextc();
13782                     if (c == -1) {
13783                         compile_error(PARSER_ARG "embedded document meets end of file");
13784                         return 0;
13785                     }
13786                     if (c != '=') continue;
13787                     if (strncmp(lex_p, "end", 3) == 0 &&
13788                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13789                         break;
13790                     }
13791                 }
13792                 lex_goto_eol(parser);
13793 #ifdef RIPPER
13794                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
13795 #endif
13796                 goto retry;
13797             }
13798         }
13799 
13800         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13801         if ((c = nextc()) == '=') {
13802             if ((c = nextc()) == '=') {
13803                 return tEQQ;
13804             }
13805             pushback(c);
13806             return tEQ;
13807         }
13808         if (c == '~') {
13809             return tMATCH;
13810         }
13811         else if (c == '>') {
13812             return tASSOC;
13813         }
13814         pushback(c);
13815         return '=';
13816 
13817       case '<':
13818         last_state = lex_state;
13819         c = nextc();
13820         if (c == '<' &&
13821             !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13822             !IS_END() &&
13823             (!IS_ARG() || space_seen)) {
13824             int token = heredoc_identifier();
13825             if (token) return token;
13826         }
13827         if (IS_AFTER_OPERATOR()) {
13828             lex_state = EXPR_ARG;
13829         }
13830         else {
13831             if (IS_lex_state(EXPR_CLASS))
13832                 command_start = TRUE;
13833             lex_state = EXPR_BEG;
13834         }
13835         if (c == '=') {
13836             if ((c = nextc()) == '>') {
13837                 return tCMP;
13838             }
13839             pushback(c);
13840             return tLEQ;
13841         }
13842         if (c == '<') {
13843             if ((c = nextc()) == '=') {
13844                 set_yylval_id(tLSHFT);
13845                 lex_state = EXPR_BEG;
13846                 return tOP_ASGN;
13847             }
13848             pushback(c);
13849             warn_balanced("<<", "here document");
13850             return tLSHFT;
13851         }
13852         pushback(c);
13853         return '<';
13854 
13855       case '>':
13856         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13857         if ((c = nextc()) == '=') {
13858             return tGEQ;
13859         }
13860         if (c == '>') {
13861             if ((c = nextc()) == '=') {
13862                 set_yylval_id(tRSHFT);
13863                 lex_state = EXPR_BEG;
13864                 return tOP_ASGN;
13865             }
13866             pushback(c);
13867             return tRSHFT;
13868         }
13869         pushback(c);
13870         return '>';
13871 
13872       case '"':
13873         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13874         return tSTRING_BEG;
13875 
13876       case '`':
13877         if (IS_lex_state(EXPR_FNAME)) {
13878             lex_state = EXPR_ENDFN;
13879             return c;
13880         }
13881         if (IS_lex_state(EXPR_DOT)) {
13882             if (cmd_state)
13883                 lex_state = EXPR_CMDARG;
13884             else
13885                 lex_state = EXPR_ARG;
13886             return c;
13887         }
13888         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13889         return tXSTRING_BEG;
13890 
13891       case '\'':
13892         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13893         return tSTRING_BEG;
13894 
13895       case '?':
13896         if (IS_END()) {
13897             lex_state = EXPR_VALUE;
13898             return '?';
13899         }
13900         c = nextc();
13901         if (c == -1) {
13902             compile_error(PARSER_ARG "incomplete character syntax");
13903             return 0;
13904         }
13905         if (rb_enc_isspace(c, current_enc)) {
13906             if (!IS_ARG()) {
13907                 int c2 = 0;
13908                 switch (c) {
13909                   case ' ':
13910                     c2 = 's';
13911                     break;
13912                   case '\n':
13913                     c2 = 'n';
13914                     break;
13915                   case '\t':
13916                     c2 = 't';
13917                     break;
13918                   case '\v':
13919                     c2 = 'v';
13920                     break;
13921                   case '\r':
13922                     c2 = 'r';
13923                     break;
13924                   case '\f':
13925                     c2 = 'f';
13926                     break;
13927                 }
13928                 if (c2) {
13929                     rb_warnI("invalid character syntax; use ?\\%c", c2);
13930                 }
13931             }
13932           ternary:
13933             pushback(c);
13934             lex_state = EXPR_VALUE;
13935             return '?';
13936         }
13937         newtok();
13938         enc = current_enc;
13939         if (!parser_isascii()) {
13940             if (tokadd_mbchar(c) == -1) return 0;
13941         }
13942         else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13943                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13944             goto ternary;
13945         }
13946         else if (c == '\\') {
13947             if (peek('u')) {
13948                 nextc();
13949                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13950                 if (0x80 <= c) {
13951                     tokaddmbc(c, enc);
13952                 }
13953                 else {
13954                     tokadd(c);
13955                 }
13956             }
13957             else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13958                 nextc();
13959                 if (tokadd_mbchar(c) == -1) return 0;
13960             }
13961             else {
13962                 c = read_escape(0, &enc);
13963                 tokadd(c);
13964             }
13965         }
13966         else {
13967             tokadd(c);
13968         }
13969         tokfix();
13970         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13971         lex_state = EXPR_END;
13972         return tCHAR;
13973 
13974       case '&':
13975         if ((c = nextc()) == '&') {
13976             lex_state = EXPR_BEG;
13977             if ((c = nextc()) == '=') {
13978                 set_yylval_id(tANDOP);
13979                 lex_state = EXPR_BEG;
13980                 return tOP_ASGN;
13981             }
13982             pushback(c);
13983             return tANDOP;
13984         }
13985         else if (c == '=') {
13986             set_yylval_id('&');
13987             lex_state = EXPR_BEG;
13988             return tOP_ASGN;
13989         }
13990         pushback(c);
13991         if (IS_SPCARG(c)) {
13992             rb_warning0("`&' interpreted as argument prefix");
13993             c = tAMPER;
13994         }
13995         else if (IS_BEG()) {
13996             c = tAMPER;
13997         }
13998         else {
13999             warn_balanced("&", "argument prefix");
14000             c = '&';
14001         }
14002         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14003         return c;
14004 
14005       case '|':
14006         if ((c = nextc()) == '|') {
14007             lex_state = EXPR_BEG;
14008             if ((c = nextc()) == '=') {
14009                 set_yylval_id(tOROP);
14010                 lex_state = EXPR_BEG;
14011                 return tOP_ASGN;
14012             }
14013             pushback(c);
14014             return tOROP;
14015         }
14016         if (c == '=') {
14017             set_yylval_id('|');
14018             lex_state = EXPR_BEG;
14019             return tOP_ASGN;
14020         }
14021         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14022         pushback(c);
14023         return '|';
14024 
14025       case '+':
14026         c = nextc();
14027         if (IS_AFTER_OPERATOR()) {
14028             lex_state = EXPR_ARG;
14029             if (c == '@') {
14030                 return tUPLUS;
14031             }
14032             pushback(c);
14033             return '+';
14034         }
14035         if (c == '=') {
14036             set_yylval_id('+');
14037             lex_state = EXPR_BEG;
14038             return tOP_ASGN;
14039         }
14040         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14041             lex_state = EXPR_BEG;
14042             pushback(c);
14043             if (c != -1 && ISDIGIT(c)) {
14044                 c = '+';
14045                 goto start_num;
14046             }
14047             return tUPLUS;
14048         }
14049         lex_state = EXPR_BEG;
14050         pushback(c);
14051         warn_balanced("+", "unary operator");
14052         return '+';
14053 
14054       case '-':
14055         c = nextc();
14056         if (IS_AFTER_OPERATOR()) {
14057             lex_state = EXPR_ARG;
14058             if (c == '@') {
14059                 return tUMINUS;
14060             }
14061             pushback(c);
14062             return '-';
14063         }
14064         if (c == '=') {
14065             set_yylval_id('-');
14066             lex_state = EXPR_BEG;
14067             return tOP_ASGN;
14068         }
14069         if (c == '>') {
14070             lex_state = EXPR_ENDFN;
14071             return tLAMBDA;
14072         }
14073         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14074             lex_state = EXPR_BEG;
14075             pushback(c);
14076             if (c != -1 && ISDIGIT(c)) {
14077                 return tUMINUS_NUM;
14078             }
14079             return tUMINUS;
14080         }
14081         lex_state = EXPR_BEG;
14082         pushback(c);
14083         warn_balanced("-", "unary operator");
14084         return '-';
14085 
14086       case '.':
14087         lex_state = EXPR_BEG;
14088         if ((c = nextc()) == '.') {
14089             if ((c = nextc()) == '.') {
14090                 return tDOT3;
14091             }
14092             pushback(c);
14093             return tDOT2;
14094         }
14095         pushback(c);
14096         if (c != -1 && ISDIGIT(c)) {
14097             yyerror("no .<digit> floating literal anymore; put 0 before dot");
14098         }
14099         lex_state = EXPR_DOT;
14100         return '.';
14101 
14102       start_num:
14103       case '0': case '1': case '2': case '3': case '4':
14104       case '5': case '6': case '7': case '8': case '9':
14105         {
14106             int is_float, seen_point, seen_e, nondigit;
14107             int suffix;
14108 
14109             is_float = seen_point = seen_e = nondigit = 0;
14110             lex_state = EXPR_END;
14111             newtok();
14112             if (c == '-' || c == '+') {
14113                 tokadd(c);
14114                 c = nextc();
14115             }
14116             if (c == '0') {
14117 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
14118                 int start = toklen();
14119                 c = nextc();
14120                 if (c == 'x' || c == 'X') {
14121                     /* hexadecimal */
14122                     c = nextc();
14123                     if (c != -1 && ISXDIGIT(c)) {
14124                         do {
14125                             if (c == '_') {
14126                                 if (nondigit) break;
14127                                 nondigit = c;
14128                                 continue;
14129                             }
14130                             if (!ISXDIGIT(c)) break;
14131                             nondigit = 0;
14132                             tokadd(c);
14133                         } while ((c = nextc()) != -1);
14134                     }
14135                     pushback(c);
14136                     tokfix();
14137                     if (toklen() == start) {
14138                         no_digits();
14139                     }
14140                     else if (nondigit) goto trailing_uc;
14141                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14142                     return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
14143                 }
14144                 if (c == 'b' || c == 'B') {
14145                     /* binary */
14146                     c = nextc();
14147                     if (c == '0' || c == '1') {
14148                         do {
14149                             if (c == '_') {
14150                                 if (nondigit) break;
14151                                 nondigit = c;
14152                                 continue;
14153                             }
14154                             if (c != '0' && c != '1') break;
14155                             nondigit = 0;
14156                             tokadd(c);
14157                         } while ((c = nextc()) != -1);
14158                     }
14159                     pushback(c);
14160                     tokfix();
14161                     if (toklen() == start) {
14162                         no_digits();
14163                     }
14164                     else if (nondigit) goto trailing_uc;
14165                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14166                     return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
14167                 }
14168                 if (c == 'd' || c == 'D') {
14169                     /* decimal */
14170                     c = nextc();
14171                     if (c != -1 && ISDIGIT(c)) {
14172                         do {
14173                             if (c == '_') {
14174                                 if (nondigit) break;
14175                                 nondigit = c;
14176                                 continue;
14177                             }
14178                             if (!ISDIGIT(c)) break;
14179                             nondigit = 0;
14180                             tokadd(c);
14181                         } while ((c = nextc()) != -1);
14182                     }
14183                     pushback(c);
14184                     tokfix();
14185                     if (toklen() == start) {
14186                         no_digits();
14187                     }
14188                     else if (nondigit) goto trailing_uc;
14189                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14190                     return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14191                 }
14192                 if (c == '_') {
14193                     /* 0_0 */
14194                     goto octal_number;
14195                 }
14196                 if (c == 'o' || c == 'O') {
14197                     /* prefixed octal */
14198                     c = nextc();
14199                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
14200                         no_digits();
14201                     }
14202                 }
14203                 if (c >= '0' && c <= '7') {
14204                     /* octal */
14205                   octal_number:
14206                     do {
14207                         if (c == '_') {
14208                             if (nondigit) break;
14209                             nondigit = c;
14210                             continue;
14211                         }
14212                         if (c < '0' || c > '9') break;
14213                         if (c > '7') goto invalid_octal;
14214                         nondigit = 0;
14215                         tokadd(c);
14216                     } while ((c = nextc()) != -1);
14217                     if (toklen() > start) {
14218                         pushback(c);
14219                         tokfix();
14220                         if (nondigit) goto trailing_uc;
14221                         suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14222                         return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
14223                     }
14224                     if (nondigit) {
14225                         pushback(c);
14226                         goto trailing_uc;
14227                     }
14228                 }
14229                 if (c > '7' && c <= '9') {
14230                   invalid_octal:
14231                     yyerror("Invalid octal digit");
14232                 }
14233                 else if (c == '.' || c == 'e' || c == 'E') {
14234                     tokadd('0');
14235                 }
14236                 else {
14237                     pushback(c);
14238                     suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14239                     return set_integer_literal(INT2FIX(0), suffix);
14240                 }
14241             }
14242 
14243             for (;;) {
14244                 switch (c) {
14245                   case '0': case '1': case '2': case '3': case '4':
14246                   case '5': case '6': case '7': case '8': case '9':
14247                     nondigit = 0;
14248                     tokadd(c);
14249                     break;
14250 
14251                   case '.':
14252                     if (nondigit) goto trailing_uc;
14253                     if (seen_point || seen_e) {
14254                         goto decode_num;
14255                     }
14256                     else {
14257                         int c0 = nextc();
14258                         if (c0 == -1 || !ISDIGIT(c0)) {
14259                             pushback(c0);
14260                             goto decode_num;
14261                         }
14262                         c = c0;
14263                     }
14264                     seen_point = toklen();
14265                     tokadd('.');
14266                     tokadd(c);
14267                     is_float++;
14268                     nondigit = 0;
14269                     break;
14270 
14271                   case 'e':
14272                   case 'E':
14273                     if (nondigit) {
14274                         pushback(c);
14275                         c = nondigit;
14276                         goto decode_num;
14277                     }
14278                     if (seen_e) {
14279                         goto decode_num;
14280                     }
14281                     nondigit = c;
14282                     c = nextc();
14283                     if (c != '-' && c != '+' && !ISDIGIT(c)) {
14284                         pushback(c);
14285                         nondigit = 0;
14286                         goto decode_num;
14287                     }
14288                     tokadd(nondigit);
14289                     seen_e++;
14290                     is_float++;
14291                     tokadd(c);
14292                     nondigit = (c == '-' || c == '+') ? c : 0;
14293                     break;
14294 
14295                   case '_':     /* `_' in number just ignored */
14296                     if (nondigit) goto decode_num;
14297                     nondigit = c;
14298                     break;
14299 
14300                   default:
14301                     goto decode_num;
14302                 }
14303                 c = nextc();
14304             }
14305 
14306           decode_num:
14307             pushback(c);
14308             if (nondigit) {
14309                 char tmp[30];
14310               trailing_uc:
14311                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14312                 yyerror(tmp);
14313             }
14314             tokfix();
14315             if (is_float) {
14316                 int type = tFLOAT;
14317                 VALUE v;
14318 
14319                 suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
14320                 if (suffix & NUM_SUFFIX_R) {
14321                     char *point = &tok()[seen_point];
14322                     size_t fraclen = toklen()-seen_point-1;
14323                     type = tRATIONAL;
14324                     memmove(point, point+1, fraclen+1);
14325                     v = rb_cstr_to_inum(tok(), 10, FALSE);
14326                     v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14327                 }
14328                 else {
14329                     double d = strtod(tok(), 0);
14330                     if (errno == ERANGE) {
14331                         rb_warningS("Float %s out of range", tok());
14332                         errno = 0;
14333                     }
14334                     v = DBL2NUM(d);
14335                 }
14336                 return set_number_literal(v, type, suffix);
14337             }
14338             suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14339             return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14340         }
14341 
14342       case ')':
14343       case ']':
14344         paren_nest--;
14345       case '}':
14346         COND_LEXPOP();
14347         CMDARG_LEXPOP();
14348         if (c == ')')
14349             lex_state = EXPR_ENDFN;
14350         else
14351             lex_state = EXPR_ENDARG;
14352         if (c == '}') {
14353             if (!brace_nest--) c = tSTRING_DEND;
14354         }
14355         return c;
14356 
14357       case ':':
14358         c = nextc();
14359         if (c == ':') {
14360             if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14361                 lex_state = EXPR_BEG;
14362                 return tCOLON3;
14363             }
14364             lex_state = EXPR_DOT;
14365             return tCOLON2;
14366         }
14367         if (IS_END() || ISSPACE(c)) {
14368             pushback(c);
14369             warn_balanced(":", "symbol literal");
14370             lex_state = EXPR_BEG;
14371             return ':';
14372         }
14373         switch (c) {
14374           case '\'':
14375             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14376             break;
14377           case '"':
14378             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14379             break;
14380           default:
14381             pushback(c);
14382             break;
14383         }
14384         lex_state = EXPR_FNAME;
14385         return tSYMBEG;
14386 
14387       case '/':
14388         if (IS_lex_state(EXPR_BEG_ANY)) {
14389             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14390             return tREGEXP_BEG;
14391         }
14392         if ((c = nextc()) == '=') {
14393             set_yylval_id('/');
14394             lex_state = EXPR_BEG;
14395             return tOP_ASGN;
14396         }
14397         pushback(c);
14398         if (IS_SPCARG(c)) {
14399             (void)arg_ambiguous();
14400             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14401             return tREGEXP_BEG;
14402         }
14403         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14404         warn_balanced("/", "regexp literal");
14405         return '/';
14406 
14407       case '^':
14408         if ((c = nextc()) == '=') {
14409             set_yylval_id('^');
14410             lex_state = EXPR_BEG;
14411             return tOP_ASGN;
14412         }
14413         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14414         pushback(c);
14415         return '^';
14416 
14417       case ';':
14418         lex_state = EXPR_BEG;
14419         command_start = TRUE;
14420         return ';';
14421 
14422       case ',':
14423         lex_state = EXPR_BEG;
14424         return ',';
14425 
14426       case '~':
14427         if (IS_AFTER_OPERATOR()) {
14428             if ((c = nextc()) != '@') {
14429                 pushback(c);
14430             }
14431             lex_state = EXPR_ARG;
14432         }
14433         else {
14434             lex_state = EXPR_BEG;
14435         }
14436         return '~';
14437 
14438       case '(':
14439         if (IS_BEG()) {
14440             c = tLPAREN;
14441         }
14442         else if (IS_SPCARG(-1)) {
14443             c = tLPAREN_ARG;
14444         }
14445         paren_nest++;
14446         COND_PUSH(0);
14447         CMDARG_PUSH(0);
14448         lex_state = EXPR_BEG;
14449         return c;
14450 
14451       case '[':
14452         paren_nest++;
14453         if (IS_AFTER_OPERATOR()) {
14454             lex_state = EXPR_ARG;
14455             if ((c = nextc()) == ']') {
14456                 if ((c = nextc()) == '=') {
14457                     return tASET;
14458                 }
14459                 pushback(c);
14460                 return tAREF;
14461             }
14462             pushback(c);
14463             return '[';
14464         }
14465         else if (IS_BEG()) {
14466             c = tLBRACK;
14467         }
14468         else if (IS_ARG() && space_seen) {
14469             c = tLBRACK;
14470         }
14471         lex_state = EXPR_BEG;
14472         COND_PUSH(0);
14473         CMDARG_PUSH(0);
14474         return c;
14475 
14476       case '{':
14477         ++brace_nest;
14478         if (lpar_beg && lpar_beg == paren_nest) {
14479             lex_state = EXPR_BEG;
14480             lpar_beg = 0;
14481             --paren_nest;
14482             COND_PUSH(0);
14483             CMDARG_PUSH(0);
14484             return tLAMBEG;
14485         }
14486         if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14487             c = '{';          /* block (primary) */
14488         else if (IS_lex_state(EXPR_ENDARG))
14489             c = tLBRACE_ARG;  /* block (expr) */
14490         else
14491             c = tLBRACE;      /* hash */
14492         COND_PUSH(0);
14493         CMDARG_PUSH(0);
14494         lex_state = EXPR_BEG;
14495         if (c != tLBRACE) command_start = TRUE;
14496         return c;
14497 
14498       case '\\':
14499         c = nextc();
14500         if (c == '\n') {
14501             space_seen = 1;
14502 #ifdef RIPPER
14503             ripper_dispatch_scan_event(parser, tSP);
14504 #endif
14505             goto retry; /* skip \\n */
14506         }
14507         pushback(c);
14508         return '\\';
14509 
14510       case '%':
14511         if (IS_lex_state(EXPR_BEG_ANY)) {
14512             int term;
14513             int paren;
14514 
14515             c = nextc();
14516           quotation:
14517             if (c == -1 || !ISALNUM(c)) {
14518                 term = c;
14519                 c = 'Q';
14520             }
14521             else {
14522                 term = nextc();
14523                 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14524                     yyerror("unknown type of %string");
14525                     return 0;
14526                 }
14527             }
14528             if (c == -1 || term == -1) {
14529                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14530                 return 0;
14531             }
14532             paren = term;
14533             if (term == '(') term = ')';
14534             else if (term == '[') term = ']';
14535             else if (term == '{') term = '}';
14536             else if (term == '<') term = '>';
14537             else paren = 0;
14538 
14539             switch (c) {
14540               case 'Q':
14541                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14542                 return tSTRING_BEG;
14543 
14544               case 'q':
14545                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
14546                 return tSTRING_BEG;
14547 
14548               case 'W':
14549                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14550                 do {c = nextc();} while (ISSPACE(c));
14551                 pushback(c);
14552                 return tWORDS_BEG;
14553 
14554               case 'w':
14555                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14556                 do {c = nextc();} while (ISSPACE(c));
14557                 pushback(c);
14558                 return tQWORDS_BEG;
14559 
14560               case 'I':
14561                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
14562                 do {c = nextc();} while (ISSPACE(c));
14563                 pushback(c);
14564                 return tSYMBOLS_BEG;
14565 
14566               case 'i':
14567                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
14568                 do {c = nextc();} while (ISSPACE(c));
14569                 pushback(c);
14570                 return tQSYMBOLS_BEG;
14571 
14572               case 'x':
14573                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14574                 return tXSTRING_BEG;
14575 
14576               case 'r':
14577                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14578                 return tREGEXP_BEG;
14579 
14580               case 's':
14581                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14582                 lex_state = EXPR_FNAME;
14583                 return tSYMBEG;
14584 
14585               default:
14586                 yyerror("unknown type of %string");
14587                 return 0;
14588             }
14589         }
14590         if ((c = nextc()) == '=') {
14591             set_yylval_id('%');
14592             lex_state = EXPR_BEG;
14593             return tOP_ASGN;
14594         }
14595         if (IS_SPCARG(c)) {
14596             goto quotation;
14597         }
14598         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14599         pushback(c);
14600         warn_balanced("%%", "string literal");
14601         return '%';
14602 
14603       case '$':
14604         lex_state = EXPR_END;
14605         newtok();
14606         c = nextc();
14607         switch (c) {
14608           case '_':             /* $_: last read line string */
14609             c = nextc();
14610             if (parser_is_identchar()) {
14611                 tokadd('$');
14612                 tokadd('_');
14613                 break;
14614             }
14615             pushback(c);
14616             c = '_';
14617             /* fall through */
14618           case '~':             /* $~: match-data */
14619           case '*':             /* $*: argv */
14620           case '$':             /* $$: pid */
14621           case '?':             /* $?: last status */
14622           case '!':             /* $!: error string */
14623           case '@':             /* $@: error position */
14624           case '/':             /* $/: input record separator */
14625           case '\\':            /* $\: output record separator */
14626           case ';':             /* $;: field separator */
14627           case ',':             /* $,: output field separator */
14628           case '.':             /* $.: last read line number */
14629           case '=':             /* $=: ignorecase */
14630           case ':':             /* $:: load path */
14631           case '<':             /* $<: reading filename */
14632           case '>':             /* $>: default output handle */
14633           case '\"':            /* $": already loaded files */
14634             tokadd('$');
14635             tokadd(c);
14636             goto gvar;
14637 
14638           case '-':
14639             tokadd('$');
14640             tokadd(c);
14641             c = nextc();
14642             if (parser_is_identchar()) {
14643                 if (tokadd_mbchar(c) == -1) return 0;
14644             }
14645             else {
14646                 pushback(c);
14647                 pushback('-');
14648                 return '$';
14649             }
14650           gvar:
14651             set_yylval_name(rb_intern3(tok(), tokidx, current_enc));
14652             return tGVAR;
14653 
14654           case '&':             /* $&: last match */
14655           case '`':             /* $`: string before last match */
14656           case '\'':            /* $': string after last match */
14657           case '+':             /* $+: string matches last paren. */
14658             if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14659                 tokadd('$');
14660                 tokadd(c);
14661                 goto gvar;
14662             }
14663             set_yylval_node(NEW_BACK_REF(c));
14664             return tBACK_REF;
14665 
14666           case '1': case '2': case '3':
14667           case '4': case '5': case '6':
14668           case '7': case '8': case '9':
14669             tokadd('$');
14670             do {
14671                 tokadd(c);
14672                 c = nextc();
14673             } while (c != -1 && ISDIGIT(c));
14674             pushback(c);
14675             if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14676             tokfix();
14677             set_yylval_node(NEW_NTH_REF(parse_numvar(parser)));
14678             return tNTH_REF;
14679 
14680           default:
14681             if (!parser_is_identchar()) {
14682                 pushback(c);
14683                 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14684                 return 0;
14685             }
14686           case '0':
14687             tokadd('$');
14688         }
14689         break;
14690 
14691       case '@':
14692         c = nextc();
14693         newtok();
14694         tokadd('@');
14695         if (c == '@') {
14696             tokadd('@');
14697             c = nextc();
14698         }
14699         if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14700             pushback(c);
14701             if (tokidx == 1) {
14702                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14703             }
14704             else {
14705                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14706             }
14707             return 0;
14708         }
14709         break;
14710 
14711       case '_':
14712         if (was_bol() && whole_match_p("__END__", 7, 0)) {
14713             ruby__end__seen = 1;
14714             parser->eofp = Qtrue;
14715 #ifndef RIPPER
14716             return -1;
14717 #else
14718             lex_goto_eol(parser);
14719             ripper_dispatch_scan_event(parser, k__END__);
14720             return 0;
14721 #endif
14722         }
14723         newtok();
14724         break;
14725 
14726       default:
14727         if (!parser_is_identchar()) {
14728             compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
14729             goto retry;
14730         }
14731 
14732         newtok();
14733         break;
14734     }
14735 
14736     mb = ENC_CODERANGE_7BIT;
14737     do {
14738         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14739         if (tokadd_mbchar(c) == -1) return 0;
14740         c = nextc();
14741     } while (parser_is_identchar());
14742     switch (tok()[0]) {
14743       case '@': case '$':
14744         pushback(c);
14745         break;
14746       default:
14747         if ((c == '!' || c == '?') && !peek('=')) {
14748             tokadd(c);
14749         }
14750         else {
14751             pushback(c);
14752         }
14753     }
14754     tokfix();
14755 
14756     {
14757         int result = 0;
14758 
14759         last_state = lex_state;
14760         switch (tok()[0]) {
14761           case '$':
14762             lex_state = EXPR_END;
14763             result = tGVAR;
14764             break;
14765           case '@':
14766             lex_state = EXPR_END;
14767             if (tok()[1] == '@')
14768                 result = tCVAR;
14769             else
14770                 result = tIVAR;
14771             break;
14772 
14773           default:
14774             if (toklast() == '!' || toklast() == '?') {
14775                 result = tFID;
14776             }
14777             else {
14778                 if (IS_lex_state(EXPR_FNAME)) {
14779                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14780                         (!peek('=') || (peek_n('>', 1)))) {
14781                         result = tIDENTIFIER;
14782                         tokadd(c);
14783                         tokfix();
14784                     }
14785                     else {
14786                         pushback(c);
14787                     }
14788                 }
14789                 if (result == 0 && ISUPPER(tok()[0])) {
14790                     result = tCONSTANT;
14791                 }
14792                 else {
14793                     result = tIDENTIFIER;
14794                 }
14795             }
14796 
14797             if (IS_LABEL_POSSIBLE()) {
14798                 if (IS_LABEL_SUFFIX(0)) {
14799                     lex_state = EXPR_LABELARG;
14800                     nextc();
14801                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
14802                     return tLABEL;
14803                 }
14804             }
14805             if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14806                 const struct kwtable *kw;
14807 
14808                 /* See if it is a reserved word.  */
14809                 kw = rb_reserved_word(tok(), toklen());
14810                 if (kw) {
14811                     enum lex_state_e state = lex_state;
14812                     lex_state = kw->state;
14813                     if (IS_lex_state_for(state, EXPR_FNAME)) {
14814                         set_yylval_name(rb_intern(kw->name));
14815                         return kw->id[0];
14816                     }
14817                     if (IS_lex_state(EXPR_BEG)) {
14818                         command_start = TRUE;
14819                     }
14820                     if (kw->id[0] == keyword_do) {
14821                         if (lpar_beg && lpar_beg == paren_nest) {
14822                             lpar_beg = 0;
14823                             --paren_nest;
14824                             return keyword_do_LAMBDA;
14825                         }
14826                         if (COND_P()) return keyword_do_cond;
14827                         if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14828                             return keyword_do_block;
14829                         if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14830                             return keyword_do_block;
14831                         return keyword_do;
14832                     }
14833                     if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG)))
14834                         return kw->id[0];
14835                     else {
14836                         if (kw->id[0] != kw->id[1])
14837                             lex_state = EXPR_BEG;
14838                         return kw->id[1];
14839                     }
14840                 }
14841             }
14842 
14843             if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14844                 if (cmd_state) {
14845                     lex_state = EXPR_CMDARG;
14846                 }
14847                 else {
14848                     lex_state = EXPR_ARG;
14849                 }
14850             }
14851             else if (lex_state == EXPR_FNAME) {
14852                 lex_state = EXPR_ENDFN;
14853             }
14854             else {
14855                 lex_state = EXPR_END;
14856             }
14857         }
14858         {
14859             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14860 
14861             set_yylval_name(ident);
14862             if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14863                 is_local_id(ident) && lvar_defined(ident)) {
14864                 lex_state = EXPR_END;
14865             }
14866         }
14867         return result;
14868     }
14869 }
14870 
14871 #if YYPURE
14872 static int
14873 yylex(void *lval, void *p)
14874 #else
14875 yylex(void *p)
14876 #endif
14877 {
14878     struct parser_params *parser = (struct parser_params*)p;
14879     int t;
14880 
14881 #if YYPURE
14882     parser->parser_yylval = lval;
14883     parser->parser_yylval->val = Qundef;
14884 #endif
14885     t = parser_yylex(parser);
14886 #ifdef RIPPER
14887     if (!NIL_P(parser->delayed)) {
14888         ripper_dispatch_delayed_token(parser, t);
14889         return t;
14890     }
14891     if (t != 0)
14892         ripper_dispatch_scan_event(parser, t);
14893 #endif
14894 
14895     return t;
14896 }
14897 
14898 #ifndef RIPPER
14899 static NODE*
14900 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14901 {
14902     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14903     nd_set_line(n, ruby_sourceline);
14904     return n;
14905 }
14906 
14907 static enum node_type
14908 nodetype(NODE *node)                    /* for debug */
14909 {
14910     return (enum node_type)nd_type(node);
14911 }
14912 
14913 static int
14914 nodeline(NODE *node)
14915 {
14916     return nd_line(node);
14917 }
14918 
14919 static NODE*
14920 newline_node(NODE *node)
14921 {
14922     if (node) {
14923         node = remove_begin(node);
14924         node->flags |= NODE_FL_NEWLINE;
14925     }
14926     return node;
14927 }
14928 
14929 static void
14930 fixpos(NODE *node, NODE *orig)
14931 {
14932     if (!node) return;
14933     if (!orig) return;
14934     if (orig == (NODE*)1) return;
14935     nd_set_line(node, nd_line(orig));
14936 }
14937 
14938 static void
14939 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14940 {
14941     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14942 }
14943 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14944 
14945 static void
14946 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14947 {
14948     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14949 }
14950 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14951 
14952 static NODE*
14953 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14954 {
14955     NODE *end, *h = head, *nd;
14956 
14957     if (tail == 0) return head;
14958 
14959     if (h == 0) return tail;
14960     switch (nd_type(h)) {
14961       case NODE_LIT:
14962       case NODE_STR:
14963       case NODE_SELF:
14964       case NODE_TRUE:
14965       case NODE_FALSE:
14966       case NODE_NIL:
14967         parser_warning(h, "unused literal ignored");
14968         return tail;
14969       default:
14970         h = end = NEW_BLOCK(head);
14971         end->nd_end = end;
14972         fixpos(end, head);
14973         head = end;
14974         break;
14975       case NODE_BLOCK:
14976         end = h->nd_end;
14977         break;
14978     }
14979 
14980     nd = end->nd_head;
14981     switch (nd_type(nd)) {
14982       case NODE_RETURN:
14983       case NODE_BREAK:
14984       case NODE_NEXT:
14985       case NODE_REDO:
14986       case NODE_RETRY:
14987         if (RTEST(ruby_verbose)) {
14988             parser_warning(tail, "statement not reached");
14989         }
14990         break;
14991 
14992       default:
14993         break;
14994     }
14995 
14996     if (nd_type(tail) != NODE_BLOCK) {
14997         tail = NEW_BLOCK(tail);
14998         tail->nd_end = tail;
14999     }
15000     end->nd_next = tail;
15001     h->nd_end = tail->nd_end;
15002     return head;
15003 }
15004 
15005 /* append item to the list */
15006 static NODE*
15007 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
15008 {
15009     NODE *last;
15010 
15011     if (list == 0) return NEW_LIST(item);
15012     if (list->nd_next) {
15013         last = list->nd_next->nd_end;
15014     }
15015     else {
15016         last = list;
15017     }
15018 
15019     list->nd_alen += 1;
15020     last->nd_next = NEW_LIST(item);
15021     list->nd_next->nd_end = last->nd_next;
15022     return list;
15023 }
15024 
15025 /* concat two lists */
15026 static NODE*
15027 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
15028 {
15029     NODE *last;
15030 
15031     if (head->nd_next) {
15032         last = head->nd_next->nd_end;
15033     }
15034     else {
15035         last = head;
15036     }
15037 
15038     head->nd_alen += tail->nd_alen;
15039     last->nd_next = tail;
15040     if (tail->nd_next) {
15041         head->nd_next->nd_end = tail->nd_next->nd_end;
15042     }
15043     else {
15044         head->nd_next->nd_end = tail;
15045     }
15046 
15047     return head;
15048 }
15049 
15050 static int
15051 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
15052 {
15053     if (NIL_P(tail)) return 1;
15054     if (!rb_enc_compatible(head, tail)) {
15055         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
15056                       rb_enc_name(rb_enc_get(head)),
15057                       rb_enc_name(rb_enc_get(tail)));
15058         rb_str_resize(head, 0);
15059         rb_str_resize(tail, 0);
15060         return 0;
15061     }
15062     rb_str_buf_append(head, tail);
15063     return 1;
15064 }
15065 
15066 /* concat two string literals */
15067 static NODE *
15068 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
15069 {
15070     enum node_type htype;
15071     NODE *headlast;
15072     VALUE lit;
15073 
15074     if (!head) return tail;
15075     if (!tail) return head;
15076 
15077     htype = nd_type(head);
15078     if (htype == NODE_EVSTR) {
15079         NODE *node = NEW_DSTR(STR_NEW0());
15080         head = list_append(node, head);
15081         htype = NODE_DSTR;
15082     }
15083     switch (nd_type(tail)) {
15084       case NODE_STR:
15085         if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15086             nd_type(headlast) == NODE_STR) {
15087             htype = NODE_STR;
15088             lit = headlast->nd_lit;
15089         }
15090         else {
15091             lit = head->nd_lit;
15092         }
15093         if (htype == NODE_STR) {
15094             if (!literal_concat0(parser, lit, tail->nd_lit)) {
15095               error:
15096                 rb_gc_force_recycle((VALUE)head);
15097                 rb_gc_force_recycle((VALUE)tail);
15098                 return 0;
15099             }
15100             rb_gc_force_recycle((VALUE)tail);
15101         }
15102         else {
15103             list_append(head, tail);
15104         }
15105         break;
15106 
15107       case NODE_DSTR:
15108         if (htype == NODE_STR) {
15109             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
15110                 goto error;
15111             tail->nd_lit = head->nd_lit;
15112             rb_gc_force_recycle((VALUE)head);
15113             head = tail;
15114         }
15115         else if (NIL_P(tail->nd_lit)) {
15116           append:
15117             head->nd_alen += tail->nd_alen - 1;
15118             head->nd_next->nd_end->nd_next = tail->nd_next;
15119             head->nd_next->nd_end = tail->nd_next->nd_end;
15120             rb_gc_force_recycle((VALUE)tail);
15121         }
15122         else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15123                  nd_type(headlast) == NODE_STR) {
15124             lit = headlast->nd_lit;
15125             if (!literal_concat0(parser, lit, tail->nd_lit))
15126                 goto error;
15127             tail->nd_lit = Qnil;
15128             goto append;
15129         }
15130         else {
15131             nd_set_type(tail, NODE_ARRAY);
15132             tail->nd_head = NEW_STR(tail->nd_lit);
15133             list_concat(head, tail);
15134         }
15135         break;
15136 
15137       case NODE_EVSTR:
15138         if (htype == NODE_STR) {
15139             nd_set_type(head, NODE_DSTR);
15140             head->nd_alen = 1;
15141         }
15142         list_append(head, tail);
15143         break;
15144     }
15145     return head;
15146 }
15147 
15148 static NODE *
15149 evstr2dstr_gen(struct parser_params *parser, NODE *node)
15150 {
15151     if (nd_type(node) == NODE_EVSTR) {
15152         node = list_append(NEW_DSTR(STR_NEW0()), node);
15153     }
15154     return node;
15155 }
15156 
15157 static NODE *
15158 new_evstr_gen(struct parser_params *parser, NODE *node)
15159 {
15160     NODE *head = node;
15161 
15162     if (node) {
15163         switch (nd_type(node)) {
15164           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15165             return node;
15166         }
15167     }
15168     return NEW_EVSTR(head);
15169 }
15170 
15171 static NODE *
15172 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
15173 {
15174     value_expr(recv);
15175     value_expr(arg1);
15176     return NEW_CALL(recv, id, NEW_LIST(arg1));
15177 }
15178 
15179 static NODE *
15180 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15181 {
15182     value_expr(recv);
15183     return NEW_CALL(recv, id, 0);
15184 }
15185 
15186 static NODE*
15187 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15188 {
15189     value_expr(node1);
15190     value_expr(node2);
15191     if (node1) {
15192         switch (nd_type(node1)) {
15193           case NODE_DREGX:
15194           case NODE_DREGX_ONCE:
15195             return NEW_MATCH2(node1, node2);
15196 
15197           case NODE_LIT:
15198             if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15199                 return NEW_MATCH2(node1, node2);
15200             }
15201         }
15202     }
15203 
15204     if (node2) {
15205         switch (nd_type(node2)) {
15206           case NODE_DREGX:
15207           case NODE_DREGX_ONCE:
15208             return NEW_MATCH3(node2, node1);
15209 
15210           case NODE_LIT:
15211             if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15212                 return NEW_MATCH3(node2, node1);
15213             }
15214         }
15215     }
15216 
15217     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15218 }
15219 
15220 static NODE*
15221 gettable_gen(struct parser_params *parser, ID id)
15222 {
15223     switch (id) {
15224       case keyword_self:
15225         return NEW_SELF();
15226       case keyword_nil:
15227         return NEW_NIL();
15228       case keyword_true:
15229         return NEW_TRUE();
15230       case keyword_false:
15231         return NEW_FALSE();
15232       case keyword__FILE__:
15233         return NEW_STR(rb_str_dup(ruby_sourcefile_string));
15234       case keyword__LINE__:
15235         return NEW_LIT(INT2FIX(tokline));
15236       case keyword__ENCODING__:
15237         return NEW_LIT(rb_enc_from_encoding(current_enc));
15238     }
15239     switch (id_type(id)) {
15240       case ID_LOCAL:
15241         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15242         if (local_id(id)) return NEW_LVAR(id);
15243         /* method call without arguments */
15244         return NEW_VCALL(id);
15245       case ID_GLOBAL:
15246         return NEW_GVAR(id);
15247       case ID_INSTANCE:
15248         return NEW_IVAR(id);
15249       case ID_CONST:
15250         return NEW_CONST(id);
15251       case ID_CLASS:
15252         return NEW_CVAR(id);
15253     }
15254     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15255     return 0;
15256 }
15257 #else  /* !RIPPER */
15258 static int
15259 id_is_var_gen(struct parser_params *parser, ID id)
15260 {
15261     if (is_notop_id(id)) {
15262         switch (id & ID_SCOPE_MASK) {
15263           case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15264             return 1;
15265           case ID_LOCAL:
15266             if (dyna_in_block() && dvar_defined(id)) return 1;
15267             if (local_id(id)) return 1;
15268             /* method call without arguments */
15269             return 0;
15270         }
15271     }
15272     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15273     return 0;
15274 }
15275 #endif /* !RIPPER */
15276 
15277 #if PARSER_DEBUG
15278 static const char *
15279 lex_state_name(enum lex_state_e state)
15280 {
15281     static const char names[][12] = {
15282         "EXPR_BEG",    "EXPR_END",    "EXPR_ENDARG", "EXPR_ENDFN",  "EXPR_ARG",
15283         "EXPR_CMDARG", "EXPR_MID",    "EXPR_FNAME",  "EXPR_DOT",    "EXPR_CLASS",
15284         "EXPR_VALUE",
15285     };
15286 
15287     if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15288         return names[ffs(state)];
15289     return NULL;
15290 }
15291 #endif
15292 
15293 #ifdef RIPPER
15294 static VALUE
15295 assignable_gen(struct parser_params *parser, VALUE lhs)
15296 #else
15297 static NODE*
15298 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15299 #endif
15300 {
15301 #ifdef RIPPER
15302     ID id = get_id(lhs);
15303 # define assignable_result(x) get_value(lhs)
15304 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15305 #else
15306 # define assignable_result(x) (x)
15307 #endif
15308     if (!id) return assignable_result(0);
15309     switch (id) {
15310       case keyword_self:
15311         yyerror("Can't change the value of self");
15312         goto error;
15313       case keyword_nil:
15314         yyerror("Can't assign to nil");
15315         goto error;
15316       case keyword_true:
15317         yyerror("Can't assign to true");
15318         goto error;
15319       case keyword_false:
15320         yyerror("Can't assign to false");
15321         goto error;
15322       case keyword__FILE__:
15323         yyerror("Can't assign to __FILE__");
15324         goto error;
15325       case keyword__LINE__:
15326         yyerror("Can't assign to __LINE__");
15327         goto error;
15328       case keyword__ENCODING__:
15329         yyerror("Can't assign to __ENCODING__");
15330         goto error;
15331     }
15332     switch (id_type(id)) {
15333       case ID_LOCAL:
15334         if (dyna_in_block()) {
15335             if (dvar_curr(id)) {
15336                 return assignable_result(NEW_DASGN_CURR(id, val));
15337             }
15338             else if (dvar_defined(id)) {
15339                 return assignable_result(NEW_DASGN(id, val));
15340             }
15341             else if (local_id(id)) {
15342                 return assignable_result(NEW_LASGN(id, val));
15343             }
15344             else {
15345                 dyna_var(id);
15346                 return assignable_result(NEW_DASGN_CURR(id, val));
15347             }
15348         }
15349         else {
15350             if (!local_id(id)) {
15351                 local_var(id);
15352             }
15353             return assignable_result(NEW_LASGN(id, val));
15354         }
15355         break;
15356       case ID_GLOBAL:
15357         return assignable_result(NEW_GASGN(id, val));
15358       case ID_INSTANCE:
15359         return assignable_result(NEW_IASGN(id, val));
15360       case ID_CONST:
15361         if (!in_def && !in_single)
15362             return assignable_result(NEW_CDECL(id, val, 0));
15363         yyerror("dynamic constant assignment");
15364         break;
15365       case ID_CLASS:
15366         return assignable_result(NEW_CVASGN(id, val));
15367       default:
15368         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15369     }
15370   error:
15371     return assignable_result(0);
15372 #undef assignable_result
15373 #undef parser_yyerror
15374 }
15375 
15376 static int
15377 is_private_local_id(ID name)
15378 {
15379     VALUE s;
15380     if (name == idUScore) return 1;
15381     if (!is_local_id(name)) return 0;
15382     s = rb_id2str(name);
15383     if (!s) return 0;
15384     return RSTRING_PTR(s)[0] == '_';
15385 }
15386 
15387 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15388 
15389 static int
15390 shadowing_lvar_0(struct parser_params *parser, ID name)
15391 {
15392     if (is_private_local_id(name)) return 1;
15393     if (dyna_in_block()) {
15394         if (dvar_curr(name)) {
15395             yyerror("duplicated argument name");
15396         }
15397         else if (dvar_defined_get(name) || local_id(name)) {
15398             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15399             vtable_add(lvtbl->vars, name);
15400             if (lvtbl->used) {
15401                 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15402             }
15403             return 0;
15404         }
15405     }
15406     else {
15407         if (local_id(name)) {
15408             yyerror("duplicated argument name");
15409         }
15410     }
15411     return 1;
15412 }
15413 
15414 static ID
15415 shadowing_lvar_gen(struct parser_params *parser, ID name)
15416 {
15417     shadowing_lvar_0(parser, name);
15418     return name;
15419 }
15420 
15421 static void
15422 new_bv_gen(struct parser_params *parser, ID name)
15423 {
15424     if (!name) return;
15425     if (!is_local_id(name)) {
15426         compile_error(PARSER_ARG "invalid local variable - %s",
15427                       rb_id2name(name));
15428         return;
15429     }
15430     if (!shadowing_lvar_0(parser, name)) return;
15431     dyna_var(name);
15432 }
15433 
15434 #ifndef RIPPER
15435 static NODE *
15436 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15437 {
15438     if (recv && nd_type(recv) == NODE_SELF)
15439         recv = (NODE *)1;
15440     return NEW_ATTRASGN(recv, tASET, idx);
15441 }
15442 
15443 static void
15444 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15445 {
15446     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15447         compile_error(PARSER_ARG "both block arg and actual block given");
15448     }
15449 }
15450 
15451 static const char id_type_names[][9] = {
15452     "LOCAL",
15453     "INSTANCE",
15454     "",                         /* INSTANCE2 */
15455     "GLOBAL",
15456     "ATTRSET",
15457     "CONST",
15458     "CLASS",
15459     "JUNK",
15460 };
15461 
15462 ID
15463 rb_id_attrset(ID id)
15464 {
15465     if (!is_notop_id(id)) {
15466         switch (id) {
15467           case tAREF: case tASET:
15468             return tASET;       /* only exception */
15469         }
15470         rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15471     }
15472     else {
15473         int scope = (int)(id & ID_SCOPE_MASK);
15474         switch (scope) {
15475           case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15476           case ID_CONST: case ID_CLASS: case ID_JUNK:
15477             break;
15478           case ID_ATTRSET:
15479             return id;
15480           default:
15481             rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15482                           id_type_names[scope], ID2SYM(id));
15483 
15484         }
15485     }
15486     id &= ~ID_SCOPE_MASK;
15487     id |= ID_ATTRSET;
15488     return id;
15489 }
15490 
15491 static NODE *
15492 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15493 {
15494     if (recv && nd_type(recv) == NODE_SELF)
15495         recv = (NODE *)1;
15496     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15497 }
15498 
15499 static void
15500 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15501 {
15502     switch (nd_type(node)) {
15503       case NODE_NTH_REF:
15504         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15505         break;
15506       case NODE_BACK_REF:
15507         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15508         break;
15509     }
15510 }
15511 
15512 static NODE *
15513 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15514 {
15515     if (!node2) return node1;
15516     switch (nd_type(node1)) {
15517       case NODE_BLOCK_PASS:
15518         if (node1->nd_head)
15519             node1->nd_head = arg_concat(node1->nd_head, node2);
15520         else
15521             node1->nd_head = NEW_LIST(node2);
15522         return node1;
15523       case NODE_ARGSPUSH:
15524         if (nd_type(node2) != NODE_ARRAY) break;
15525         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15526         nd_set_type(node1, NODE_ARGSCAT);
15527         return node1;
15528       case NODE_ARGSCAT:
15529         if (nd_type(node2) != NODE_ARRAY ||
15530             nd_type(node1->nd_body) != NODE_ARRAY) break;
15531         node1->nd_body = list_concat(node1->nd_body, node2);
15532         return node1;
15533     }
15534     return NEW_ARGSCAT(node1, node2);
15535 }
15536 
15537 static NODE *
15538 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15539 {
15540     if (!node1) return NEW_LIST(node2);
15541     switch (nd_type(node1))  {
15542       case NODE_ARRAY:
15543         return list_append(node1, node2);
15544       case NODE_BLOCK_PASS:
15545         node1->nd_head = arg_append(node1->nd_head, node2);
15546         return node1;
15547       case NODE_ARGSPUSH:
15548         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15549         nd_set_type(node1, NODE_ARGSCAT);
15550         return node1;
15551     }
15552     return NEW_ARGSPUSH(node1, node2);
15553 }
15554 
15555 static NODE *
15556 splat_array(NODE* node)
15557 {
15558     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15559     if (nd_type(node) == NODE_ARRAY) return node;
15560     return 0;
15561 }
15562 
15563 static NODE *
15564 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15565 {
15566     if (!lhs) return 0;
15567 
15568     switch (nd_type(lhs)) {
15569       case NODE_GASGN:
15570       case NODE_IASGN:
15571       case NODE_IASGN2:
15572       case NODE_LASGN:
15573       case NODE_DASGN:
15574       case NODE_DASGN_CURR:
15575       case NODE_MASGN:
15576       case NODE_CDECL:
15577       case NODE_CVASGN:
15578         lhs->nd_value = rhs;
15579         break;
15580 
15581       case NODE_ATTRASGN:
15582       case NODE_CALL:
15583         lhs->nd_args = arg_append(lhs->nd_args, rhs);
15584         break;
15585 
15586       default:
15587         /* should not happen */
15588         break;
15589     }
15590 
15591     return lhs;
15592 }
15593 
15594 static int
15595 value_expr_gen(struct parser_params *parser, NODE *node)
15596 {
15597     int cond = 0;
15598 
15599     if (!node) {
15600         rb_warning0("empty expression");
15601     }
15602     while (node) {
15603         switch (nd_type(node)) {
15604           case NODE_RETURN:
15605           case NODE_BREAK:
15606           case NODE_NEXT:
15607           case NODE_REDO:
15608           case NODE_RETRY:
15609             if (!cond) yyerror("void value expression");
15610             /* or "control never reach"? */
15611             return FALSE;
15612 
15613           case NODE_BLOCK:
15614             while (node->nd_next) {
15615                 node = node->nd_next;
15616             }
15617             node = node->nd_head;
15618             break;
15619 
15620           case NODE_BEGIN:
15621             node = node->nd_body;
15622             break;
15623 
15624           case NODE_IF:
15625             if (!node->nd_body) {
15626                 node = node->nd_else;
15627                 break;
15628             }
15629             else if (!node->nd_else) {
15630                 node = node->nd_body;
15631                 break;
15632             }
15633             if (!value_expr(node->nd_body)) return FALSE;
15634             node = node->nd_else;
15635             break;
15636 
15637           case NODE_AND:
15638           case NODE_OR:
15639             cond = 1;
15640             node = node->nd_2nd;
15641             break;
15642 
15643           default:
15644             return TRUE;
15645         }
15646     }
15647 
15648     return TRUE;
15649 }
15650 
15651 static void
15652 void_expr_gen(struct parser_params *parser, NODE *node)
15653 {
15654     const char *useless = 0;
15655 
15656     if (!RTEST(ruby_verbose)) return;
15657 
15658     if (!node) return;
15659     switch (nd_type(node)) {
15660       case NODE_CALL:
15661         switch (node->nd_mid) {
15662           case '+':
15663           case '-':
15664           case '*':
15665           case '/':
15666           case '%':
15667           case tPOW:
15668           case tUPLUS:
15669           case tUMINUS:
15670           case '|':
15671           case '^':
15672           case '&':
15673           case tCMP:
15674           case '>':
15675           case tGEQ:
15676           case '<':
15677           case tLEQ:
15678           case tEQ:
15679           case tNEQ:
15680             useless = rb_id2name(node->nd_mid);
15681             break;
15682         }
15683         break;
15684 
15685       case NODE_LVAR:
15686       case NODE_DVAR:
15687       case NODE_GVAR:
15688       case NODE_IVAR:
15689       case NODE_CVAR:
15690       case NODE_NTH_REF:
15691       case NODE_BACK_REF:
15692         useless = "a variable";
15693         break;
15694       case NODE_CONST:
15695         useless = "a constant";
15696         break;
15697       case NODE_LIT:
15698       case NODE_STR:
15699       case NODE_DSTR:
15700       case NODE_DREGX:
15701       case NODE_DREGX_ONCE:
15702         useless = "a literal";
15703         break;
15704       case NODE_COLON2:
15705       case NODE_COLON3:
15706         useless = "::";
15707         break;
15708       case NODE_DOT2:
15709         useless = "..";
15710         break;
15711       case NODE_DOT3:
15712         useless = "...";
15713         break;
15714       case NODE_SELF:
15715         useless = "self";
15716         break;
15717       case NODE_NIL:
15718         useless = "nil";
15719         break;
15720       case NODE_TRUE:
15721         useless = "true";
15722         break;
15723       case NODE_FALSE:
15724         useless = "false";
15725         break;
15726       case NODE_DEFINED:
15727         useless = "defined?";
15728         break;
15729     }
15730 
15731     if (useless) {
15732         int line = ruby_sourceline;
15733 
15734         ruby_sourceline = nd_line(node);
15735         rb_warnS("possibly useless use of %s in void context", useless);
15736         ruby_sourceline = line;
15737     }
15738 }
15739 
15740 static void
15741 void_stmts_gen(struct parser_params *parser, NODE *node)
15742 {
15743     if (!RTEST(ruby_verbose)) return;
15744     if (!node) return;
15745     if (nd_type(node) != NODE_BLOCK) return;
15746 
15747     for (;;) {
15748         if (!node->nd_next) return;
15749         void_expr0(node->nd_head);
15750         node = node->nd_next;
15751     }
15752 }
15753 
15754 static NODE *
15755 remove_begin(NODE *node)
15756 {
15757     NODE **n = &node, *n1 = node;
15758     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15759         *n = n1 = n1->nd_body;
15760     }
15761     return node;
15762 }
15763 
15764 static NODE *
15765 remove_begin_all(NODE *node)
15766 {
15767     NODE **n = &node, *n1 = node;
15768     while (n1 && nd_type(n1) == NODE_BEGIN) {
15769         *n = n1 = n1->nd_body;
15770     }
15771     return node;
15772 }
15773 
15774 static void
15775 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15776 {
15777     NODE *node = *body;
15778 
15779     if (!node) {
15780         *body = NEW_NIL();
15781         return;
15782     }
15783 #define subnodes(n1, n2) \
15784     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15785      (!node->n2) ? (body = &node->n1, 1) : \
15786      (reduce_nodes(&node->n1), body = &node->n2, 1))
15787 
15788     while (node) {
15789         int newline = (int)(node->flags & NODE_FL_NEWLINE);
15790         switch (nd_type(node)) {
15791           end:
15792           case NODE_NIL:
15793             *body = 0;
15794             return;
15795           case NODE_RETURN:
15796             *body = node = node->nd_stts;
15797             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15798             continue;
15799           case NODE_BEGIN:
15800             *body = node = node->nd_body;
15801             if (newline && node) node->flags |= NODE_FL_NEWLINE;
15802             continue;
15803           case NODE_BLOCK:
15804             body = &node->nd_end->nd_head;
15805             break;
15806           case NODE_IF:
15807             if (subnodes(nd_body, nd_else)) break;
15808             return;
15809           case NODE_CASE:
15810             body = &node->nd_body;
15811             break;
15812           case NODE_WHEN:
15813             if (!subnodes(nd_body, nd_next)) goto end;
15814             break;
15815           case NODE_ENSURE:
15816             if (!subnodes(nd_head, nd_resq)) goto end;
15817             break;
15818           case NODE_RESCUE:
15819             if (node->nd_else) {
15820                 body = &node->nd_resq;
15821                 break;
15822             }
15823             if (!subnodes(nd_head, nd_resq)) goto end;
15824             break;
15825           default:
15826             return;
15827         }
15828         node = *body;
15829         if (newline && node) node->flags |= NODE_FL_NEWLINE;
15830     }
15831 
15832 #undef subnodes
15833 }
15834 
15835 static int
15836 is_static_content(NODE *node)
15837 {
15838     if (!node) return 1;
15839     switch (nd_type(node)) {
15840       case NODE_HASH:
15841         if (!(node = node->nd_head)) break;
15842       case NODE_ARRAY:
15843         do {
15844             if (!is_static_content(node->nd_head)) return 0;
15845         } while ((node = node->nd_next) != 0);
15846       case NODE_LIT:
15847       case NODE_STR:
15848       case NODE_NIL:
15849       case NODE_TRUE:
15850       case NODE_FALSE:
15851       case NODE_ZARRAY:
15852         break;
15853       default:
15854         return 0;
15855     }
15856     return 1;
15857 }
15858 
15859 static int
15860 assign_in_cond(struct parser_params *parser, NODE *node)
15861 {
15862     switch (nd_type(node)) {
15863       case NODE_MASGN:
15864         yyerror("multiple assignment in conditional");
15865         return 1;
15866 
15867       case NODE_LASGN:
15868       case NODE_DASGN:
15869       case NODE_DASGN_CURR:
15870       case NODE_GASGN:
15871       case NODE_IASGN:
15872         break;
15873 
15874       default:
15875         return 0;
15876     }
15877 
15878     if (!node->nd_value) return 1;
15879     if (is_static_content(node->nd_value)) {
15880         /* reports always */
15881         parser_warn(node->nd_value, "found = in conditional, should be ==");
15882     }
15883     return 1;
15884 }
15885 
15886 static void
15887 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15888 {
15889     if (!e_option_supplied(parser)) parser_warn(node, str);
15890 }
15891 
15892 static void
15893 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15894 {
15895     if (!e_option_supplied(parser)) parser_warning(node, str);
15896 }
15897 
15898 static void
15899 fixup_nodes(NODE **rootnode)
15900 {
15901     NODE *node, *next, *head;
15902 
15903     for (node = *rootnode; node; node = next) {
15904         enum node_type type;
15905         VALUE val;
15906 
15907         next = node->nd_next;
15908         head = node->nd_head;
15909         rb_gc_force_recycle((VALUE)node);
15910         *rootnode = next;
15911         switch (type = nd_type(head)) {
15912           case NODE_DOT2:
15913           case NODE_DOT3:
15914             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15915                                type == NODE_DOT3);
15916             rb_gc_force_recycle((VALUE)head->nd_beg);
15917             rb_gc_force_recycle((VALUE)head->nd_end);
15918             nd_set_type(head, NODE_LIT);
15919             head->nd_lit = val;
15920             break;
15921           default:
15922             break;
15923         }
15924     }
15925 }
15926 
15927 static NODE *cond0(struct parser_params*,NODE*);
15928 
15929 static NODE*
15930 range_op(struct parser_params *parser, NODE *node)
15931 {
15932     enum node_type type;
15933 
15934     if (node == 0) return 0;
15935 
15936     type = nd_type(node);
15937     value_expr(node);
15938     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15939         warn_unless_e_option(parser, node, "integer literal in conditional range");
15940         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15941     }
15942     return cond0(parser, node);
15943 }
15944 
15945 static int
15946 literal_node(NODE *node)
15947 {
15948     if (!node) return 1;        /* same as NODE_NIL */
15949     switch (nd_type(node)) {
15950       case NODE_LIT:
15951       case NODE_STR:
15952       case NODE_DSTR:
15953       case NODE_EVSTR:
15954       case NODE_DREGX:
15955       case NODE_DREGX_ONCE:
15956       case NODE_DSYM:
15957         return 2;
15958       case NODE_TRUE:
15959       case NODE_FALSE:
15960       case NODE_NIL:
15961         return 1;
15962     }
15963     return 0;
15964 }
15965 
15966 static NODE*
15967 cond0(struct parser_params *parser, NODE *node)
15968 {
15969     if (node == 0) return 0;
15970     assign_in_cond(parser, node);
15971 
15972     switch (nd_type(node)) {
15973       case NODE_DSTR:
15974       case NODE_EVSTR:
15975       case NODE_STR:
15976         rb_warn0("string literal in condition");
15977         break;
15978 
15979       case NODE_DREGX:
15980       case NODE_DREGX_ONCE:
15981         warning_unless_e_option(parser, node, "regex literal in condition");
15982         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15983 
15984       case NODE_AND:
15985       case NODE_OR:
15986         node->nd_1st = cond0(parser, node->nd_1st);
15987         node->nd_2nd = cond0(parser, node->nd_2nd);
15988         break;
15989 
15990       case NODE_DOT2:
15991       case NODE_DOT3:
15992         node->nd_beg = range_op(parser, node->nd_beg);
15993         node->nd_end = range_op(parser, node->nd_end);
15994         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15995         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15996         if (!e_option_supplied(parser)) {
15997             int b = literal_node(node->nd_beg);
15998             int e = literal_node(node->nd_end);
15999             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
16000                 parser_warn(node, "range literal in condition");
16001             }
16002         }
16003         break;
16004 
16005       case NODE_DSYM:
16006         parser_warning(node, "literal in condition");
16007         break;
16008 
16009       case NODE_LIT:
16010         if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
16011             warn_unless_e_option(parser, node, "regex literal in condition");
16012             nd_set_type(node, NODE_MATCH);
16013         }
16014         else {
16015             parser_warning(node, "literal in condition");
16016         }
16017       default:
16018         break;
16019     }
16020     return node;
16021 }
16022 
16023 static NODE*
16024 cond_gen(struct parser_params *parser, NODE *node)
16025 {
16026     if (node == 0) return 0;
16027     return cond0(parser, node);
16028 }
16029 
16030 static NODE*
16031 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
16032 {
16033     value_expr(left);
16034     if (left && (enum node_type)nd_type(left) == type) {
16035         NODE *node = left, *second;
16036         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
16037             node = second;
16038         }
16039         node->nd_2nd = NEW_NODE(type, second, right, 0);
16040         return left;
16041     }
16042     return NEW_NODE(type, left, right, 0);
16043 }
16044 
16045 static void
16046 no_blockarg(struct parser_params *parser, NODE *node)
16047 {
16048     if (node && nd_type(node) == NODE_BLOCK_PASS) {
16049         compile_error(PARSER_ARG "block argument should not be given");
16050     }
16051 }
16052 
16053 static NODE *
16054 ret_args_gen(struct parser_params *parser, NODE *node)
16055 {
16056     if (node) {
16057         no_blockarg(parser, node);
16058         if (nd_type(node) == NODE_ARRAY) {
16059             if (node->nd_next == 0) {
16060                 node = node->nd_head;
16061             }
16062             else {
16063                 nd_set_type(node, NODE_VALUES);
16064             }
16065         }
16066     }
16067     return node;
16068 }
16069 
16070 static NODE *
16071 new_yield_gen(struct parser_params *parser, NODE *node)
16072 {
16073     if (node) no_blockarg(parser, node);
16074 
16075     return NEW_YIELD(node);
16076 }
16077 
16078 static NODE*
16079 negate_lit(NODE *node)
16080 {
16081     switch (TYPE(node->nd_lit)) {
16082       case T_FIXNUM:
16083         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
16084         break;
16085       case T_BIGNUM:
16086       case T_RATIONAL:
16087       case T_COMPLEX:
16088         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
16089         break;
16090       case T_FLOAT:
16091 #if USE_FLONUM
16092         if (FLONUM_P(node->nd_lit)) {
16093             node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
16094         }
16095         else {
16096             RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16097         }
16098 #else
16099         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16100 #endif
16101         break;
16102       default:
16103         rb_bug("unknown literal type passed to negate_lit");
16104         break;
16105     }
16106     return node;
16107 }
16108 
16109 static NODE *
16110 arg_blk_pass(NODE *node1, NODE *node2)
16111 {
16112     if (node2) {
16113         node2->nd_head = node1;
16114         return node2;
16115     }
16116     return node1;
16117 }
16118 
16119 
16120 static NODE*
16121 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16122 {
16123     int saved_line = ruby_sourceline;
16124     struct rb_args_info *args = tail->nd_ainfo;
16125 
16126     args->pre_args_num   = m ? rb_long2int(m->nd_plen) : 0;
16127     args->pre_init       = m ? m->nd_next : 0;
16128 
16129     args->post_args_num  = p ? rb_long2int(p->nd_plen) : 0;
16130     args->post_init      = p ? p->nd_next : 0;
16131     args->first_post_arg = p ? p->nd_pid : 0;
16132 
16133     args->rest_arg       = r;
16134 
16135     args->opt_args       = o;
16136 
16137     ruby_sourceline = saved_line;
16138 
16139     return tail;
16140 }
16141 
16142 static NODE*
16143 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
16144 {
16145     int saved_line = ruby_sourceline;
16146     struct rb_args_info *args;
16147     NODE *kw_rest_arg = 0;
16148     NODE *node;
16149     int check = 0;
16150 
16151     args = ALLOC(struct rb_args_info);
16152     MEMZERO(args, struct rb_args_info, 1);
16153     node = NEW_NODE(NODE_ARGS, 0, 0, args);
16154 
16155     args->block_arg      = b;
16156     args->kw_args        = k;
16157     if (k && !kr) {
16158         check = 1;
16159         kr = internal_id();
16160     }
16161     if (kr) {
16162         arg_var(kr);
16163         kw_rest_arg  = NEW_DVAR(kr);
16164         kw_rest_arg->nd_cflag = check;
16165     }
16166     args->kw_rest_arg    = kw_rest_arg;
16167 
16168     ruby_sourceline = saved_line;
16169     return node;
16170 }
16171 
16172 static NODE*
16173 dsym_node_gen(struct parser_params *parser, NODE *node)
16174 {
16175     VALUE lit;
16176 
16177     if (!node) {
16178         return NEW_LIT(ID2SYM(idNULL));
16179     }
16180 
16181     switch (nd_type(node)) {
16182       case NODE_DSTR:
16183         nd_set_type(node, NODE_DSYM);
16184         break;
16185       case NODE_STR:
16186         lit = node->nd_lit;
16187         node->nd_lit = ID2SYM(rb_intern_str(lit));
16188         nd_set_type(node, NODE_LIT);
16189         break;
16190       default:
16191         node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
16192         break;
16193     }
16194     return node;
16195 }
16196 #endif /* !RIPPER */
16197 
16198 #ifndef RIPPER
16199 static NODE *
16200 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16201 {
16202     NODE *asgn;
16203 
16204     if (lhs) {
16205         ID vid = lhs->nd_vid;
16206         if (op == tOROP) {
16207             lhs->nd_value = rhs;
16208             asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16209             if (is_asgn_or_id(vid)) {
16210                 asgn->nd_aid = vid;
16211             }
16212         }
16213         else if (op == tANDOP) {
16214             lhs->nd_value = rhs;
16215             asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16216         }
16217         else {
16218             asgn = lhs;
16219             asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16220         }
16221     }
16222     else {
16223         asgn = NEW_BEGIN(0);
16224     }
16225     return asgn;
16226 }
16227 
16228 static NODE *
16229 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16230 {
16231     NODE *asgn;
16232 
16233     if (op == tOROP) {
16234         op = 0;
16235     }
16236     else if (op == tANDOP) {
16237         op = 1;
16238     }
16239     asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16240     fixpos(asgn, lhs);
16241     return asgn;
16242 }
16243 
16244 static NODE *
16245 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16246 {
16247     NODE *asgn;
16248 
16249     if (op == tOROP) {
16250         op = 0;
16251     }
16252     else if (op == tANDOP) {
16253         op = 1;
16254     }
16255     if (lhs) {
16256         asgn = NEW_OP_CDECL(lhs, op, rhs);
16257     }
16258     else {
16259         asgn = NEW_BEGIN(0);
16260     }
16261     fixpos(asgn, lhs);
16262     return asgn;
16263 }
16264 #else
16265 static VALUE
16266 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16267 {
16268     return dispatch3(opassign, lhs, op, rhs);
16269 }
16270 
16271 static VALUE
16272 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16273 {
16274     VALUE recv = dispatch3(field, lhs, type, attr);
16275     return dispatch3(opassign, recv, op, rhs);
16276 }
16277 #endif
16278 
16279 static void
16280 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16281 {
16282     int i, cnt;
16283     ID *v, *u;
16284 
16285     if (!local->used) return;
16286     v = local->vars->tbl;
16287     u = local->used->tbl;
16288     cnt = local->used->pos;
16289     if (cnt != local->vars->pos) {
16290         rb_bug("local->used->pos != local->vars->pos");
16291     }
16292     for (i = 0; i < cnt; ++i) {
16293         if (!v[i] || (u[i] & LVAR_USED)) continue;
16294         if (is_private_local_id(v[i])) continue;
16295         rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16296     }
16297 }
16298 
16299 static void
16300 local_push_gen(struct parser_params *parser, int inherit_dvars)
16301 {
16302     struct local_vars *local;
16303 
16304     local = ALLOC(struct local_vars);
16305     local->prev = lvtbl;
16306     local->args = vtable_alloc(0);
16307     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16308     local->used = !(inherit_dvars &&
16309                     (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
16310         RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16311     local->cmdargs = cmdarg_stack;
16312     cmdarg_stack = 0;
16313     lvtbl = local;
16314 }
16315 
16316 static void
16317 local_pop_gen(struct parser_params *parser)
16318 {
16319     struct local_vars *local = lvtbl->prev;
16320     if (lvtbl->used) {
16321         warn_unused_var(parser, lvtbl);
16322         vtable_free(lvtbl->used);
16323     }
16324     vtable_free(lvtbl->args);
16325     vtable_free(lvtbl->vars);
16326     cmdarg_stack = lvtbl->cmdargs;
16327     xfree(lvtbl);
16328     lvtbl = local;
16329 }
16330 
16331 #ifndef RIPPER
16332 static ID*
16333 local_tbl_gen(struct parser_params *parser)
16334 {
16335     int cnt_args = vtable_size(lvtbl->args);
16336     int cnt_vars = vtable_size(lvtbl->vars);
16337     int cnt = cnt_args + cnt_vars;
16338     int i, j;
16339     ID *buf;
16340 
16341     if (cnt <= 0) return 0;
16342     buf = ALLOC_N(ID, cnt + 1);
16343     MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16344     /* remove IDs duplicated to warn shadowing */
16345     for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16346         ID id = lvtbl->vars->tbl[i];
16347         if (!vtable_included(lvtbl->args, id)) {
16348             buf[j++] = id;
16349         }
16350     }
16351     if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16352     buf[0] = cnt;
16353     return buf;
16354 }
16355 #endif
16356 
16357 static int
16358 arg_var_gen(struct parser_params *parser, ID id)
16359 {
16360     vtable_add(lvtbl->args, id);
16361     return vtable_size(lvtbl->args) - 1;
16362 }
16363 
16364 static int
16365 local_var_gen(struct parser_params *parser, ID id)
16366 {
16367     vtable_add(lvtbl->vars, id);
16368     if (lvtbl->used) {
16369         vtable_add(lvtbl->used, (ID)ruby_sourceline);
16370     }
16371     return vtable_size(lvtbl->vars) - 1;
16372 }
16373 
16374 static int
16375 local_id_gen(struct parser_params *parser, ID id)
16376 {
16377     struct vtable *vars, *args, *used;
16378 
16379     vars = lvtbl->vars;
16380     args = lvtbl->args;
16381     used = lvtbl->used;
16382 
16383     while (vars && POINTER_P(vars->prev)) {
16384         vars = vars->prev;
16385         args = args->prev;
16386         if (used) used = used->prev;
16387     }
16388 
16389     if (vars && vars->prev == DVARS_INHERIT) {
16390         return rb_local_defined(id);
16391     }
16392     else if (vtable_included(args, id)) {
16393         return 1;
16394     }
16395     else {
16396         int i = vtable_included(vars, id);
16397         if (i && used) used->tbl[i-1] |= LVAR_USED;
16398         return i != 0;
16399     }
16400 }
16401 
16402 static const struct vtable *
16403 dyna_push_gen(struct parser_params *parser)
16404 {
16405     lvtbl->args = vtable_alloc(lvtbl->args);
16406     lvtbl->vars = vtable_alloc(lvtbl->vars);
16407     if (lvtbl->used) {
16408         lvtbl->used = vtable_alloc(lvtbl->used);
16409     }
16410     return lvtbl->args;
16411 }
16412 
16413 static void
16414 dyna_pop_1(struct parser_params *parser)
16415 {
16416     struct vtable *tmp;
16417 
16418     if ((tmp = lvtbl->used) != 0) {
16419         warn_unused_var(parser, lvtbl);
16420         lvtbl->used = lvtbl->used->prev;
16421         vtable_free(tmp);
16422     }
16423     tmp = lvtbl->args;
16424     lvtbl->args = lvtbl->args->prev;
16425     vtable_free(tmp);
16426     tmp = lvtbl->vars;
16427     lvtbl->vars = lvtbl->vars->prev;
16428     vtable_free(tmp);
16429 }
16430 
16431 static void
16432 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16433 {
16434     while (lvtbl->args != lvargs) {
16435         dyna_pop_1(parser);
16436         if (!lvtbl->args) {
16437             struct local_vars *local = lvtbl->prev;
16438             xfree(lvtbl);
16439             lvtbl = local;
16440         }
16441     }
16442     dyna_pop_1(parser);
16443 }
16444 
16445 static int
16446 dyna_in_block_gen(struct parser_params *parser)
16447 {
16448     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16449 }
16450 
16451 static int
16452 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16453 {
16454     struct vtable *vars, *args, *used;
16455     int i;
16456 
16457     args = lvtbl->args;
16458     vars = lvtbl->vars;
16459     used = lvtbl->used;
16460 
16461     while (POINTER_P(vars)) {
16462         if (vtable_included(args, id)) {
16463             return 1;
16464         }
16465         if ((i = vtable_included(vars, id)) != 0) {
16466             if (used) used->tbl[i-1] |= LVAR_USED;
16467             return 1;
16468         }
16469         args = args->prev;
16470         vars = vars->prev;
16471         if (get) used = 0;
16472         if (used) used = used->prev;
16473     }
16474 
16475     if (vars == DVARS_INHERIT) {
16476         return rb_dvar_defined(id);
16477     }
16478 
16479     return 0;
16480 }
16481 
16482 static int
16483 dvar_curr_gen(struct parser_params *parser, ID id)
16484 {
16485     return (vtable_included(lvtbl->args, id) ||
16486             vtable_included(lvtbl->vars, id));
16487 }
16488 
16489 #ifndef RIPPER
16490 static void
16491 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
16492 {
16493     int c = RE_OPTION_ENCODING_IDX(options);
16494 
16495     if (c) {
16496         int opt, idx;
16497         rb_char_to_option_kcode(c, &opt, &idx);
16498         if (idx != ENCODING_GET(str) &&
16499             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16500             goto error;
16501         }
16502         ENCODING_SET(str, idx);
16503     }
16504     else if (RE_OPTION_ENCODING_NONE(options)) {
16505         if (!ENCODING_IS_ASCII8BIT(str) &&
16506             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16507             c = 'n';
16508             goto error;
16509         }
16510         rb_enc_associate(str, rb_ascii8bit_encoding());
16511     }
16512     else if (current_enc == rb_usascii_encoding()) {
16513         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16514             /* raise in re.c */
16515             rb_enc_associate(str, rb_usascii_encoding());
16516         }
16517         else {
16518             rb_enc_associate(str, rb_ascii8bit_encoding());
16519         }
16520     }
16521     return;
16522 
16523   error:
16524     compile_error(PARSER_ARG
16525         "regexp encoding option '%c' differs from source encoding '%s'",
16526         c, rb_enc_name(rb_enc_get(str)));
16527 }
16528 
16529 static int
16530 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
16531 {
16532     VALUE err;
16533     reg_fragment_setenc(str, options);
16534     err = rb_reg_check_preprocess(str);
16535     if (err != Qnil) {
16536         err = rb_obj_as_string(err);
16537         compile_error(PARSER_ARG "%"PRIsVALUE, err);
16538         return 0;
16539     }
16540     return 1;
16541 }
16542 
16543 typedef struct {
16544     struct parser_params* parser;
16545     rb_encoding *enc;
16546     NODE *succ_block;
16547     NODE *fail_block;
16548     int num;
16549 } reg_named_capture_assign_t;
16550 
16551 static int
16552 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
16553           int back_num, int *back_refs, OnigRegex regex, void *arg0)
16554 {
16555     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
16556     struct parser_params* parser = arg->parser;
16557     rb_encoding *enc = arg->enc;
16558     long len = name_end - name;
16559     const char *s = (const char *)name;
16560     ID var;
16561 
16562     arg->num++;
16563 
16564     if (arg->succ_block == 0) {
16565         arg->succ_block = NEW_BEGIN(0);
16566         arg->fail_block = NEW_BEGIN(0);
16567     }
16568 
16569     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16570         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16571         !rb_enc_symname2_p(s, len, enc)) {
16572         return ST_CONTINUE;
16573     }
16574     var = rb_intern3(s, len, enc);
16575     if (dvar_defined(var) || local_id(var)) {
16576         rb_warningS("named capture conflicts a local variable - %s",
16577                     rb_id2name(var));
16578     }
16579     arg->succ_block = block_append(arg->succ_block,
16580         newline_node(node_assign(assignable(var,0),
16581             NEW_CALL(
16582               gettable(rb_intern("$~")),
16583               idAREF,
16584               NEW_LIST(NEW_LIT(ID2SYM(var))))
16585             )));
16586     arg->fail_block = block_append(arg->fail_block,
16587         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
16588     return ST_CONTINUE;
16589 }
16590 
16591 static NODE *
16592 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
16593 {
16594     reg_named_capture_assign_t arg;
16595 
16596     arg.parser = parser;
16597     arg.enc = rb_enc_get(regexp);
16598     arg.succ_block = 0;
16599     arg.fail_block = 0;
16600     arg.num = 0;
16601     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16602 
16603     if (arg.num == 0)
16604         return match;
16605 
16606     return
16607         block_append(
16608             newline_node(match),
16609             NEW_IF(gettable(rb_intern("$~")),
16610                 block_append(
16611                     newline_node(arg.succ_block),
16612                     newline_node(
16613                         NEW_CALL(
16614                           gettable(rb_intern("$~")),
16615                           rb_intern("begin"),
16616                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16617                 block_append(
16618                     newline_node(arg.fail_block),
16619                     newline_node(
16620                         NEW_LIT(Qnil)))));
16621 }
16622 
16623 static VALUE
16624 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16625 {
16626     VALUE re;
16627     VALUE err;
16628 
16629     reg_fragment_setenc(str, options);
16630     err = rb_errinfo();
16631     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
16632     if (NIL_P(re)) {
16633         ID mesg = rb_intern("mesg");
16634         VALUE m = rb_attr_get(rb_errinfo(), mesg);
16635         rb_set_errinfo(err);
16636         if (!NIL_P(err)) {
16637             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16638         }
16639         else {
16640             compile_error(PARSER_ARG "%"PRIsVALUE, m);
16641         }
16642         return Qnil;
16643     }
16644     return re;
16645 }
16646 
16647 void
16648 rb_gc_mark_parser(void)
16649 {
16650 }
16651 
16652 NODE*
16653 rb_parser_append_print(VALUE vparser, NODE *node)
16654 {
16655     NODE *prelude = 0;
16656     NODE *scope = node;
16657     struct parser_params *parser;
16658 
16659     if (!node) return node;
16660 
16661     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16662 
16663     node = node->nd_body;
16664 
16665     if (nd_type(node) == NODE_PRELUDE) {
16666         prelude = node;
16667         node = node->nd_body;
16668     }
16669 
16670     node = block_append(node,
16671                         NEW_FCALL(rb_intern("print"),
16672                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16673     if (prelude) {
16674         prelude->nd_body = node;
16675         scope->nd_body = prelude;
16676     }
16677     else {
16678         scope->nd_body = node;
16679     }
16680 
16681     return scope;
16682 }
16683 
16684 NODE *
16685 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16686 {
16687     NODE *prelude = 0;
16688     NODE *scope = node;
16689     struct parser_params *parser;
16690 
16691     if (!node) return node;
16692 
16693     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16694 
16695     node = node->nd_body;
16696 
16697     if (nd_type(node) == NODE_PRELUDE) {
16698         prelude = node;
16699         node = node->nd_body;
16700     }
16701     if (split) {
16702         node = block_append(NEW_GASGN(rb_intern("$F"),
16703                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
16704                                                rb_intern("split"), 0)),
16705                             node);
16706     }
16707     if (chop) {
16708         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16709                                      rb_intern("chop!"), 0), node);
16710     }
16711 
16712     node = NEW_OPT_N(node);
16713 
16714     if (prelude) {
16715         prelude->nd_body = node;
16716         scope->nd_body = prelude;
16717     }
16718     else {
16719         scope->nd_body = node;
16720     }
16721 
16722     return scope;
16723 }
16724 
16725 static const struct {
16726     ID token;
16727     const char *name;
16728 } op_tbl[] = {
16729     {tDOT2,     ".."},
16730     {tDOT3,     "..."},
16731     {tPOW,      "**"},
16732     {tDSTAR,    "**"},
16733     {tUPLUS,    "+@"},
16734     {tUMINUS,   "-@"},
16735     {tCMP,      "<=>"},
16736     {tGEQ,      ">="},
16737     {tLEQ,      "<="},
16738     {tEQ,       "=="},
16739     {tEQQ,      "==="},
16740     {tNEQ,      "!="},
16741     {tMATCH,    "=~"},
16742     {tNMATCH,   "!~"},
16743     {tAREF,     "[]"},
16744     {tASET,     "[]="},
16745     {tLSHFT,    "<<"},
16746     {tRSHFT,    ">>"},
16747     {tCOLON2,   "::"},
16748 };
16749 
16750 #define op_tbl_count numberof(op_tbl)
16751 
16752 #ifndef ENABLE_SELECTOR_NAMESPACE
16753 #define ENABLE_SELECTOR_NAMESPACE 0
16754 #endif
16755 
16756 static struct symbols {
16757     ID last_id;
16758     st_table *sym_id;
16759     st_table *id_str;
16760 #if ENABLE_SELECTOR_NAMESPACE
16761     st_table *ivar2_id;
16762     st_table *id_ivar2;
16763 #endif
16764     VALUE op_sym[tLAST_OP_ID];
16765     int minor_marked;
16766 } global_symbols = {tLAST_TOKEN};
16767 
16768 static const struct st_hash_type symhash = {
16769     rb_str_hash_cmp,
16770     rb_str_hash,
16771 };
16772 
16773 #if ENABLE_SELECTOR_NAMESPACE
16774 struct ivar2_key {
16775     ID id;
16776     VALUE klass;
16777 };
16778 
16779 static int
16780 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16781 {
16782     if (key1->id == key2->id && key1->klass == key2->klass) {
16783         return 0;
16784     }
16785     return 1;
16786 }
16787 
16788 static int
16789 ivar2_hash(struct ivar2_key *key)
16790 {
16791     return (key->id << 8) ^ (key->klass >> 2);
16792 }
16793 
16794 static const struct st_hash_type ivar2_hash_type = {
16795     ivar2_cmp,
16796     ivar2_hash,
16797 };
16798 #endif
16799 
16800 void
16801 Init_sym(void)
16802 {
16803     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16804     global_symbols.id_str = st_init_numtable_with_size(1000);
16805 #if ENABLE_SELECTOR_NAMESPACE
16806     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16807     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16808 #endif
16809 
16810     (void)nodetype;
16811     (void)nodeline;
16812 #if PARSER_DEBUG
16813     (void)lex_state_name(-1);
16814 #endif
16815 
16816     Init_id();
16817 }
16818 
16819 void
16820 rb_gc_mark_symbols(int full_mark)
16821 {
16822     if (full_mark || global_symbols.minor_marked == 0) {
16823         rb_mark_tbl(global_symbols.id_str);
16824         rb_gc_mark_locations(global_symbols.op_sym,
16825                              global_symbols.op_sym + numberof(global_symbols.op_sym));
16826 
16827         if (!full_mark) global_symbols.minor_marked = 1;
16828     }
16829 }
16830 #endif /* !RIPPER */
16831 
16832 static ID
16833 internal_id_gen(struct parser_params *parser)
16834 {
16835     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16836     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16837     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16838 }
16839 
16840 #ifndef RIPPER
16841 static int
16842 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16843 {
16844     int mb = 0;
16845 
16846     if (m >= e) return 0;
16847     if (is_global_name_punct(*m)) {
16848         ++m;
16849     }
16850     else if (*m == '-') {
16851         if (++m >= e) return 0;
16852         if (is_identchar(m, e, enc)) {
16853             if (!ISASCII(*m)) mb = 1;
16854             m += rb_enc_mbclen(m, e, enc);
16855         }
16856     }
16857     else {
16858         if (!rb_enc_isdigit(*m, enc)) return 0;
16859         do {
16860             if (!ISASCII(*m)) mb = 1;
16861             ++m;
16862         } while (m < e && rb_enc_isdigit(*m, enc));
16863     }
16864     return m == e ? mb + 1 : 0;
16865 }
16866 
16867 int
16868 rb_symname_p(const char *name)
16869 {
16870     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16871 }
16872 
16873 int
16874 rb_enc_symname_p(const char *name, rb_encoding *enc)
16875 {
16876     return rb_enc_symname2_p(name, strlen(name), enc);
16877 }
16878 
16879 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16880 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
16881 
16882 static int
16883 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
16884 {
16885     const char *m = name;
16886     const char *e = m + len;
16887     int type = ID_JUNK;
16888 
16889     if (!m || len <= 0) return -1;
16890     switch (*m) {
16891       case '\0':
16892         return -1;
16893 
16894       case '$':
16895         type = ID_GLOBAL;
16896         if (is_special_global_name(++m, e, enc)) return type;
16897         goto id;
16898 
16899       case '@':
16900         type = ID_INSTANCE;
16901         if (*++m == '@') {
16902             ++m;
16903             type = ID_CLASS;
16904         }
16905         goto id;
16906 
16907       case '<':
16908         switch (*++m) {
16909           case '<': ++m; break;
16910           case '=': if (*++m == '>') ++m; break;
16911           default: break;
16912         }
16913         break;
16914 
16915       case '>':
16916         switch (*++m) {
16917           case '>': case '=': ++m; break;
16918         }
16919         break;
16920 
16921       case '=':
16922         switch (*++m) {
16923           case '~': ++m; break;
16924           case '=': if (*++m == '=') ++m; break;
16925           default: return -1;
16926         }
16927         break;
16928 
16929       case '*':
16930         if (*++m == '*') ++m;
16931         break;
16932 
16933       case '+': case '-':
16934         if (*++m == '@') ++m;
16935         break;
16936 
16937       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16938         ++m;
16939         break;
16940 
16941       case '[':
16942         if (*++m != ']') return -1;
16943         if (*++m == '=') ++m;
16944         break;
16945 
16946       case '!':
16947         if (len == 1) return ID_JUNK;
16948         switch (*++m) {
16949           case '=': case '~': ++m; break;
16950           default: return -1;
16951         }
16952         break;
16953 
16954       default:
16955         type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16956       id:
16957         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16958             return -1;
16959         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16960         if (m >= e) break;
16961         switch (*m) {
16962           case '!': case '?':
16963             if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16964             type = ID_JUNK;
16965             ++m;
16966             break;
16967           case '=':
16968             if (!(allowed_attrset & (1U << type))) return -1;
16969             type = ID_ATTRSET;
16970             ++m;
16971             break;
16972         }
16973         break;
16974     }
16975     return m == e ? type : -1;
16976 }
16977 
16978 int
16979 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16980 {
16981     return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16982 }
16983 
16984 static int
16985 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
16986 {
16987     const char *ptr = StringValuePtr(name);
16988     long len = RSTRING_LEN(name);
16989     int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
16990     RB_GC_GUARD(name);
16991     return type;
16992 }
16993 
16994 static ID
16995 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16996 {
16997     VALUE str = rb_enc_str_new(name, len, enc);
16998     return register_symid_str(id, str);
16999 }
17000 
17001 static ID
17002 register_symid_str(ID id, VALUE str)
17003 {
17004     OBJ_FREEZE(str);
17005     str = rb_fstring(str);
17006 
17007     if (RUBY_DTRACE_SYMBOL_CREATE_ENABLED()) {
17008         RUBY_DTRACE_SYMBOL_CREATE(RSTRING_PTR(str), rb_sourcefile(), rb_sourceline());
17009     }
17010 
17011     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
17012     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
17013     global_symbols.minor_marked = 0;
17014     return id;
17015 }
17016 
17017 static int
17018 sym_check_asciionly(VALUE str)
17019 {
17020     if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
17021     switch (rb_enc_str_coderange(str)) {
17022       case ENC_CODERANGE_BROKEN:
17023         rb_raise(rb_eEncodingError, "invalid encoding symbol");
17024       case ENC_CODERANGE_7BIT:
17025         return TRUE;
17026     }
17027     return FALSE;
17028 }
17029 
17030 /*
17031  * _str_ itself will be registered at the global symbol table.  _str_
17032  * can be modified before the registration, since the encoding will be
17033  * set to ASCII-8BIT if it is a special global name.
17034  */
17035 static ID intern_str(VALUE str);
17036 
17037 static VALUE
17038 setup_fake_str(struct RString *fake_str, const char *name, long len)
17039 {
17040     fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
17041     RBASIC_SET_CLASS_RAW((VALUE)fake_str, rb_cString);
17042     fake_str->as.heap.len = len;
17043     fake_str->as.heap.ptr = (char *)name;
17044     fake_str->as.heap.aux.capa = len;
17045     return (VALUE)fake_str;
17046 }
17047 
17048 ID
17049 rb_intern3(const char *name, long len, rb_encoding *enc)
17050 {
17051     st_data_t data;
17052     struct RString fake_str;
17053     VALUE str = setup_fake_str(&fake_str, name, len);
17054     rb_enc_associate(str, enc);
17055     OBJ_FREEZE(str);
17056 
17057     if (st_lookup(global_symbols.sym_id, str, &data))
17058         return (ID)data;
17059 
17060     str = rb_enc_str_new(name, len, enc); /* make true string */
17061     return intern_str(str);
17062 }
17063 
17064 static ID
17065 intern_str(VALUE str)
17066 {
17067     const char *name, *m, *e;
17068     long len, last;
17069     rb_encoding *enc, *symenc;
17070     unsigned char c;
17071     ID id;
17072     int mb;
17073 
17074     RSTRING_GETMEM(str, name, len);
17075     m = name;
17076     e = m + len;
17077     enc = rb_enc_get(str);
17078     symenc = enc;
17079 
17080     if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
17081       junk:
17082         id = ID_JUNK;
17083         goto new_id;
17084     }
17085     last = len-1;
17086     id = 0;
17087     switch (*m) {
17088       case '$':
17089         if (len < 2) goto junk;
17090         id |= ID_GLOBAL;
17091         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
17092             if (!--mb) symenc = rb_usascii_encoding();
17093             goto new_id;
17094         }
17095         break;
17096       case '@':
17097         if (m[1] == '@') {
17098             if (len < 3) goto junk;
17099             m++;
17100             id |= ID_CLASS;
17101         }
17102         else {
17103             if (len < 2) goto junk;
17104             id |= ID_INSTANCE;
17105         }
17106         m++;
17107         break;
17108       default:
17109         c = m[0];
17110         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
17111             /* operators */
17112             int i;
17113 
17114             if (len == 1) {
17115                 id = c;
17116                 goto id_register;
17117             }
17118             for (i = 0; i < op_tbl_count; i++) {
17119                 if (*op_tbl[i].name == *m &&
17120                     strcmp(op_tbl[i].name, m) == 0) {
17121                     id = op_tbl[i].token;
17122                     goto id_register;
17123                 }
17124             }
17125         }
17126         break;
17127     }
17128     if (name[last] == '=') {
17129         /* attribute assignment */
17130         if (last > 1 && name[last-1] == '=')
17131             goto junk;
17132         id = rb_intern3(name, last, enc);
17133         if (id > tLAST_OP_ID && !is_attrset_id(id)) {
17134             enc = rb_enc_get(rb_id2str(id));
17135             id = rb_id_attrset(id);
17136             goto id_register;
17137         }
17138         id = ID_ATTRSET;
17139     }
17140     else if (id == 0) {
17141         if (rb_enc_isupper(m[0], enc)) {
17142             id = ID_CONST;
17143         }
17144         else {
17145             id = ID_LOCAL;
17146         }
17147     }
17148     if (!rb_enc_isdigit(*m, enc)) {
17149         while (m <= name + last && is_identchar(m, e, enc)) {
17150             if (ISASCII(*m)) {
17151                 m++;
17152             }
17153             else {
17154                 m += rb_enc_mbclen(m, e, enc);
17155             }
17156         }
17157     }
17158     if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
17159     if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
17160   new_id:
17161     if (symenc != enc) rb_enc_associate(str, symenc);
17162     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
17163         if (len > 20) {
17164             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
17165                      name);
17166         }
17167         else {
17168             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
17169                      (int)len, name);
17170         }
17171     }
17172     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
17173   id_register:
17174     return register_symid_str(id, str);
17175 }
17176 
17177 ID
17178 rb_intern2(const char *name, long len)
17179 {
17180     return rb_intern3(name, len, rb_usascii_encoding());
17181 }
17182 
17183 #undef rb_intern
17184 ID
17185 rb_intern(const char *name)
17186 {
17187     return rb_intern2(name, strlen(name));
17188 }
17189 
17190 ID
17191 rb_intern_str(VALUE str)
17192 {
17193     st_data_t id;
17194 
17195     if (st_lookup(global_symbols.sym_id, str, &id))
17196         return (ID)id;
17197     return intern_str(rb_str_dup(str));
17198 }
17199 
17200 VALUE
17201 rb_id2str(ID id)
17202 {
17203     st_data_t data;
17204 
17205     if (id < tLAST_TOKEN) {
17206         int i = 0;
17207 
17208         if (id < INT_MAX && rb_ispunct((int)id)) {
17209             VALUE str = global_symbols.op_sym[i = (int)id];
17210             if (!str) {
17211                 char name[2];
17212                 name[0] = (char)id;
17213                 name[1] = 0;
17214                 str = rb_usascii_str_new(name, 1);
17215                 OBJ_FREEZE(str);
17216                 str = rb_fstring(str);
17217                 global_symbols.op_sym[i] = str;
17218                 global_symbols.minor_marked = 0;
17219             }
17220             return str;
17221         }
17222         for (i = 0; i < op_tbl_count; i++) {
17223             if (op_tbl[i].token == id) {
17224                 VALUE str = global_symbols.op_sym[i];
17225                 if (!str) {
17226                     str = rb_usascii_str_new2(op_tbl[i].name);
17227                     OBJ_FREEZE(str);
17228                     str = rb_fstring(str);
17229                     global_symbols.op_sym[i] = str;
17230                     global_symbols.minor_marked = 0;
17231                 }
17232                 return str;
17233             }
17234         }
17235     }
17236 
17237     if (st_lookup(global_symbols.id_str, id, &data)) {
17238         VALUE str = (VALUE)data;
17239         if (RBASIC(str)->klass == 0)
17240             RBASIC_SET_CLASS_RAW(str, rb_cString);
17241         return str;
17242     }
17243 
17244     if (is_attrset_id(id)) {
17245         ID id_stem = (id & ~ID_SCOPE_MASK);
17246         VALUE str;
17247 
17248         do {
17249             if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17250             if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17251             if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17252             if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17253             if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17254             if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17255             return 0;
17256         } while (0);
17257         str = rb_str_dup(str);
17258         rb_str_cat(str, "=", 1);
17259         register_symid_str(id, str);
17260         if (st_lookup(global_symbols.id_str, id, &data)) {
17261             VALUE str = (VALUE)data;
17262             if (RBASIC(str)->klass == 0)
17263                 RBASIC_SET_CLASS_RAW(str, rb_cString);
17264             return str;
17265         }
17266     }
17267     return 0;
17268 }
17269 
17270 const char *
17271 rb_id2name(ID id)
17272 {
17273     VALUE str = rb_id2str(id);
17274 
17275     if (!str) return 0;
17276     return RSTRING_PTR(str);
17277 }
17278 
17279 static int
17280 symbols_i(VALUE sym, ID value, VALUE ary)
17281 {
17282     rb_ary_push(ary, ID2SYM(value));
17283     return ST_CONTINUE;
17284 }
17285 
17286 /*
17287  *  call-seq:
17288  *     Symbol.all_symbols    => array
17289  *
17290  *  Returns an array of all the symbols currently in Ruby's symbol
17291  *  table.
17292  *
17293  *     Symbol.all_symbols.size    #=> 903
17294  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
17295  *                                     :chown, :EOFError, :$;, :String,
17296  *                                     :LOCK_SH, :"setuid?", :$<,
17297  *                                     :default_proc, :compact, :extend,
17298  *                                     :Tms, :getwd, :$=, :ThreadGroup,
17299  *                                     :wait2, :$>]
17300  */
17301 
17302 VALUE
17303 rb_sym_all_symbols(void)
17304 {
17305     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
17306 
17307     st_foreach(global_symbols.sym_id, symbols_i, ary);
17308     return ary;
17309 }
17310 
17311 int
17312 rb_is_const_id(ID id)
17313 {
17314     return is_const_id(id);
17315 }
17316 
17317 int
17318 rb_is_class_id(ID id)
17319 {
17320     return is_class_id(id);
17321 }
17322 
17323 int
17324 rb_is_global_id(ID id)
17325 {
17326     return is_global_id(id);
17327 }
17328 
17329 int
17330 rb_is_instance_id(ID id)
17331 {
17332     return is_instance_id(id);
17333 }
17334 
17335 int
17336 rb_is_attrset_id(ID id)
17337 {
17338     return is_attrset_id(id);
17339 }
17340 
17341 int
17342 rb_is_local_id(ID id)
17343 {
17344     return is_local_id(id);
17345 }
17346 
17347 int
17348 rb_is_junk_id(ID id)
17349 {
17350     return is_junk_id(id);
17351 }
17352 
17364 ID
17365 rb_check_id(volatile VALUE *namep)
17366 {
17367     st_data_t id;
17368     VALUE tmp;
17369     VALUE name = *namep;
17370 
17371     if (SYMBOL_P(name)) {
17372         return SYM2ID(name);
17373     }
17374     else if (!RB_TYPE_P(name, T_STRING)) {
17375         tmp = rb_check_string_type(name);
17376         if (NIL_P(tmp)) {
17377             tmp = rb_inspect(name);
17378             rb_raise(rb_eTypeError, "%s is not a symbol",
17379                      RSTRING_PTR(tmp));
17380         }
17381         name = tmp;
17382         *namep = name;
17383     }
17384 
17385     sym_check_asciionly(name);
17386 
17387     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17388         return (ID)id;
17389 
17390     if (rb_is_attrset_name(name)) {
17391         struct RString fake_str;
17392         /* make local name by chopping '=' */
17393         const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
17394         rb_enc_copy(localname, name);
17395         OBJ_FREEZE(localname);
17396 
17397         if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17398             return rb_id_attrset((ID)id);
17399         }
17400         RB_GC_GUARD(name);
17401     }
17402 
17403     return (ID)0;
17404 }
17405 
17406 ID
17407 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17408 {
17409     st_data_t id;
17410     struct RString fake_str;
17411     const VALUE name = setup_fake_str(&fake_str, ptr, len);
17412     rb_enc_associate(name, enc);
17413 
17414     sym_check_asciionly(name);
17415 
17416     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17417         return (ID)id;
17418 
17419     if (rb_is_attrset_name(name)) {
17420         fake_str.as.heap.len = len - 1;
17421         if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17422             return rb_id_attrset((ID)id);
17423         }
17424     }
17425 
17426     return (ID)0;
17427 }
17428 
17429 int
17430 rb_is_const_name(VALUE name)
17431 {
17432     return rb_str_symname_type(name, 0) == ID_CONST;
17433 }
17434 
17435 int
17436 rb_is_class_name(VALUE name)
17437 {
17438     return rb_str_symname_type(name, 0) == ID_CLASS;
17439 }
17440 
17441 int
17442 rb_is_global_name(VALUE name)
17443 {
17444     return rb_str_symname_type(name, 0) == ID_GLOBAL;
17445 }
17446 
17447 int
17448 rb_is_instance_name(VALUE name)
17449 {
17450     return rb_str_symname_type(name, 0) == ID_INSTANCE;
17451 }
17452 
17453 int
17454 rb_is_attrset_name(VALUE name)
17455 {
17456     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
17457 }
17458 
17459 int
17460 rb_is_local_name(VALUE name)
17461 {
17462     return rb_str_symname_type(name, 0) == ID_LOCAL;
17463 }
17464 
17465 int
17466 rb_is_method_name(VALUE name)
17467 {
17468     switch (rb_str_symname_type(name, 0)) {
17469       case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17470         return TRUE;
17471     }
17472     return FALSE;
17473 }
17474 
17475 int
17476 rb_is_junk_name(VALUE name)
17477 {
17478     return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17479 }
17480 
17481 #endif /* !RIPPER */
17482 
17483 static void
17484 parser_initialize(struct parser_params *parser)
17485 {
17486     parser->eofp = Qfalse;
17487 
17488     parser->parser_lex_strterm = 0;
17489     parser->parser_cond_stack = 0;
17490     parser->parser_cmdarg_stack = 0;
17491     parser->parser_class_nest = 0;
17492     parser->parser_paren_nest = 0;
17493     parser->parser_lpar_beg = 0;
17494     parser->parser_brace_nest = 0;
17495     parser->parser_in_single = 0;
17496     parser->parser_in_def = 0;
17497     parser->parser_in_defined = 0;
17498     parser->parser_in_kwarg = 0;
17499     parser->parser_compile_for_eval = 0;
17500     parser->parser_cur_mid = 0;
17501     parser->parser_tokenbuf = NULL;
17502     parser->parser_tokidx = 0;
17503     parser->parser_toksiz = 0;
17504     parser->parser_heredoc_end = 0;
17505     parser->parser_command_start = TRUE;
17506     parser->parser_deferred_nodes = 0;
17507     parser->parser_lex_pbeg = 0;
17508     parser->parser_lex_p = 0;
17509     parser->parser_lex_pend = 0;
17510     parser->parser_lvtbl = 0;
17511     parser->parser_ruby__end__seen = 0;
17512     parser->parser_ruby_sourcefile = 0;
17513     parser->parser_ruby_sourcefile_string = Qnil;
17514 #ifndef RIPPER
17515     parser->is_ripper = 0;
17516     parser->parser_eval_tree_begin = 0;
17517     parser->parser_eval_tree = 0;
17518 #else
17519     parser->is_ripper = 1;
17520     parser->delayed = Qnil;
17521 
17522     parser->result = Qnil;
17523     parser->parsing_thread = Qnil;
17524     parser->toplevel_p = TRUE;
17525 #endif
17526 #ifdef YYMALLOC
17527     parser->heap = NULL;
17528 #endif
17529     parser->enc = rb_utf8_encoding();
17530 }
17531 
17532 #ifdef RIPPER
17533 #define parser_mark ripper_parser_mark
17534 #define parser_free ripper_parser_free
17535 #endif
17536 
17537 static void
17538 parser_mark(void *ptr)
17539 {
17540     struct parser_params *p = (struct parser_params*)ptr;
17541 
17542     rb_gc_mark((VALUE)p->parser_lex_strterm);
17543     rb_gc_mark((VALUE)p->parser_deferred_nodes);
17544     rb_gc_mark(p->parser_lex_input);
17545     rb_gc_mark(p->parser_lex_lastline);
17546     rb_gc_mark(p->parser_lex_nextline);
17547     rb_gc_mark(p->parser_ruby_sourcefile_string);
17548 #ifndef RIPPER
17549     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
17550     rb_gc_mark((VALUE)p->parser_eval_tree) ;
17551     rb_gc_mark(p->debug_lines);
17552 #else
17553     rb_gc_mark(p->delayed);
17554     rb_gc_mark(p->value);
17555     rb_gc_mark(p->result);
17556     rb_gc_mark(p->parsing_thread);
17557 #endif
17558 #ifdef YYMALLOC
17559     rb_gc_mark((VALUE)p->heap);
17560 #endif
17561 }
17562 
17563 static void
17564 parser_free(void *ptr)
17565 {
17566     struct parser_params *p = (struct parser_params*)ptr;
17567     struct local_vars *local, *prev;
17568 
17569     if (p->parser_tokenbuf) {
17570         xfree(p->parser_tokenbuf);
17571     }
17572     for (local = p->parser_lvtbl; local; local = prev) {
17573         if (local->vars) xfree(local->vars);
17574         prev = local->prev;
17575         xfree(local);
17576     }
17577     xfree(p);
17578 }
17579 
17580 static size_t
17581 parser_memsize(const void *ptr)
17582 {
17583     struct parser_params *p = (struct parser_params*)ptr;
17584     struct local_vars *local;
17585     size_t size = sizeof(*p);
17586 
17587     if (!ptr) return 0;
17588     size += p->parser_toksiz;
17589     for (local = p->parser_lvtbl; local; local = local->prev) {
17590         size += sizeof(*local);
17591         if (local->vars) size += local->vars->capa * sizeof(ID);
17592     }
17593     return size;
17594 }
17595 
17596 static
17597 #ifndef RIPPER
17598 const
17599 #endif
17600 rb_data_type_t parser_data_type = {
17601     "parser",
17602     {
17603         parser_mark,
17604         parser_free,
17605         parser_memsize,
17606     },
17607     NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
17608 };
17609 
17610 #ifndef RIPPER
17611 #undef rb_reserved_word
17612 
17613 const struct kwtable *
17614 rb_reserved_word(const char *str, unsigned int len)
17615 {
17616     return reserved_word(str, len);
17617 }
17618 
17619 static struct parser_params *
17620 parser_new(void)
17621 {
17622     struct parser_params *p;
17623 
17624     p = ALLOC_N(struct parser_params, 1);
17625     MEMZERO(p, struct parser_params, 1);
17626     parser_initialize(p);
17627     return p;
17628 }
17629 
17630 VALUE
17631 rb_parser_new(void)
17632 {
17633     struct parser_params *p = parser_new();
17634 
17635     return TypedData_Wrap_Struct(0, &parser_data_type, p);
17636 }
17637 
17638 /*
17639  *  call-seq:
17640  *    ripper#end_seen?   -> Boolean
17641  *
17642  *  Return true if parsed source ended by +\_\_END\_\_+.
17643  */
17644 VALUE
17645 rb_parser_end_seen_p(VALUE vparser)
17646 {
17647     struct parser_params *parser;
17648 
17649     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17650     return ruby__end__seen ? Qtrue : Qfalse;
17651 }
17652 
17653 /*
17654  *  call-seq:
17655  *    ripper#encoding   -> encoding
17656  *
17657  *  Return encoding of the source.
17658  */
17659 VALUE
17660 rb_parser_encoding(VALUE vparser)
17661 {
17662     struct parser_params *parser;
17663 
17664     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17665     return rb_enc_from_encoding(current_enc);
17666 }
17667 
17668 /*
17669  *  call-seq:
17670  *    ripper.yydebug   -> true or false
17671  *
17672  *  Get yydebug.
17673  */
17674 VALUE
17675 rb_parser_get_yydebug(VALUE self)
17676 {
17677     struct parser_params *parser;
17678 
17679     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17680     return yydebug ? Qtrue : Qfalse;
17681 }
17682 
17683 /*
17684  *  call-seq:
17685  *    ripper.yydebug = flag
17686  *
17687  *  Set yydebug.
17688  */
17689 VALUE
17690 rb_parser_set_yydebug(VALUE self, VALUE flag)
17691 {
17692     struct parser_params *parser;
17693 
17694     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17695     yydebug = RTEST(flag);
17696     return flag;
17697 }
17698 
17699 #ifdef YYMALLOC
17700 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17701 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17702 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17703                            (n)->u3.cnt = (c), (p))
17704 
17705 void *
17706 rb_parser_malloc(struct parser_params *parser, size_t size)
17707 {
17708     size_t cnt = HEAPCNT(1, size);
17709     NODE *n = NEWHEAP();
17710     void *ptr = xmalloc(size);
17711 
17712     return ADD2HEAP(n, cnt, ptr);
17713 }
17714 
17715 void *
17716 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17717 {
17718     size_t cnt = HEAPCNT(nelem, size);
17719     NODE *n = NEWHEAP();
17720     void *ptr = xcalloc(nelem, size);
17721 
17722     return ADD2HEAP(n, cnt, ptr);
17723 }
17724 
17725 void *
17726 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17727 {
17728     NODE *n;
17729     size_t cnt = HEAPCNT(1, size);
17730 
17731     if (ptr && (n = parser->heap) != NULL) {
17732         do {
17733             if (n->u1.node == ptr) {
17734                 n->u1.node = ptr = xrealloc(ptr, size);
17735                 if (n->u3.cnt) n->u3.cnt = cnt;
17736                 return ptr;
17737             }
17738         } while ((n = n->u2.node) != NULL);
17739     }
17740     n = NEWHEAP();
17741     ptr = xrealloc(ptr, size);
17742     return ADD2HEAP(n, cnt, ptr);
17743 }
17744 
17745 void
17746 rb_parser_free(struct parser_params *parser, void *ptr)
17747 {
17748     NODE **prev = &parser->heap, *n;
17749 
17750     while ((n = *prev) != NULL) {
17751         if (n->u1.node == ptr) {
17752             *prev = n->u2.node;
17753             rb_gc_force_recycle((VALUE)n);
17754             break;
17755         }
17756         prev = &n->u2.node;
17757     }
17758     xfree(ptr);
17759 }
17760 #endif
17761 #endif
17762 
17763 #ifdef RIPPER
17764 #ifdef RIPPER_DEBUG
17765 extern int rb_is_pointer_to_heap(VALUE);
17766 
17767 /* :nodoc: */
17768 static VALUE
17769 ripper_validate_object(VALUE self, VALUE x)
17770 {
17771     if (x == Qfalse) return x;
17772     if (x == Qtrue) return x;
17773     if (x == Qnil) return x;
17774     if (x == Qundef)
17775         rb_raise(rb_eArgError, "Qundef given");
17776     if (FIXNUM_P(x)) return x;
17777     if (SYMBOL_P(x)) return x;
17778     if (!rb_is_pointer_to_heap(x))
17779         rb_raise(rb_eArgError, "invalid pointer: %p", x);
17780     switch (BUILTIN_TYPE(x)) {
17781       case T_STRING:
17782       case T_OBJECT:
17783       case T_ARRAY:
17784       case T_BIGNUM:
17785       case T_FLOAT:
17786       case T_COMPLEX:
17787       case T_RATIONAL:
17788         return x;
17789       case T_NODE:
17790         if (nd_type(x) != NODE_LASGN) {
17791             rb_raise(rb_eArgError, "NODE given: %p", x);
17792         }
17793         return ((NODE *)x)->nd_rval;
17794       default:
17795         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17796                  x, rb_obj_classname(x));
17797     }
17798     return x;
17799 }
17800 #endif
17801 
17802 #define validate(x) ((x) = get_value(x))
17803 
17804 static VALUE
17805 ripper_dispatch0(struct parser_params *parser, ID mid)
17806 {
17807     return rb_funcall(parser->value, mid, 0);
17808 }
17809 
17810 static VALUE
17811 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17812 {
17813     validate(a);
17814     return rb_funcall(parser->value, mid, 1, a);
17815 }
17816 
17817 static VALUE
17818 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17819 {
17820     validate(a);
17821     validate(b);
17822     return rb_funcall(parser->value, mid, 2, a, b);
17823 }
17824 
17825 static VALUE
17826 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17827 {
17828     validate(a);
17829     validate(b);
17830     validate(c);
17831     return rb_funcall(parser->value, mid, 3, a, b, c);
17832 }
17833 
17834 static VALUE
17835 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17836 {
17837     validate(a);
17838     validate(b);
17839     validate(c);
17840     validate(d);
17841     return rb_funcall(parser->value, mid, 4, a, b, c, d);
17842 }
17843 
17844 static VALUE
17845 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17846 {
17847     validate(a);
17848     validate(b);
17849     validate(c);
17850     validate(d);
17851     validate(e);
17852     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17853 }
17854 
17855 static VALUE
17856 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17857 {
17858     validate(a);
17859     validate(b);
17860     validate(c);
17861     validate(d);
17862     validate(e);
17863     validate(f);
17864     validate(g);
17865     return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17866 }
17867 
17868 static const struct kw_assoc {
17869     ID id;
17870     const char *name;
17871 } keyword_to_name[] = {
17872     {keyword_class,     "class"},
17873     {keyword_module,    "module"},
17874     {keyword_def,       "def"},
17875     {keyword_undef,     "undef"},
17876     {keyword_begin,     "begin"},
17877     {keyword_rescue,    "rescue"},
17878     {keyword_ensure,    "ensure"},
17879     {keyword_end,       "end"},
17880     {keyword_if,        "if"},
17881     {keyword_unless,    "unless"},
17882     {keyword_then,      "then"},
17883     {keyword_elsif,     "elsif"},
17884     {keyword_else,      "else"},
17885     {keyword_case,      "case"},
17886     {keyword_when,      "when"},
17887     {keyword_while,     "while"},
17888     {keyword_until,     "until"},
17889     {keyword_for,       "for"},
17890     {keyword_break,     "break"},
17891     {keyword_next,      "next"},
17892     {keyword_redo,      "redo"},
17893     {keyword_retry,     "retry"},
17894     {keyword_in,        "in"},
17895     {keyword_do,        "do"},
17896     {keyword_do_cond,   "do"},
17897     {keyword_do_block,  "do"},
17898     {keyword_return,    "return"},
17899     {keyword_yield,     "yield"},
17900     {keyword_super,     "super"},
17901     {keyword_self,      "self"},
17902     {keyword_nil,       "nil"},
17903     {keyword_true,      "true"},
17904     {keyword_false,     "false"},
17905     {keyword_and,       "and"},
17906     {keyword_or,        "or"},
17907     {keyword_not,       "not"},
17908     {modifier_if,       "if"},
17909     {modifier_unless,   "unless"},
17910     {modifier_while,    "while"},
17911     {modifier_until,    "until"},
17912     {modifier_rescue,   "rescue"},
17913     {keyword_alias,     "alias"},
17914     {keyword_defined,   "defined?"},
17915     {keyword_BEGIN,     "BEGIN"},
17916     {keyword_END,       "END"},
17917     {keyword__LINE__,   "__LINE__"},
17918     {keyword__FILE__,   "__FILE__"},
17919     {keyword__ENCODING__, "__ENCODING__"},
17920     {0, NULL}
17921 };
17922 
17923 static const char*
17924 keyword_id_to_str(ID id)
17925 {
17926     const struct kw_assoc *a;
17927 
17928     for (a = keyword_to_name; a->id; a++) {
17929         if (a->id == id)
17930             return a->name;
17931     }
17932     return NULL;
17933 }
17934 
17935 #undef ripper_id2sym
17936 static VALUE
17937 ripper_id2sym(ID id)
17938 {
17939     const char *name;
17940     char buf[8];
17941 
17942     if (id <= 256) {
17943         buf[0] = (char)id;
17944         buf[1] = '\0';
17945         return ID2SYM(rb_intern2(buf, 1));
17946     }
17947     if ((name = keyword_id_to_str(id))) {
17948         return ID2SYM(rb_intern(name));
17949     }
17950     switch (id) {
17951       case tOROP:
17952         name = "||";
17953         break;
17954       case tANDOP:
17955         name = "&&";
17956         break;
17957       default:
17958         name = rb_id2name(id);
17959         if (!name) {
17960             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17961         }
17962         return ID2SYM(id);
17963     }
17964     return ID2SYM(rb_intern(name));
17965 }
17966 
17967 static ID
17968 ripper_get_id(VALUE v)
17969 {
17970     NODE *nd;
17971     if (!RB_TYPE_P(v, T_NODE)) return 0;
17972     nd = (NODE *)v;
17973     if (nd_type(nd) != NODE_LASGN) return 0;
17974     return nd->nd_vid;
17975 }
17976 
17977 static VALUE
17978 ripper_get_value(VALUE v)
17979 {
17980     NODE *nd;
17981     if (v == Qundef) return Qnil;
17982     if (!RB_TYPE_P(v, T_NODE)) return v;
17983     nd = (NODE *)v;
17984     if (nd_type(nd) != NODE_LASGN) return Qnil;
17985     return nd->nd_rval;
17986 }
17987 
17988 static void
17989 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17990 {
17991     VALUE str;
17992     va_list args;
17993 
17994     va_start(args, fmt);
17995     str = rb_vsprintf(fmt, args);
17996     va_end(args);
17997     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17998 }
17999 
18000 static void
18001 ripper_warn0(struct parser_params *parser, const char *fmt)
18002 {
18003     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
18004 }
18005 
18006 static void
18007 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
18008 {
18009     rb_funcall(parser->value, rb_intern("warn"), 2,
18010                STR_NEW2(fmt), INT2NUM(a));
18011 }
18012 
18013 static void
18014 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
18015 {
18016     rb_funcall(parser->value, rb_intern("warn"), 2,
18017                STR_NEW2(fmt), STR_NEW2(str));
18018 }
18019 
18020 static void
18021 ripper_warning0(struct parser_params *parser, const char *fmt)
18022 {
18023     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
18024 }
18025 
18026 static void
18027 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
18028 {
18029     rb_funcall(parser->value, rb_intern("warning"), 2,
18030                STR_NEW2(fmt), STR_NEW2(str));
18031 }
18032 
18033 static VALUE
18034 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
18035 {
18036     return rb_io_gets(src);
18037 }
18038 
18039 static VALUE
18040 ripper_s_allocate(VALUE klass)
18041 {
18042     struct parser_params *p;
18043     VALUE self;
18044 
18045     p = ALLOC_N(struct parser_params, 1);
18046     MEMZERO(p, struct parser_params, 1);
18047     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
18048     p->value = self;
18049     return self;
18050 }
18051 
18052 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
18053 
18054 /*
18055  *  call-seq:
18056  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
18057  *
18058  *  Create a new Ripper object.
18059  *  _src_ must be a String, an IO, or an Object which has #gets method.
18060  *
18061  *  This method does not starts parsing.
18062  *  See also Ripper#parse and Ripper.parse.
18063  */
18064 static VALUE
18065 ripper_initialize(int argc, VALUE *argv, VALUE self)
18066 {
18067     struct parser_params *parser;
18068     VALUE src, fname, lineno;
18069 
18070     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18071     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
18072     if (RB_TYPE_P(src, T_FILE)) {
18073         parser->parser_lex_gets = ripper_lex_get_generic;
18074     }
18075     else {
18076         StringValue(src);
18077         parser->parser_lex_gets = lex_get_str;
18078     }
18079     parser->parser_lex_input = src;
18080     parser->eofp = Qfalse;
18081     if (NIL_P(fname)) {
18082         fname = STR_NEW2("(ripper)");
18083     }
18084     else {
18085         StringValue(fname);
18086     }
18087     parser_initialize(parser);
18088 
18089     parser->parser_ruby_sourcefile_string = fname;
18090     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
18091     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
18092 
18093     return Qnil;
18094 }
18095 
18096 struct ripper_args {
18097     struct parser_params *parser;
18098     int argc;
18099     VALUE *argv;
18100 };
18101 
18102 static VALUE
18103 ripper_parse0(VALUE parser_v)
18104 {
18105     struct parser_params *parser;
18106 
18107     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18108     parser_prepare(parser);
18109     ripper_yyparse((void*)parser);
18110     return parser->result;
18111 }
18112 
18113 static VALUE
18114 ripper_ensure(VALUE parser_v)
18115 {
18116     struct parser_params *parser;
18117 
18118     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18119     parser->parsing_thread = Qnil;
18120     return Qnil;
18121 }
18122 
18123 /*
18124  *  call-seq:
18125  *    ripper#parse
18126  *
18127  *  Start parsing and returns the value of the root action.
18128  */
18129 static VALUE
18130 ripper_parse(VALUE self)
18131 {
18132     struct parser_params *parser;
18133 
18134     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18135     if (!ripper_initialized_p(parser)) {
18136         rb_raise(rb_eArgError, "method called for uninitialized object");
18137     }
18138     if (!NIL_P(parser->parsing_thread)) {
18139         if (parser->parsing_thread == rb_thread_current())
18140             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
18141         else
18142             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
18143     }
18144     parser->parsing_thread = rb_thread_current();
18145     rb_ensure(ripper_parse0, self, ripper_ensure, self);
18146 
18147     return parser->result;
18148 }
18149 
18150 /*
18151  *  call-seq:
18152  *    ripper#column   -> Integer
18153  *
18154  *  Return column number of current parsing line.
18155  *  This number starts from 0.
18156  */
18157 static VALUE
18158 ripper_column(VALUE self)
18159 {
18160     struct parser_params *parser;
18161     long col;
18162 
18163     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18164     if (!ripper_initialized_p(parser)) {
18165         rb_raise(rb_eArgError, "method called for uninitialized object");
18166     }
18167     if (NIL_P(parser->parsing_thread)) return Qnil;
18168     col = parser->tokp - parser->parser_lex_pbeg;
18169     return LONG2NUM(col);
18170 }
18171 
18172 /*
18173  *  call-seq:
18174  *    ripper#filename   -> String
18175  *
18176  *  Return current parsing filename.
18177  */
18178 static VALUE
18179 ripper_filename(VALUE self)
18180 {
18181     struct parser_params *parser;
18182 
18183     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18184     if (!ripper_initialized_p(parser)) {
18185         rb_raise(rb_eArgError, "method called for uninitialized object");
18186     }
18187     return parser->parser_ruby_sourcefile_string;
18188 }
18189 
18190 /*
18191  *  call-seq:
18192  *    ripper#lineno   -> Integer
18193  *
18194  *  Return line number of current parsing line.
18195  *  This number starts from 1.
18196  */
18197 static VALUE
18198 ripper_lineno(VALUE self)
18199 {
18200     struct parser_params *parser;
18201 
18202     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18203     if (!ripper_initialized_p(parser)) {
18204         rb_raise(rb_eArgError, "method called for uninitialized object");
18205     }
18206     if (NIL_P(parser->parsing_thread)) return Qnil;
18207     return INT2NUM(parser->parser_ruby_sourceline);
18208 }
18209 
18210 #ifdef RIPPER_DEBUG
18211 /* :nodoc: */
18212 static VALUE
18213 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18214 {
18215     StringValue(msg);
18216     if (obj == Qundef) {
18217         rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
18218     }
18219     return Qnil;
18220 }
18221 
18222 /* :nodoc: */
18223 static VALUE
18224 ripper_value(VALUE self, VALUE obj)
18225 {
18226     return ULONG2NUM(obj);
18227 }
18228 #endif
18229 
18230 
18231 void
18232 Init_ripper(void)
18233 {
18234     parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
18235 
18236     ripper_init_eventids1();
18237     ripper_init_eventids2();
18238     /* ensure existing in symbol table */
18239     (void)rb_intern("||");
18240     (void)rb_intern("&&");
18241 
18242     InitVM(ripper);
18243 }
18244 
18245 void
18246 InitVM_ripper(void)
18247 {
18248     VALUE Ripper;
18249 
18250     Ripper = rb_define_class("Ripper", rb_cObject);
18251     /* version of Ripper */
18252     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18253     rb_define_alloc_func(Ripper, ripper_s_allocate);
18254     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18255     rb_define_method(Ripper, "parse", ripper_parse, 0);
18256     rb_define_method(Ripper, "column", ripper_column, 0);
18257     rb_define_method(Ripper, "filename", ripper_filename, 0);
18258     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18259     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18260     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18261     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18262     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18263 #ifdef RIPPER_DEBUG
18264     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18265     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18266     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18267 #endif
18268 
18269     ripper_init_eventids1_table(Ripper);
18270     ripper_init_eventids2_table(Ripper);
18271 
18272 # if 0
18273     /* Hack to let RDoc document SCRIPT_LINES__ */
18274 
18275     /*
18276      * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18277      * after the assignment will be added as an Array of lines with the file
18278      * name as the key.
18279      */
18280     rb_define_global_const("SCRIPT_LINES__", Qnil);
18281 #endif
18282 
18283 }
18284 #endif /* RIPPER */
18285 
18286