Ruby: ext/ripper/ripper.c Source File

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.7.1.  */
00002 
00003 /* Bison implementation for Yacc-like parsers in C
00004    
00005       Copyright (C) 1984, 1989-1990, 2000-2013 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.7.1"
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 
00062 
00063 
00064 /* Copy the first part of user declarations.  */
00065 /* Line 371 of yacc.c  */
00066 #line 12 "ripper.y"
00067 
00068 
00069 #define YYDEBUG 1
00070 #define YYERROR_VERBOSE 1
00071 #define YYSTACK_USE_ALLOCA 0
00072 
00073 #include "ruby/ruby.h"
00074 #include "ruby/st.h"
00075 #include "ruby/encoding.h"
00076 #include "internal.h"
00077 #include "node.h"
00078 #include "parse.h"
00079 #include "id.h"
00080 #include "regenc.h"
00081 #include <stdio.h>
00082 #include <errno.h>
00083 #include <ctype.h>
00084 
00085 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
00086 
00087 #define YYMALLOC(size)          rb_parser_malloc(parser, (size))
00088 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, (ptr), (size))
00089 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, (nelem), (size))
00090 #define YYFREE(ptr)             rb_parser_free(parser, (ptr))
00091 #define malloc  YYMALLOC
00092 #define realloc YYREALLOC
00093 #define calloc  YYCALLOC
00094 #define free    YYFREE
00095 
00096 #ifndef RIPPER
00097 static ID register_symid(ID, const char *, long, rb_encoding *);
00098 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
00099 #include "id.c"
00100 #endif
00101 
00102 #define is_notop_id(id) ((id)>tLAST_TOKEN)
00103 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00104 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00105 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00106 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00107 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00108 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00109 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00110 
00111 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00112         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00113          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00114          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00115 
00116 enum lex_state_e {
00117     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
00118     EXPR_END,                   /* newline significant, +/- is an operator. */
00119     EXPR_ENDARG,                /* ditto, and unbound braces. */
00120     EXPR_ENDFN,                 /* ditto, and unbound braces. */
00121     EXPR_ARG,                   /* newline significant, +/- is an operator. */
00122     EXPR_CMDARG,                /* newline significant, +/- is an operator. */
00123     EXPR_MID,                   /* newline significant, +/- is an operator. */
00124     EXPR_FNAME,                 /* ignore newline, no reserved words. */
00125     EXPR_DOT,                   /* right after `.' or `::', no reserved words. */
00126     EXPR_CLASS,                 /* immediate after `class', no here document. */
00127     EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
00128     EXPR_MAX_STATE
00129 };
00130 
00131 typedef VALUE stack_type;
00132 
00133 # define BITSTACK_PUSH(stack, n)        ((stack) = ((stack)<<1)|((n)&1))
00134 # define BITSTACK_POP(stack)    ((stack) = (stack) >> 1)
00135 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
00136 # define BITSTACK_SET_P(stack)  ((stack)&1)
00137 
00138 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, (n))
00139 #define COND_POP()      BITSTACK_POP(cond_stack)
00140 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00141 #define COND_P()        BITSTACK_SET_P(cond_stack)
00142 
00143 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, (n))
00144 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00145 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00146 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00147 
00148 struct vtable {
00149     ID *tbl;
00150     int pos;
00151     int capa;
00152     struct vtable *prev;
00153 };
00154 
00155 struct local_vars {
00156     struct vtable *args;
00157     struct vtable *vars;
00158     struct vtable *used;
00159     struct local_vars *prev;
00160     stack_type cmdargs;
00161 };
00162 
00163 #define DVARS_INHERIT ((void*)1)
00164 #define DVARS_TOPSCOPE NULL
00165 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00166 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00167 
00168 static int
00169 vtable_size(const struct vtable *tbl)
00170 {
00171     if (POINTER_P(tbl)) {
00172         return tbl->pos;
00173     }
00174     else {
00175         return 0;
00176     }
00177 }
00178 
00179 #define VTBL_DEBUG 0
00180 
00181 static struct vtable *
00182 vtable_alloc(struct vtable *prev)
00183 {
00184     struct vtable *tbl = ALLOC(struct vtable);
00185     tbl->pos = 0;
00186     tbl->capa = 8;
00187     tbl->tbl = ALLOC_N(ID, tbl->capa);
00188     tbl->prev = prev;
00189     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00190     return tbl;
00191 }
00192 
00193 static void
00194 vtable_free(struct vtable *tbl)
00195 {
00196     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00197     if (POINTER_P(tbl)) {
00198         if (tbl->tbl) {
00199             xfree(tbl->tbl);
00200         }
00201         xfree(tbl);
00202     }
00203 }
00204 
00205 static void
00206 vtable_add(struct vtable *tbl, ID id)
00207 {
00208     if (!POINTER_P(tbl)) {
00209         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00210     }
00211     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00212 
00213     if (tbl->pos == tbl->capa) {
00214         tbl->capa = tbl->capa * 2;
00215         REALLOC_N(tbl->tbl, ID, tbl->capa);
00216     }
00217     tbl->tbl[tbl->pos++] = id;
00218 }
00219 
00220 static int
00221 vtable_included(const struct vtable * tbl, ID id)
00222 {
00223     int i;
00224 
00225     if (POINTER_P(tbl)) {
00226         for (i = 0; i < tbl->pos; i++) {
00227             if (tbl->tbl[i] == id) {
00228                 return i+1;
00229             }
00230         }
00231     }
00232     return 0;
00233 }
00234 
00235 
00236 #ifndef RIPPER
00237 typedef struct token_info {
00238     const char *token;
00239     int linenum;
00240     int column;
00241     int nonspc;
00242     struct token_info *next;
00243 } token_info;
00244 #endif
00245 
00246 /*
00247     Structure of Lexer Buffer:
00248 
00249  lex_pbeg      tokp         lex_p        lex_pend
00250     |           |              |            |
00251     |-----------+--------------+------------|
00252                 |<------------>|
00253                      token
00254 */
00255 struct parser_params {
00256     int is_ripper;
00257     NODE *heap;
00258 
00259     YYSTYPE *parser_yylval;
00260     VALUE eofp;
00261 
00262     NODE *parser_lex_strterm;
00263     enum lex_state_e parser_lex_state;
00264     stack_type parser_cond_stack;
00265     stack_type parser_cmdarg_stack;
00266     int parser_class_nest;
00267     int parser_paren_nest;
00268     int parser_lpar_beg;
00269     int parser_in_single;
00270     int parser_in_def;
00271     int parser_compile_for_eval;
00272     VALUE parser_cur_mid;
00273     int parser_in_defined;
00274     char *parser_tokenbuf;
00275     int parser_tokidx;
00276     int parser_toksiz;
00277     VALUE parser_lex_input;
00278     VALUE parser_lex_lastline;
00279     VALUE parser_lex_nextline;
00280     const char *parser_lex_pbeg;
00281     const char *parser_lex_p;
00282     const char *parser_lex_pend;
00283     int parser_heredoc_end;
00284     int parser_command_start;
00285     NODE *parser_deferred_nodes;
00286     long parser_lex_gets_ptr;
00287     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00288     struct local_vars *parser_lvtbl;
00289     int parser_ruby__end__seen;
00290     int line_count;
00291     int has_shebang;
00292     char *parser_ruby_sourcefile; /* current source file */
00293     int parser_ruby_sourceline; /* current line no. */
00294     rb_encoding *enc;
00295     rb_encoding *utf8;
00296 
00297     int parser_yydebug;
00298 
00299 #ifndef RIPPER
00300     /* Ruby core only */
00301     NODE *parser_eval_tree_begin;
00302     NODE *parser_eval_tree;
00303     VALUE debug_lines;
00304     VALUE coverage;
00305     int nerr;
00306 
00307     int parser_token_info_enabled;
00308     token_info *parser_token_info;
00309 #else
00310     /* Ripper only */
00311     VALUE parser_ruby_sourcefile_string;
00312     const char *tokp;
00313     VALUE delayed;
00314     int delayed_line;
00315     int delayed_col;
00316 
00317     VALUE value;
00318     VALUE result;
00319     VALUE parsing_thread;
00320     int toplevel_p;
00321 #endif
00322 };
00323 
00324 #define UTF8_ENC() (parser->utf8 ? parser->utf8 : \
00325                     (parser->utf8 = rb_utf8_encoding()))
00326 #define STR_NEW(p,n) rb_enc_str_new((p),(n),parser->enc)
00327 #define STR_NEW0() rb_enc_str_new(0,0,parser->enc)
00328 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),parser->enc)
00329 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),parser->enc)
00330 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00331 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), parser->enc)
00332 
00333 static int parser_yyerror(struct parser_params*, const char*);
00334 #define yyerror(msg) parser_yyerror(parser, (msg))
00335 
00336 #define lex_strterm             (parser->parser_lex_strterm)
00337 #define lex_state               (parser->parser_lex_state)
00338 #define cond_stack              (parser->parser_cond_stack)
00339 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00340 #define class_nest              (parser->parser_class_nest)
00341 #define paren_nest              (parser->parser_paren_nest)
00342 #define lpar_beg                (parser->parser_lpar_beg)
00343 #define in_single               (parser->parser_in_single)
00344 #define in_def                  (parser->parser_in_def)
00345 #define compile_for_eval        (parser->parser_compile_for_eval)
00346 #define cur_mid                 (parser->parser_cur_mid)
00347 #define in_defined              (parser->parser_in_defined)
00348 #define tokenbuf                (parser->parser_tokenbuf)
00349 #define tokidx                  (parser->parser_tokidx)
00350 #define toksiz                  (parser->parser_toksiz)
00351 #define lex_input               (parser->parser_lex_input)
00352 #define lex_lastline            (parser->parser_lex_lastline)
00353 #define lex_nextline            (parser->parser_lex_nextline)
00354 #define lex_pbeg                (parser->parser_lex_pbeg)
00355 #define lex_p                   (parser->parser_lex_p)
00356 #define lex_pend                (parser->parser_lex_pend)
00357 #define heredoc_end             (parser->parser_heredoc_end)
00358 #define command_start           (parser->parser_command_start)
00359 #define deferred_nodes          (parser->parser_deferred_nodes)
00360 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00361 #define lex_gets                (parser->parser_lex_gets)
00362 #define lvtbl                   (parser->parser_lvtbl)
00363 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00364 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00365 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00366 #define current_enc             (parser->enc)
00367 #define yydebug                 (parser->parser_yydebug)
00368 #ifdef RIPPER
00369 #else
00370 #define ruby_eval_tree          (parser->parser_eval_tree)
00371 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00372 #define ruby_debug_lines        (parser->debug_lines)
00373 #define ruby_coverage           (parser->coverage)
00374 #endif
00375 
00376 #if YYPURE
00377 static int yylex(void*, void*);
00378 #else
00379 static int yylex(void*);
00380 #endif
00381 
00382 #ifndef RIPPER
00383 #define yyparse ruby_yyparse
00384 
00385 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00386 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
00387 
00388 static NODE *cond_gen(struct parser_params*,NODE*);
00389 #define cond(node) cond_gen(parser, (node))
00390 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00391 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
00392 
00393 static NODE *newline_node(NODE*);
00394 static void fixpos(NODE*,NODE*);
00395 
00396 static int value_expr_gen(struct parser_params*,NODE*);
00397 static void void_expr_gen(struct parser_params*,NODE*);
00398 static NODE *remove_begin(NODE*);
00399 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00400 #define void_expr0(node) void_expr_gen(parser, (node))
00401 #define void_expr(node) void_expr0((node) = remove_begin(node))
00402 static void void_stmts_gen(struct parser_params*,NODE*);
00403 #define void_stmts(node) void_stmts_gen(parser, (node))
00404 static void reduce_nodes_gen(struct parser_params*,NODE**);
00405 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
00406 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00407 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
00408 
00409 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00410 #define block_append(h,t) block_append_gen(parser,(h),(t))
00411 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00412 #define list_append(l,i) list_append_gen(parser,(l),(i))
00413 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00414 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
00415 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00416 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
00417 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00418 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
00419 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00420 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
00421 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00422 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00423 #define new_evstr(n) new_evstr_gen(parser,(n))
00424 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00425 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
00426 static NODE *splat_array(NODE*);
00427 
00428 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00429 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
00430 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00431 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
00432 
00433 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
00434 #define new_args(f,o,r,p,b) new_args_gen(parser, (f),(o),(r),(p),(b))
00435 
00436 static NODE *negate_lit(NODE*);
00437 static NODE *ret_args_gen(struct parser_params*,NODE*);
00438 #define ret_args(node) ret_args_gen(parser, (node))
00439 static NODE *arg_blk_pass(NODE*,NODE*);
00440 static NODE *new_yield_gen(struct parser_params*,NODE*);
00441 #define new_yield(node) new_yield_gen(parser, (node))
00442 
00443 static NODE *gettable_gen(struct parser_params*,ID);
00444 #define gettable(id) gettable_gen(parser,(id))
00445 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00446 #define assignable(id,node) assignable_gen(parser, (id), (node))
00447 
00448 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00449 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
00450 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00451 #define attrset(node,id) attrset_gen(parser, (node), (id))
00452 
00453 static void rb_backref_error_gen(struct parser_params*,NODE*);
00454 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
00455 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00456 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
00457 
00458 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00459 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
00460 
00461 static ID  *local_tbl_gen(struct parser_params*);
00462 #define local_tbl() local_tbl_gen(parser)
00463 
00464 static void fixup_nodes(NODE **);
00465 
00466 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00467 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
00468 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00469 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
00470 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00471 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
00472 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00473 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
00474 
00475 #define get_id(id) (id)
00476 #define get_value(val) (val)
00477 #else
00478 #define remove_begin(node) (node)
00479 #define rb_dvar_defined(id) 0
00480 #define rb_local_defined(id) 0
00481 static ID ripper_get_id(VALUE);
00482 #define get_id(id) ripper_get_id(id)
00483 static VALUE ripper_get_value(VALUE);
00484 #define get_value(val) ripper_get_value(val)
00485 static VALUE assignable_gen(struct parser_params*,VALUE);
00486 #define assignable(lhs,node) assignable_gen(parser, (lhs))
00487 static int id_is_var_gen(struct parser_params *parser, ID id);
00488 #define id_is_var(id) id_is_var_gen(parser, (id))
00489 #endif /* !RIPPER */
00490 
00491 static ID formal_argument_gen(struct parser_params*, ID);
00492 #define formal_argument(id) formal_argument_gen(parser, (id))
00493 static ID shadowing_lvar_gen(struct parser_params*,ID);
00494 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
00495 static void new_bv_gen(struct parser_params*,ID);
00496 #define new_bv(id) new_bv_gen(parser, (id))
00497 
00498 static void local_push_gen(struct parser_params*,int);
00499 #define local_push(top) local_push_gen(parser,(top))
00500 static void local_pop_gen(struct parser_params*);
00501 #define local_pop() local_pop_gen(parser)
00502 static int local_var_gen(struct parser_params*, ID);
00503 #define local_var(id) local_var_gen(parser, (id));
00504 static int arg_var_gen(struct parser_params*, ID);
00505 #define arg_var(id) arg_var_gen(parser, (id))
00506 static int  local_id_gen(struct parser_params*, ID);
00507 #define local_id(id) local_id_gen(parser, (id))
00508 static ID   internal_id_gen(struct parser_params*);
00509 #define internal_id() internal_id_gen(parser)
00510 
00511 static const struct vtable *dyna_push_gen(struct parser_params *);
00512 #define dyna_push() dyna_push_gen(parser)
00513 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00514 #define dyna_pop(node) dyna_pop_gen(parser, (node))
00515 static int dyna_in_block_gen(struct parser_params*);
00516 #define dyna_in_block() dyna_in_block_gen(parser)
00517 #define dyna_var(id) local_var(id)
00518 static int dvar_defined_gen(struct parser_params*,ID,int);
00519 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
00520 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
00521 static int dvar_curr_gen(struct parser_params*,ID);
00522 #define dvar_curr(id) dvar_curr_gen(parser, (id))
00523 
00524 static int lvar_defined_gen(struct parser_params*, ID);
00525 #define lvar_defined(id) lvar_defined_gen(parser, (id))
00526 
00527 #define RE_OPTION_ONCE (1<<16)
00528 #define RE_OPTION_ENCODING_SHIFT 8
00529 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00530 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00531 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00532 #define RE_OPTION_MASK  0xff
00533 #define RE_OPTION_ARG_ENCODING_NONE 32
00534 
00535 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00536 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00537 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00538 #define nd_func u1.id
00539 #if SIZEOF_SHORT == 2
00540 #define nd_term(node) ((signed short)(node)->u2.id)
00541 #else
00542 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00543 #endif
00544 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00545 #define nd_nest u3.cnt
00546 
00547 /****** Ripper *******/
00548 
00549 #ifdef RIPPER
00550 #define RIPPER_VERSION "0.1.0"
00551 
00552 #include "eventids1.c"
00553 #include "eventids2.c"
00554 static ID ripper_id_gets;
00555 
00556 static VALUE ripper_dispatch0(struct parser_params*,ID);
00557 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00558 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00559 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00560 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00561 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00562 
00563 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00564 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
00565 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
00566 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
00567 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
00568 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
00569 
00570 #define yyparse ripper_yyparse
00571 
00572 #define ripper_intern(s) ID2SYM(rb_intern(s))
00573 static VALUE ripper_id2sym(ID);
00574 #ifdef __GNUC__
00575 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00576                            ID2SYM(id) : ripper_id2sym(id))
00577 #endif
00578 
00579 #define arg_new() dispatch0(args_new)
00580 #define arg_add(l,a) dispatch2(args_add, (l), (a))
00581 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
00582 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
00583 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
00584 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
00585 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
00586 
00587 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
00588 #define mrhs_new() dispatch0(mrhs_new)
00589 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
00590 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
00591 
00592 #define mlhs_new() dispatch0(mlhs_new)
00593 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
00594 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
00595 
00596 #define params_new(pars, opts, rest, pars2, blk) \
00597         dispatch5(params, (pars), (opts), (rest), (pars2), (blk))
00598 
00599 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
00600 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
00601 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
00602 
00603 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
00604 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
00605 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
00606 
00607 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00608 
00609 #define FIXME 0
00610 
00611 #endif /* RIPPER */
00612 
00613 #ifndef RIPPER
00614 # define ifndef_ripper(x) (x)
00615 #else
00616 # define ifndef_ripper(x)
00617 #endif
00618 
00619 #ifndef RIPPER
00620 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
00621 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00622 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00623 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
00624 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00625 #else
00626 # define rb_warn0(fmt)    ripper_warn0(parser, (fmt))
00627 # define rb_warnI(fmt,a)  ripper_warnI(parser, (fmt), (a))
00628 # define rb_warnS(fmt,a)  ripper_warnS(parser, (fmt), (a))
00629 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
00630 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
00631 static void ripper_warn0(struct parser_params*, const char*);
00632 static void ripper_warnI(struct parser_params*, const char*, int);
00633 #if 0
00634 static void ripper_warnS(struct parser_params*, const char*, const char*);
00635 #endif
00636 static void ripper_warning0(struct parser_params*, const char*);
00637 static void ripper_warningS(struct parser_params*, const char*, const char*);
00638 #endif
00639 
00640 #ifdef RIPPER
00641 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00642 # define rb_compile_error ripper_compile_error
00643 # define compile_error ripper_compile_error
00644 # define PARSER_ARG parser,
00645 #else
00646 # define rb_compile_error rb_compile_error_with_enc
00647 # define compile_error parser->nerr++,rb_compile_error_with_enc
00648 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
00649 #endif
00650 
00651 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00652    for instance).  This is too low for Ruby to parse some files, such as
00653    date/format.rb, therefore bump the value up to at least Bison's default. */
00654 #ifdef OLD_YACC
00655 #ifndef YYMAXDEPTH
00656 #define YYMAXDEPTH 10000
00657 #endif
00658 #endif
00659 
00660 #ifndef RIPPER
00661 static void token_info_push(struct parser_params*, const char *token);
00662 static void token_info_pop(struct parser_params*, const char *token);
00663 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
00664 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
00665 #else
00666 #define token_info_push(token) /* nothing */
00667 #define token_info_pop(token) /* nothing */
00668 #endif
00669 
00670 /* Line 371 of yacc.c  */
00671 #line 672 "parse.c"
00672 
00673 # ifndef YY_NULL
00674 #  if defined __cplusplus && 201103L <= __cplusplus
00675 #   define YY_NULL nullptr
00676 #  else
00677 #   define YY_NULL 0
00678 #  endif
00679 # endif
00680 
00681 /* Enabling verbose error messages.  */
00682 #ifdef YYERROR_VERBOSE
00683 # undef YYERROR_VERBOSE
00684 # define YYERROR_VERBOSE 1
00685 #else
00686 # define YYERROR_VERBOSE 0
00687 #endif
00688 
00689 
00690 /* Enabling traces.  */
00691 #ifndef YYDEBUG
00692 # define YYDEBUG 1
00693 #endif
00694 #if YYDEBUG
00695 #ifndef yydebug
00696 extern int yydebug;
00697 #endif
00698 #endif
00699 
00700 /* Tokens.  */
00701 #ifndef YYTOKENTYPE
00702 # define YYTOKENTYPE
00703    /* Put the tokens into the symbol table, so that GDB and other debuggers
00704       know about them.  */
00705    enum yytokentype {
00706      keyword_class = 258,
00707      keyword_module = 259,
00708      keyword_def = 260,
00709      keyword_undef = 261,
00710      keyword_begin = 262,
00711      keyword_rescue = 263,
00712      keyword_ensure = 264,
00713      keyword_end = 265,
00714      keyword_if = 266,
00715      keyword_unless = 267,
00716      keyword_then = 268,
00717      keyword_elsif = 269,
00718      keyword_else = 270,
00719      keyword_case = 271,
00720      keyword_when = 272,
00721      keyword_while = 273,
00722      keyword_until = 274,
00723      keyword_for = 275,
00724      keyword_break = 276,
00725      keyword_next = 277,
00726      keyword_redo = 278,
00727      keyword_retry = 279,
00728      keyword_in = 280,
00729      keyword_do = 281,
00730      keyword_do_cond = 282,
00731      keyword_do_block = 283,
00732      keyword_do_LAMBDA = 284,
00733      keyword_return = 285,
00734      keyword_yield = 286,
00735      keyword_super = 287,
00736      keyword_self = 288,
00737      keyword_nil = 289,
00738      keyword_true = 290,
00739      keyword_false = 291,
00740      keyword_and = 292,
00741      keyword_or = 293,
00742      keyword_not = 294,
00743      modifier_if = 295,
00744      modifier_unless = 296,
00745      modifier_while = 297,
00746      modifier_until = 298,
00747      modifier_rescue = 299,
00748      keyword_alias = 300,
00749      keyword_defined = 301,
00750      keyword_BEGIN = 302,
00751      keyword_END = 303,
00752      keyword__LINE__ = 304,
00753      keyword__FILE__ = 305,
00754      keyword__ENCODING__ = 306,
00755      tIDENTIFIER = 307,
00756      tFID = 308,
00757      tGVAR = 309,
00758      tIVAR = 310,
00759      tCONSTANT = 311,
00760      tCVAR = 312,
00761      tLABEL = 313,
00762      tINTEGER = 314,
00763      tFLOAT = 315,
00764      tSTRING_CONTENT = 316,
00765      tCHAR = 317,
00766      tNTH_REF = 318,
00767      tBACK_REF = 319,
00768      tREGEXP_END = 320,
00769      tUPLUS = 321,
00770      tUMINUS = 322,
00771      tPOW = 323,
00772      tCMP = 324,
00773      tEQ = 325,
00774      tEQQ = 326,
00775      tNEQ = 327,
00776      tGEQ = 328,
00777      tLEQ = 329,
00778      tANDOP = 330,
00779      tOROP = 331,
00780      tMATCH = 332,
00781      tNMATCH = 333,
00782      tDOT2 = 334,
00783      tDOT3 = 335,
00784      tAREF = 336,
00785      tASET = 337,
00786      tLSHFT = 338,
00787      tRSHFT = 339,
00788      tCOLON2 = 340,
00789      tCOLON3 = 341,
00790      tOP_ASGN = 342,
00791      tASSOC = 343,
00792      tLPAREN = 344,
00793      tLPAREN_ARG = 345,
00794      tRPAREN = 346,
00795      tLBRACK = 347,
00796      tLBRACE = 348,
00797      tLBRACE_ARG = 349,
00798      tSTAR = 350,
00799      tAMPER = 351,
00800      tLAMBDA = 352,
00801      tSYMBEG = 353,
00802      tSTRING_BEG = 354,
00803      tXSTRING_BEG = 355,
00804      tREGEXP_BEG = 356,
00805      tWORDS_BEG = 357,
00806      tQWORDS_BEG = 358,
00807      tSTRING_DBEG = 359,
00808      tSTRING_DVAR = 360,
00809      tSTRING_END = 361,
00810      tLAMBEG = 362,
00811      tLOWEST = 363,
00812      tUMINUS_NUM = 364,
00813      idNULL = 365,
00814      idRespond_to = 366,
00815      idIFUNC = 367,
00816      idCFUNC = 368,
00817      id_core_set_method_alias = 369,
00818      id_core_set_variable_alias = 370,
00819      id_core_undef_method = 371,
00820      id_core_define_method = 372,
00821      id_core_define_singleton_method = 373,
00822      id_core_set_postexe = 374,
00823      tLAST_TOKEN = 375
00824    };
00825 #endif
00826 
00827 
00828 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00829 typedef union YYSTYPE
00830 {
00831 /* Line 387 of yacc.c  */
00832 #line 620 "ripper.y"
00833 
00834     VALUE val;
00835     NODE *node;
00836     ID id;
00837     int num;
00838     const struct vtable *vars;
00839 
00840 
00841 /* Line 387 of yacc.c  */
00842 #line 841 "parse.c"
00843 } YYSTYPE;
00844 # define YYSTYPE_IS_TRIVIAL 1
00845 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00846 # define YYSTYPE_IS_DECLARED 1
00847 #endif
00848 
00849 
00850 #ifdef YYPARSE_PARAM
00851 #if defined __STDC__ || defined __cplusplus
00852 int yyparse (void *YYPARSE_PARAM);
00853 #else
00854 int yyparse ();
00855 #endif
00856 #else /* ! YYPARSE_PARAM */
00857 #if defined __STDC__ || defined __cplusplus
00858 int yyparse (struct parser_params *parser);
00859 #else
00860 int yyparse ();
00861 #endif
00862 #endif /* ! YYPARSE_PARAM */
00863 
00864 
00865 
00866 /* Copy the second part of user declarations.  */
00867 
00868 /* Line 390 of yacc.c  */
00869 #line 868 "parse.c"
00870 
00871 #ifdef short
00872 # undef short
00873 #endif
00874 
00875 #ifdef YYTYPE_UINT8
00876 typedef YYTYPE_UINT8 yytype_uint8;
00877 #else
00878 typedef unsigned char yytype_uint8;
00879 #endif
00880 
00881 #ifdef YYTYPE_INT8
00882 typedef YYTYPE_INT8 yytype_int8;
00883 #elif (defined __STDC__ || defined __C99__FUNC__ \
00884      || defined __cplusplus || defined _MSC_VER)
00885 typedef signed char yytype_int8;
00886 #else
00887 typedef short int yytype_int8;
00888 #endif
00889 
00890 #ifdef YYTYPE_UINT16
00891 typedef YYTYPE_UINT16 yytype_uint16;
00892 #else
00893 typedef unsigned short int yytype_uint16;
00894 #endif
00895 
00896 #ifdef YYTYPE_INT16
00897 typedef YYTYPE_INT16 yytype_int16;
00898 #else
00899 typedef short int yytype_int16;
00900 #endif
00901 
00902 #ifndef YYSIZE_T
00903 # ifdef __SIZE_TYPE__
00904 #  define YYSIZE_T __SIZE_TYPE__
00905 # elif defined size_t
00906 #  define YYSIZE_T size_t
00907 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00908      || defined __cplusplus || defined _MSC_VER)
00909 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00910 #  define YYSIZE_T size_t
00911 # else
00912 #  define YYSIZE_T unsigned int
00913 # endif
00914 #endif
00915 
00916 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00917 
00918 #ifndef YY_
00919 # if defined YYENABLE_NLS && YYENABLE_NLS
00920 #  if ENABLE_NLS
00921 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00922 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
00923 #  endif
00924 # endif
00925 # ifndef YY_
00926 #  define YY_(Msgid) Msgid
00927 # endif
00928 #endif
00929 
00930 #ifndef __attribute__
00931 /* This feature is available in gcc versions 2.5 and later.  */
00932 # if (! defined __GNUC__ || __GNUC__ < 2 \
00933       || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
00934 #  define __attribute__(Spec) /* empty */
00935 # endif
00936 #endif
00937 
00938 /* Suppress unused-variable warnings by "using" E.  */
00939 #if ! defined lint || defined __GNUC__
00940 # define YYUSE(E) ((void) (E))
00941 #else
00942 # define YYUSE(E) /* empty */
00943 #endif
00944 
00945 
00946 /* Identity function, used to suppress warnings about constant conditions.  */
00947 #ifndef lint
00948 # define YYID(N) (N)
00949 #else
00950 #if (defined __STDC__ || defined __C99__FUNC__ \
00951      || defined __cplusplus || defined _MSC_VER)
00952 static int
00953 YYID (int yyi)
00954 #else
00955 static int
00956 YYID (yyi)
00957     int yyi;
00958 #endif
00959 {
00960   return yyi;
00961 }
00962 #endif
00963 
00964 #if ! defined yyoverflow || YYERROR_VERBOSE
00965 
00966 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00967 
00968 # ifdef YYSTACK_USE_ALLOCA
00969 #  if YYSTACK_USE_ALLOCA
00970 #   ifdef __GNUC__
00971 #    define YYSTACK_ALLOC __builtin_alloca
00972 #   elif defined __BUILTIN_VA_ARG_INCR
00973 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00974 #   elif defined _AIX
00975 #    define YYSTACK_ALLOC __alloca
00976 #   elif defined _MSC_VER
00977 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00978 #    define alloca _alloca
00979 #   else
00980 #    define YYSTACK_ALLOC alloca
00981 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00982      || defined __cplusplus || defined _MSC_VER)
00983 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00984       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
00985 #     ifndef EXIT_SUCCESS
00986 #      define EXIT_SUCCESS 0
00987 #     endif
00988 #    endif
00989 #   endif
00990 #  endif
00991 # endif
00992 
00993 # ifdef YYSTACK_ALLOC
00994    /* Pacify GCC's `empty if-body' warning.  */
00995 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00996 #  ifndef YYSTACK_ALLOC_MAXIMUM
00997     /* The OS might guarantee only one guard page at the bottom of the stack,
00998        and a page size can be as small as 4096 bytes.  So we cannot safely
00999        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01000        to allow for a few compiler-allocated temporary stack slots.  */
01001 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01002 #  endif
01003 # else
01004 #  define YYSTACK_ALLOC YYMALLOC
01005 #  define YYSTACK_FREE YYFREE
01006 #  ifndef YYSTACK_ALLOC_MAXIMUM
01007 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01008 #  endif
01009 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
01010        && ! ((defined YYMALLOC || defined malloc) \
01011              && (defined YYFREE || defined free)))
01012 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01013 #   ifndef EXIT_SUCCESS
01014 #    define EXIT_SUCCESS 0
01015 #   endif
01016 #  endif
01017 #  ifndef YYMALLOC
01018 #   define YYMALLOC malloc
01019 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01020      || defined __cplusplus || defined _MSC_VER)
01021 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01022 #   endif
01023 #  endif
01024 #  ifndef YYFREE
01025 #   define YYFREE free
01026 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01027      || defined __cplusplus || defined _MSC_VER)
01028 void free (void *); /* INFRINGES ON USER NAME SPACE */
01029 #   endif
01030 #  endif
01031 # endif
01032 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01033 
01034 
01035 #if (! defined yyoverflow \
01036      && (! defined __cplusplus \
01037          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01038 
01039 /* A type that is properly aligned for any stack member.  */
01040 union yyalloc
01041 {
01042   yytype_int16 yyss_alloc;
01043   YYSTYPE yyvs_alloc;
01044 };
01045 
01046 /* The size of the maximum gap between one aligned stack and the next.  */
01047 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01048 
01049 /* The size of an array large to enough to hold all stacks, each with
01050    N elements.  */
01051 # define YYSTACK_BYTES(N) \
01052      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01053       + YYSTACK_GAP_MAXIMUM)
01054 
01055 # define YYCOPY_NEEDED 1
01056 
01057 /* Relocate STACK from its old location to the new one.  The
01058    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01059    elements in the stack, and YYPTR gives the new location of the
01060    stack.  Advance YYPTR to a properly aligned location for the next
01061    stack.  */
01062 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01063     do                                                                  \
01064       {                                                                 \
01065         YYSIZE_T yynewbytes;                                            \
01066         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01067         Stack = &yyptr->Stack_alloc;                                    \
01068         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01069         yyptr += yynewbytes / sizeof (*yyptr);                          \
01070       }                                                                 \
01071     while (YYID (0))
01072 
01073 #endif
01074 
01075 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
01076 /* Copy COUNT objects from SRC to DST.  The source and destination do
01077    not overlap.  */
01078 # ifndef YYCOPY
01079 #  if defined __GNUC__ && 1 < __GNUC__
01080 #   define YYCOPY(Dst, Src, Count) \
01081       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
01082 #  else
01083 #   define YYCOPY(Dst, Src, Count)              \
01084       do                                        \
01085         {                                       \
01086           YYSIZE_T yyi;                         \
01087           for (yyi = 0; yyi < (Count); yyi++)   \
01088             (Dst)[yyi] = (Src)[yyi];            \
01089         }                                       \
01090       while (YYID (0))
01091 #  endif
01092 # endif
01093 #endif /* !YYCOPY_NEEDED */
01094 
01095 /* YYFINAL -- State number of the termination state.  */
01096 #define YYFINAL  3
01097 /* YYLAST -- Last index in YYTABLE.  */
01098 #define YYLAST   10748
01099 
01100 /* YYNTOKENS -- Number of terminals.  */
01101 #define YYNTOKENS  148
01102 /* YYNNTS -- Number of nonterminals.  */
01103 #define YYNNTS  174
01104 /* YYNRULES -- Number of rules.  */
01105 #define YYNRULES  573
01106 /* YYNRULES -- Number of states.  */
01107 #define YYNSTATES  991
01108 
01109 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01110 #define YYUNDEFTOK  2
01111 #define YYMAXUTOK   375
01112 
01113 #define YYTRANSLATE(YYX)                                                \
01114   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01115 
01116 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01117 static const yytype_uint8 yytranslate[] =
01118 {
01119        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01120      147,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01121        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01122        2,     2,   146,   123,     2,     2,     2,   121,   116,     2,
01123      142,   143,   119,   117,   140,   118,   139,   120,     2,     2,
01124        2,     2,     2,     2,     2,     2,     2,     2,   111,   145,
01125      113,   109,   112,   110,     2,     2,     2,     2,     2,     2,
01126        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01127        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01128        2,   138,     2,   144,   115,     2,   141,     2,     2,     2,
01129        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01130        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01131        2,     2,     2,   136,   114,   137,   124,     2,     2,     2,
01132        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01133        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01134        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01135        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01136        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01137        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01138        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01139        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01140        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01141        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01142        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01143        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01144        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01145        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01146       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01147       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01148       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01149       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01150       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01151       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
01152       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
01153       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
01154       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
01155      105,   106,   107,   108,   122,   125,   126,   127,   128,   129,
01156      130,   131,   132,   133,   134,   135
01157 };
01158 
01159 #if YYDEBUG
01160 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01161    YYRHS.  */
01162 static const yytype_uint16 yyprhs[] =
01163 {
01164        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01165       23,    24,    30,    35,    38,    40,    42,    46,    49,    50,
01166       55,    59,    63,    67,    70,    74,    78,    82,    86,    90,
01167       95,    97,   101,   105,   112,   118,   124,   130,   136,   140,
01168      144,   148,   152,   154,   158,   162,   164,   168,   172,   176,
01169      179,   181,   183,   185,   187,   189,   194,   199,   200,   206,
01170      209,   213,   218,   224,   229,   235,   238,   241,   244,   247,
01171      250,   252,   256,   258,   262,   264,   267,   271,   277,   280,
01172      285,   288,   293,   295,   299,   301,   305,   308,   312,   314,
01173      318,   320,   322,   327,   331,   335,   339,   343,   346,   348,
01174      350,   352,   357,   361,   365,   369,   373,   376,   378,   380,
01175      382,   385,   387,   391,   393,   395,   397,   399,   401,   403,
01176      405,   407,   409,   411,   412,   417,   419,   421,   423,   425,
01177      427,   429,   431,   433,   435,   437,   439,   441,   443,   445,
01178      447,   449,   451,   453,   455,   457,   459,   461,   463,   465,
01179      467,   469,   471,   473,   475,   477,   479,   481,   483,   485,
01180      487,   489,   491,   493,   495,   497,   499,   501,   503,   505,
01181      507,   509,   511,   513,   515,   517,   519,   521,   523,   525,
01182      527,   529,   531,   533,   535,   537,   539,   541,   543,   545,
01183      547,   549,   551,   553,   555,   557,   561,   567,   571,   577,
01184      584,   590,   596,   602,   608,   613,   617,   621,   625,   629,
01185      633,   637,   641,   645,   649,   654,   659,   662,   665,   669,
01186      673,   677,   681,   685,   689,   693,   697,   701,   705,   709,
01187      713,   717,   720,   723,   727,   731,   735,   739,   740,   745,
01188      752,   754,   756,   758,   761,   766,   769,   773,   775,   777,
01189      779,   781,   784,   789,   792,   794,   797,   800,   805,   807,
01190      808,   811,   814,   817,   819,   821,   824,   828,   833,   837,
01191      842,   845,   847,   849,   851,   853,   855,   857,   859,   861,
01192      863,   864,   869,   870,   875,   879,   883,   886,   890,   894,
01193      896,   901,   905,   907,   908,   915,   920,   924,   927,   929,
01194      932,   935,   942,   949,   950,   951,   959,   960,   961,   969,
01195      975,   980,   981,   982,   992,   993,  1000,  1001,  1002,  1011,
01196     1012,  1018,  1019,  1026,  1027,  1028,  1038,  1040,  1042,  1044,
01197     1046,  1048,  1050,  1052,  1054,  1056,  1058,  1060,  1062,  1064,
01198     1066,  1068,  1070,  1072,  1074,  1077,  1079,  1081,  1083,  1089,
01199     1091,  1094,  1096,  1098,  1100,  1104,  1106,  1110,  1112,  1117,
01200     1124,  1128,  1134,  1137,  1142,  1144,  1148,  1155,  1164,  1169,
01201     1176,  1181,  1184,  1191,  1194,  1199,  1206,  1209,  1214,  1217,
01202     1222,  1224,  1226,  1228,  1232,  1234,  1239,  1241,  1244,  1246,
01203     1250,  1252,  1254,  1255,  1256,  1261,  1266,  1268,  1272,  1276,
01204     1277,  1283,  1286,  1291,  1296,  1299,  1304,  1309,  1313,  1317,
01205     1321,  1324,  1326,  1331,  1332,  1338,  1339,  1345,  1351,  1353,
01206     1355,  1362,  1364,  1366,  1368,  1370,  1373,  1375,  1378,  1380,
01207     1382,  1384,  1386,  1388,  1390,  1392,  1395,  1399,  1403,  1407,
01208     1411,  1415,  1416,  1420,  1422,  1425,  1429,  1433,  1434,  1438,
01209     1439,  1442,  1443,  1446,  1447,  1450,  1452,  1453,  1457,  1458,
01210     1459,  1465,  1467,  1469,  1471,  1473,  1476,  1478,  1480,  1482,
01211     1484,  1488,  1490,  1492,  1495,  1498,  1500,  1502,  1504,  1506,
01212     1508,  1510,  1512,  1514,  1516,  1518,  1520,  1522,  1524,  1526,
01213     1528,  1530,  1532,  1534,  1536,  1537,  1542,  1545,  1549,  1552,
01214     1559,  1568,  1573,  1580,  1585,  1592,  1595,  1600,  1607,  1610,
01215     1615,  1618,  1623,  1625,  1626,  1628,  1630,  1632,  1634,  1636,
01216     1638,  1640,  1644,  1646,  1650,  1654,  1658,  1660,  1664,  1666,
01217     1670,  1672,  1674,  1677,  1679,  1681,  1683,  1686,  1689,  1691,
01218     1693,  1694,  1699,  1701,  1704,  1706,  1710,  1714,  1717,  1719,
01219     1721,  1723,  1725,  1727,  1729,  1731,  1733,  1735,  1737,  1739,
01220     1741,  1742,  1744,  1745,  1747,  1750,  1753,  1754,  1756,  1758,
01221     1760,  1762,  1764,  1767
01222 };
01223 
01224 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01225 static const yytype_int16 yyrhs[] =
01226 {
01227      149,     0,    -1,    -1,   150,   151,    -1,   152,   314,    -1,
01228      321,    -1,   153,    -1,   152,   320,   153,    -1,     1,   153,
01229       -1,   158,    -1,    -1,    47,   154,   136,   151,   137,    -1,
01230      156,   256,   231,   259,    -1,   157,   314,    -1,   321,    -1,
01231      158,    -1,   157,   320,   158,    -1,     1,   158,    -1,    -1,
01232       45,   180,   159,   180,    -1,    45,    54,    54,    -1,    45,
01233       54,    64,    -1,    45,    54,    63,    -1,     6,   181,    -1,
01234      158,    40,   162,    -1,   158,    41,   162,    -1,   158,    42,
01235      162,    -1,   158,    43,   162,    -1,   158,    44,   158,    -1,
01236       48,   136,   156,   137,    -1,   160,    -1,   168,   109,   163,
01237       -1,   286,    87,   163,    -1,   216,   138,   191,   317,    87,
01238      163,    -1,   216,   139,    52,    87,   163,    -1,   216,   139,
01239       56,    87,   163,    -1,   216,    85,    56,    87,   163,    -1,
01240      216,    85,    52,    87,   163,    -1,   287,    87,   163,    -1,
01241      175,   109,   198,    -1,   168,   109,   187,    -1,   168,   109,
01242      198,    -1,   161,    -1,   175,   109,   163,    -1,   175,   109,
01243      160,    -1,   163,    -1,   161,    37,   161,    -1,   161,    38,
01244      161,    -1,    39,   315,   161,    -1,   123,   163,    -1,   185,
01245       -1,   161,    -1,   167,    -1,   164,    -1,   249,    -1,   249,
01246      139,   311,   193,    -1,   249,    85,   311,   193,    -1,    -1,
01247       94,   166,   237,   156,   137,    -1,   310,   193,    -1,   310,
01248      193,   165,    -1,   216,   139,   311,   193,    -1,   216,   139,
01249      311,   193,   165,    -1,   216,    85,   311,   193,    -1,   216,
01250       85,   311,   193,   165,    -1,    32,   193,    -1,    31,   193,
01251       -1,    30,   192,    -1,    21,   192,    -1,    22,   192,    -1,
01252      170,    -1,    89,   169,   316,    -1,   170,    -1,    89,   169,
01253      316,    -1,   172,    -1,   172,   171,    -1,   172,    95,   174,
01254       -1,   172,    95,   174,   140,   173,    -1,   172,    95,    -1,
01255      172,    95,   140,   173,    -1,    95,   174,    -1,    95,   174,
01256      140,   173,    -1,    95,    -1,    95,   140,   173,    -1,   174,
01257       -1,    89,   169,   316,    -1,   171,   140,    -1,   172,   171,
01258      140,    -1,   171,    -1,   173,   140,   171,    -1,   283,    -1,
01259      284,    -1,   216,   138,   191,   317,    -1,   216,   139,    52,
01260       -1,   216,    85,    52,    -1,   216,   139,    56,    -1,   216,
01261       85,    56,    -1,    86,    56,    -1,   287,    -1,   283,    -1,
01262      284,    -1,   216,   138,   191,   317,    -1,   216,   139,    52,
01263       -1,   216,    85,    52,    -1,   216,   139,    56,    -1,   216,
01264       85,    56,    -1,    86,    56,    -1,   287,    -1,    52,    -1,
01265       56,    -1,    86,   176,    -1,   176,    -1,   216,    85,   176,
01266       -1,    52,    -1,    56,    -1,    53,    -1,   183,    -1,   184,
01267       -1,   178,    -1,   279,    -1,   179,    -1,   281,    -1,   180,
01268       -1,    -1,   181,   140,   182,   180,    -1,   114,    -1,   115,
01269       -1,   116,    -1,    69,    -1,    70,    -1,    71,    -1,    77,
01270       -1,    78,    -1,   112,    -1,    73,    -1,   113,    -1,    74,
01271       -1,    72,    -1,    83,    -1,    84,    -1,   117,    -1,   118,
01272       -1,   119,    -1,    95,    -1,   120,    -1,   121,    -1,    68,
01273       -1,   123,    -1,   124,    -1,    66,    -1,    67,    -1,    81,
01274       -1,    82,    -1,   141,    -1,    49,    -1,    50,    -1,    51,
01275       -1,    47,    -1,    48,    -1,    45,    -1,    37,    -1,     7,
01276       -1,    21,    -1,    16,    -1,     3,    -1,     5,    -1,    46,
01277       -1,    26,    -1,    15,    -1,    14,    -1,    10,    -1,     9,
01278       -1,    36,    -1,    20,    -1,    25,    -1,     4,    -1,    22,
01279       -1,    34,    -1,    39,    -1,    38,    -1,    23,    -1,     8,
01280       -1,    24,    -1,    30,    -1,    33,    -1,    32,    -1,    13,
01281       -1,    35,    -1,     6,    -1,    17,    -1,    31,    -1,    11,
01282       -1,    12,    -1,    18,    -1,    19,    -1,   175,   109,   185,
01283       -1,   175,   109,   185,    44,   185,    -1,   286,    87,   185,
01284       -1,   286,    87,   185,    44,   185,    -1,   216,   138,   191,
01285      317,    87,   185,    -1,   216,   139,    52,    87,   185,    -1,
01286      216,   139,    56,    87,   185,    -1,   216,    85,    52,    87,
01287      185,    -1,   216,    85,    56,    87,   185,    -1,    86,    56,
01288       87,   185,    -1,   287,    87,   185,    -1,   185,    79,   185,
01289       -1,   185,    80,   185,    -1,   185,   117,   185,    -1,   185,
01290      118,   185,    -1,   185,   119,   185,    -1,   185,   120,   185,
01291       -1,   185,   121,   185,    -1,   185,    68,   185,    -1,   122,
01292       59,    68,   185,    -1,   122,    60,    68,   185,    -1,    66,
01293      185,    -1,    67,   185,    -1,   185,   114,   185,    -1,   185,
01294      115,   185,    -1,   185,   116,   185,    -1,   185,    69,   185,
01295       -1,   185,   112,   185,    -1,   185,    73,   185,    -1,   185,
01296      113,   185,    -1,   185,    74,   185,    -1,   185,    70,   185,
01297       -1,   185,    71,   185,    -1,   185,    72,   185,    -1,   185,
01298       77,   185,    -1,   185,    78,   185,    -1,   123,   185,    -1,
01299      124,   185,    -1,   185,    83,   185,    -1,   185,    84,   185,
01300       -1,   185,    75,   185,    -1,   185,    76,   185,    -1,    -1,
01301       46,   315,   186,   185,    -1,   185,   110,   185,   315,   111,
01302      185,    -1,   199,    -1,   185,    -1,   321,    -1,   197,   318,
01303       -1,   197,   140,   308,   318,    -1,   308,   318,    -1,   142,
01304      191,   316,    -1,   321,    -1,   189,    -1,   321,    -1,   192,
01305       -1,   197,   140,    -1,   197,   140,   308,   140,    -1,   308,
01306      140,    -1,   167,    -1,   197,   196,    -1,   308,   196,    -1,
01307      197,   140,   308,   196,    -1,   195,    -1,    -1,   194,   192,
01308       -1,    96,   187,    -1,   140,   195,    -1,   321,    -1,   187,
01309       -1,    95,   187,    -1,   197,   140,   187,    -1,   197,   140,
01310       95,   187,    -1,   197,   140,   187,    -1,   197,   140,    95,
01311      187,    -1,    95,   187,    -1,   260,    -1,   261,    -1,   264,
01312       -1,   265,    -1,   266,    -1,   269,    -1,   285,    -1,   287,
01313       -1,    53,    -1,    -1,   217,   200,   155,   227,    -1,    -1,
01314       90,   161,   201,   316,    -1,    89,   156,   143,    -1,   216,
01315       85,    56,    -1,    86,    56,    -1,    92,   188,   144,    -1,
01316       93,   307,   137,    -1,    30,    -1,    31,   142,   192,   316,
01317       -1,    31,   142,   316,    -1,    31,    -1,    -1,    46,   315,
01318      142,   202,   161,   316,    -1,    39,   142,   161,   316,    -1,
01319       39,   142,   316,    -1,   310,   251,    -1,   250,    -1,   250,
01320      251,    -1,    97,   242,    -1,   218,   162,   228,   156,   230,
01321      227,    -1,   219,   162,   228,   156,   231,   227,    -1,    -1,
01322       -1,   220,   203,   162,   229,   204,   156,   227,    -1,    -1,
01323       -1,   221,   205,   162,   229,   206,   156,   227,    -1,   222,
01324      162,   314,   254,   227,    -1,   222,   314,   254,   227,    -1,
01325       -1,    -1,   223,   232,    25,   207,   162,   229,   208,   156,
01326      227,    -1,    -1,   224,   177,   288,   209,   155,   227,    -1,
01327       -1,    -1,   224,    83,   161,   210,   319,   211,   155,   227,
01328       -1,    -1,   225,   177,   212,   155,   227,    -1,    -1,   226,
01329      178,   213,   290,   155,   227,    -1,    -1,    -1,   226,   305,
01330      313,   214,   178,   215,   290,   155,   227,    -1,    21,    -1,
01331       22,    -1,    23,    -1,    24,    -1,   199,    -1,     7,    -1,
01332       11,    -1,    12,    -1,    18,    -1,    19,    -1,    16,    -1,
01333       20,    -1,     3,    -1,     4,    -1,     5,    -1,    10,    -1,
01334      319,    -1,    13,    -1,   319,    13,    -1,   319,    -1,    27,
01335       -1,   231,    -1,    14,   162,   228,   156,   230,    -1,   321,
01336       -1,    15,   156,    -1,   175,    -1,   168,    -1,   293,    -1,
01337       89,   235,   316,    -1,   233,    -1,   234,   140,   233,    -1,
01338      234,    -1,   234,   140,    95,   293,    -1,   234,   140,    95,
01339      293,   140,   234,    -1,   234,   140,    95,    -1,   234,   140,
01340       95,   140,   234,    -1,    95,   293,    -1,    95,   293,   140,
01341      234,    -1,    95,    -1,    95,   140,   234,    -1,   295,   140,
01342      298,   140,   301,   304,    -1,   295,   140,   298,   140,   301,
01343      140,   295,   304,    -1,   295,   140,   298,   304,    -1,   295,
01344      140,   298,   140,   295,   304,    -1,   295,   140,   301,   304,
01345       -1,   295,   140,    -1,   295,   140,   301,   140,   295,   304,
01346       -1,   295,   304,    -1,   298,   140,   301,   304,    -1,   298,
01347      140,   301,   140,   295,   304,    -1,   298,   304,    -1,   298,
01348      140,   295,   304,    -1,   301,   304,    -1,   301,   140,   295,
01349      304,    -1,   303,    -1,   321,    -1,   238,    -1,   114,   239,
01350      114,    -1,    76,    -1,   114,   236,   239,   114,    -1,   321,
01351       -1,   145,   240,    -1,   241,    -1,   240,   140,   241,    -1,
01352       52,    -1,   292,    -1,    -1,    -1,   243,   244,   245,   246,
01353       -1,   142,   291,   239,   316,    -1,   291,    -1,   107,   156,
01354      137,    -1,    29,   156,    10,    -1,    -1,    28,   248,   237,
01355      156,    10,    -1,   167,   247,    -1,   249,   139,   311,   190,
01356       -1,   249,    85,   311,   190,    -1,   310,   189,    -1,   216,
01357      139,   311,   190,    -1,   216,    85,   311,   189,    -1,   216,
01358       85,   312,    -1,   216,   139,   189,    -1,   216,    85,   189,
01359       -1,    32,   189,    -1,    32,    -1,   216,   138,   191,   317,
01360       -1,    -1,   136,   252,   237,   156,   137,    -1,    -1,    26,
01361      253,   237,   156,    10,    -1,    17,   197,   228,   156,   255,
01362       -1,   231,    -1,   254,    -1,     8,   257,   258,   228,   156,
01363      256,    -1,   321,    -1,   187,    -1,   198,    -1,   321,    -1,
01364       88,   175,    -1,   321,    -1,     9,   156,    -1,   321,    -1,
01365      282,    -1,   279,    -1,   281,    -1,   262,    -1,    62,    -1,
01366      263,    -1,   262,   263,    -1,    99,   271,   106,    -1,   100,
01367      272,   106,    -1,   101,   273,    65,    -1,   102,   146,   106,
01368       -1,   102,   267,   106,    -1,    -1,   267,   268,   146,    -1,
01369      274,    -1,   268,   274,    -1,   103,   146,   106,    -1,   103,
01370      270,   106,    -1,    -1,   270,    61,   146,    -1,    -1,   271,
01371      274,    -1,    -1,   272,   274,    -1,    -1,   273,   274,    -1,
01372       61,    -1,    -1,   105,   275,   278,    -1,    -1,    -1,   104,
01373      276,   277,   156,   137,    -1,    54,    -1,    55,    -1,    57,
01374       -1,   287,    -1,    98,   280,    -1,   178,    -1,    55,    -1,
01375       54,    -1,    57,    -1,    98,   272,   106,    -1,    59,    -1,
01376       60,    -1,   122,    59,    -1,   122,    60,    -1,    52,    -1,
01377       55,    -1,    54,    -1,    56,    -1,    57,    -1,    34,    -1,
01378       33,    -1,    35,    -1,    36,    -1,    50,    -1,    49,    -1,
01379       51,    -1,   283,    -1,   284,    -1,   283,    -1,   284,    -1,
01380       63,    -1,    64,    -1,   319,    -1,    -1,   113,   289,   162,
01381      319,    -1,     1,   319,    -1,   142,   291,   316,    -1,   291,
01382      319,    -1,   295,   140,   299,   140,   301,   304,    -1,   295,
01383      140,   299,   140,   301,   140,   295,   304,    -1,   295,   140,
01384      299,   304,    -1,   295,   140,   299,   140,   295,   304,    -1,
01385      295,   140,   301,   304,    -1,   295,   140,   301,   140,   295,
01386      304,    -1,   295,   304,    -1,   299,   140,   301,   304,    -1,
01387      299,   140,   301,   140,   295,   304,    -1,   299,   304,    -1,
01388      299,   140,   295,   304,    -1,   301,   304,    -1,   301,   140,
01389      295,   304,    -1,   303,    -1,    -1,    56,    -1,    55,    -1,
01390       54,    -1,    57,    -1,   292,    -1,    52,    -1,   293,    -1,
01391       89,   235,   316,    -1,   294,    -1,   295,   140,   294,    -1,
01392       52,   109,   187,    -1,    52,   109,   216,    -1,   297,    -1,
01393      298,   140,   297,    -1,   296,    -1,   299,   140,   296,    -1,
01394      119,    -1,    95,    -1,   300,    52,    -1,   300,    -1,   116,
01395       -1,    96,    -1,   302,    52,    -1,   140,   303,    -1,   321,
01396       -1,   285,    -1,    -1,   142,   306,   161,   316,    -1,   321,
01397       -1,   308,   318,    -1,   309,    -1,   308,   140,   309,    -1,
01398      187,    88,   187,    -1,    58,   187,    -1,    52,    -1,    56,
01399       -1,    53,    -1,    52,    -1,    56,    -1,    53,    -1,   183,
01400       -1,    52,    -1,    53,    -1,   183,    -1,   139,    -1,    85,
01401       -1,    -1,   320,    -1,    -1,   147,    -1,   315,   143,    -1,
01402      315,   144,    -1,    -1,   147,    -1,   140,    -1,   145,    -1,
01403      147,    -1,   319,    -1,   320,   145,    -1,    -1
01404 };
01405 
01406 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01407 static const yytype_uint16 yyrline[] =
01408 {
01409        0,   786,   786,   786,   817,   828,   837,   845,   853,   859,
01410      861,   860,   884,   917,   928,   937,   945,   953,   959,   959,
01411      967,   975,   986,   996,  1004,  1013,  1022,  1035,  1048,  1057,
01412     1069,  1070,  1080,  1109,  1130,  1147,  1164,  1175,  1192,  1202,
01413     1211,  1220,  1229,  1232,  1241,  1253,  1254,  1262,  1270,  1278,
01414     1286,  1289,  1301,  1302,  1305,  1306,  1315,  1327,  1326,  1348,
01415     1357,  1369,  1378,  1390,  1399,  1411,  1420,  1429,  1437,  1445,
01416     1455,  1456,  1466,  1467,  1477,  1485,  1493,  1501,  1510,  1518,
01417     1527,  1535,  1544,  1552,  1563,  1564,  1574,  1582,  1592,  1600,
01418     1610,  1614,  1618,  1626,  1634,  1642,  1650,  1662,  1672,  1684,
01419     1693,  1702,  1710,  1718,  1726,  1734,  1747,  1760,  1771,  1779,
01420     1782,  1790,  1798,  1808,  1809,  1810,  1811,  1816,  1827,  1828,
01421     1831,  1839,  1842,  1850,  1850,  1860,  1861,  1862,  1863,  1864,
01422     1865,  1866,  1867,  1868,  1869,  1870,  1871,  1872,  1873,  1874,
01423     1875,  1876,  1877,  1878,  1879,  1880,  1881,  1882,  1883,  1884,
01424     1885,  1886,  1887,  1888,  1891,  1891,  1891,  1892,  1892,  1893,
01425     1893,  1893,  1894,  1894,  1894,  1894,  1895,  1895,  1895,  1895,
01426     1896,  1896,  1896,  1897,  1897,  1897,  1897,  1898,  1898,  1898,
01427     1898,  1899,  1899,  1899,  1899,  1900,  1900,  1900,  1900,  1901,
01428     1901,  1901,  1901,  1902,  1902,  1905,  1914,  1924,  1953,  1984,
01429     2010,  2027,  2044,  2061,  2072,  2083,  2094,  2108,  2122,  2130,
01430     2138,  2146,  2154,  2162,  2170,  2179,  2188,  2196,  2204,  2212,
01431     2220,  2228,  2236,  2244,  2252,  2260,  2268,  2276,  2284,  2292,
01432     2303,  2311,  2319,  2327,  2335,  2343,  2351,  2359,  2359,  2369,
01433     2379,  2385,  2397,  2398,  2402,  2410,  2420,  2430,  2431,  2434,
01434     2435,  2436,  2440,  2448,  2458,  2467,  2475,  2485,  2494,  2503,
01435     2503,  2515,  2525,  2529,  2535,  2543,  2551,  2565,  2581,  2595,
01436     2610,  2620,  2621,  2622,  2623,  2624,  2625,  2626,  2627,  2628,
01437     2637,  2636,  2661,  2661,  2670,  2678,  2686,  2694,  2707,  2715,
01438     2723,  2731,  2739,  2747,  2747,  2757,  2765,  2773,  2784,  2785,
01439     2796,  2800,  2812,  2824,  2824,  2824,  2835,  2835,  2835,  2846,
01440     2857,  2866,  2868,  2865,  2932,  2931,  2953,  2958,  2952,  2977,
01441     2976,  2998,  2997,  3020,  3021,  3020,  3041,  3049,  3057,  3065,
01442     3075,  3087,  3093,  3099,  3105,  3111,  3117,  3123,  3129,  3135,
01443     3141,  3151,  3157,  3162,  3163,  3170,  3175,  3178,  3179,  3192,
01444     3193,  3203,  3204,  3207,  3215,  3225,  3233,  3243,  3251,  3260,
01445     3269,  3277,  3285,  3294,  3306,  3314,  3324,  3332,  3340,  3348,
01446     3356,  3364,  3373,  3381,  3389,  3397,  3405,  3413,  3421,  3429,
01447     3437,  3447,  3448,  3454,  3463,  3472,  3483,  3484,  3494,  3501,
01448     3510,  3518,  3524,  3527,  3524,  3545,  3553,  3563,  3567,  3574,
01449     3573,  3594,  3610,  3619,  3630,  3639,  3649,  3659,  3667,  3678,
01450     3689,  3697,  3705,  3720,  3719,  3739,  3738,  3759,  3771,  3772,
01451     3775,  3794,  3797,  3805,  3813,  3816,  3820,  3823,  3831,  3834,
01452     3835,  3843,  3846,  3863,  3864,  3865,  3875,  3885,  3912,  3977,
01453     3986,  3997,  4004,  4014,  4022,  4032,  4041,  4052,  4059,  4070,
01454     4077,  4088,  4095,  4106,  4113,  4142,  4144,  4143,  4160,  4166,
01455     4159,  4185,  4193,  4201,  4209,  4212,  4223,  4224,  4225,  4226,
01456     4229,  4259,  4260,  4261,  4269,  4279,  4280,  4281,  4282,  4283,
01457     4286,  4287,  4288,  4289,  4290,  4291,  4292,  4295,  4308,  4318,
01458     4326,  4336,  4337,  4340,  4349,  4348,  4356,  4368,  4378,  4386,
01459     4394,  4402,  4410,  4418,  4426,  4434,  4442,  4450,  4458,  4466,
01460     4474,  4482,  4490,  4499,  4508,  4517,  4526,  4535,  4546,  4547,
01461     4554,  4563,  4582,  4589,  4602,  4614,  4626,  4634,  4650,  4658,
01462     4674,  4675,  4678,  4691,  4702,  4703,  4706,  4723,  4727,  4737,
01463     4747,  4747,  4776,  4777,  4787,  4794,  4804,  4812,  4822,  4823,
01464     4824,  4827,  4828,  4829,  4830,  4833,  4834,  4835,  4838,  4843,
01465     4850,  4851,  4854,  4855,  4858,  4861,  4864,  4865,  4866,  4869,
01466     4870,  4873,  4874,  4878
01467 };
01468 #endif
01469 
01470 #if YYDEBUG || YYERROR_VERBOSE || 0
01471 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01472    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01473 static const char *const yytname[] =
01474 {
01475   "$end", "error", "$undefined", "keyword_class", "keyword_module",
01476   "keyword_def", "keyword_undef", "keyword_begin", "keyword_rescue",
01477   "keyword_ensure", "keyword_end", "keyword_if", "keyword_unless",
01478   "keyword_then", "keyword_elsif", "keyword_else", "keyword_case",
01479   "keyword_when", "keyword_while", "keyword_until", "keyword_for",
01480   "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
01481   "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
01482   "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
01483   "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
01484   "keyword_and", "keyword_or", "keyword_not", "modifier_if",
01485   "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
01486   "keyword_alias", "keyword_defined", "keyword_BEGIN", "keyword_END",
01487   "keyword__LINE__", "keyword__FILE__", "keyword__ENCODING__",
01488   "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", "tCONSTANT", "tCVAR", "tLABEL",
01489   "tINTEGER", "tFLOAT", "tSTRING_CONTENT", "tCHAR", "tNTH_REF",
01490   "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", "tCMP", "tEQ",
01491   "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", "tMATCH", "tNMATCH",
01492   "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", "tRSHFT", "tCOLON2",
01493   "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", "tLPAREN_ARG", "tRPAREN",
01494   "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", "tAMPER", "tLAMBDA",
01495   "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", "tWORDS_BEG",
01496   "tQWORDS_BEG", "tSTRING_DBEG", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
01497   "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
01498   "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "idNULL",
01499   "idRespond_to", "idIFUNC", "idCFUNC", "id_core_set_method_alias",
01500   "id_core_set_variable_alias", "id_core_undef_method",
01501   "id_core_define_method", "id_core_define_singleton_method",
01502   "id_core_set_postexe", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','",
01503   "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
01504   "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt",
01505   "compstmt", "stmts", "stmt", "$@3", "command_asgn", "expr", "expr_value",
01506   "command_call", "block_command", "cmd_brace_block", "@4", "command",
01507   "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
01508   "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
01509   "fitem", "undef_list", "$@5", "op", "reswords", "arg", "$@6",
01510   "arg_value", "aref_args", "paren_args", "opt_paren_args",
01511   "opt_call_args", "call_args", "command_args", "@7", "block_arg",
01512   "opt_block_arg", "args", "mrhs", "primary", "@8", "$@9", "$@10", "$@11",
01513   "$@12", "$@13", "$@14", "$@15", "$@16", "@17", "@18", "@19", "@20",
01514   "@21", "$@22", "$@23", "primary_value", "k_begin", "k_if", "k_unless",
01515   "k_while", "k_until", "k_case", "k_for", "k_class", "k_module", "k_def",
01516   "k_end", "then", "do", "if_tail", "opt_else", "for_var", "f_marg",
01517   "f_marg_list", "f_margs", "block_param", "opt_block_param",
01518   "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@24",
01519   "@25", "f_larglist", "lambda_body", "do_block", "@26", "block_call",
01520   "method_call", "brace_block", "@27", "@28", "case_body", "cases",
01521   "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "strings",
01522   "string", "string1", "xstring", "regexp", "words", "word_list", "word",
01523   "qwords", "qword_list", "string_contents", "xstring_contents",
01524   "regexp_contents", "string_content", "@29", "@30", "@31", "string_dvar",
01525   "symbol", "sym", "dsym", "numeric", "user_variable", "keyword_variable",
01526   "var_ref", "var_lhs", "backref", "superclass", "$@32", "f_arglist",
01527   "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_opt",
01528   "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
01529   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
01530   "singleton", "$@33", "assoc_list", "assocs", "assoc", "operation",
01531   "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
01532   "rparen", "rbracket", "trailer", "term", "terms", "none", YY_NULL
01533 };
01534 #endif
01535 
01536 # ifdef YYPRINT
01537 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01538    token YYLEX-NUM.  */
01539 static const yytype_uint16 yytoknum[] =
01540 {
01541        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01542      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01543      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01544      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01545      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01546      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01547      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
01548      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
01549      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
01550      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
01551      355,   356,   357,   358,   359,   360,   361,   362,   363,    61,
01552       63,    58,    62,    60,   124,    94,    38,    43,    45,    42,
01553       47,    37,   364,    33,   126,   365,   366,   367,   368,   369,
01554      370,   371,   372,   373,   374,   375,   123,   125,    91,    46,
01555       44,    96,    40,    41,    93,    59,    32,    10
01556 };
01557 # endif
01558 
01559 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01560 static const yytype_uint16 yyr1[] =
01561 {
01562        0,   148,   150,   149,   151,   152,   152,   152,   152,   153,
01563      154,   153,   155,   156,   157,   157,   157,   157,   159,   158,
01564      158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
01565      158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
01566      158,   158,   158,   160,   160,   161,   161,   161,   161,   161,
01567      161,   162,   163,   163,   164,   164,   164,   166,   165,   167,
01568      167,   167,   167,   167,   167,   167,   167,   167,   167,   167,
01569      168,   168,   169,   169,   170,   170,   170,   170,   170,   170,
01570      170,   170,   170,   170,   171,   171,   172,   172,   173,   173,
01571      174,   174,   174,   174,   174,   174,   174,   174,   174,   175,
01572      175,   175,   175,   175,   175,   175,   175,   175,   176,   176,
01573      177,   177,   177,   178,   178,   178,   178,   178,   179,   179,
01574      180,   180,   181,   182,   181,   183,   183,   183,   183,   183,
01575      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01576      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01577      183,   183,   183,   183,   184,   184,   184,   184,   184,   184,
01578      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01579      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01580      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01581      184,   184,   184,   184,   184,   185,   185,   185,   185,   185,
01582      185,   185,   185,   185,   185,   185,   185,   185,   185,   185,
01583      185,   185,   185,   185,   185,   185,   185,   185,   185,   185,
01584      185,   185,   185,   185,   185,   185,   185,   185,   185,   185,
01585      185,   185,   185,   185,   185,   185,   185,   186,   185,   185,
01586      185,   187,   188,   188,   188,   188,   189,   190,   190,   191,
01587      191,   191,   191,   191,   192,   192,   192,   192,   192,   194,
01588      193,   195,   196,   196,   197,   197,   197,   197,   198,   198,
01589      198,   199,   199,   199,   199,   199,   199,   199,   199,   199,
01590      200,   199,   201,   199,   199,   199,   199,   199,   199,   199,
01591      199,   199,   199,   202,   199,   199,   199,   199,   199,   199,
01592      199,   199,   199,   203,   204,   199,   205,   206,   199,   199,
01593      199,   207,   208,   199,   209,   199,   210,   211,   199,   212,
01594      199,   213,   199,   214,   215,   199,   199,   199,   199,   199,
01595      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
01596      226,   227,   228,   228,   228,   229,   229,   230,   230,   231,
01597      231,   232,   232,   233,   233,   234,   234,   235,   235,   235,
01598      235,   235,   235,   235,   235,   235,   236,   236,   236,   236,
01599      236,   236,   236,   236,   236,   236,   236,   236,   236,   236,
01600      236,   237,   237,   238,   238,   238,   239,   239,   240,   240,
01601      241,   241,   243,   244,   242,   245,   245,   246,   246,   248,
01602      247,   249,   249,   249,   250,   250,   250,   250,   250,   250,
01603      250,   250,   250,   252,   251,   253,   251,   254,   255,   255,
01604      256,   256,   257,   257,   257,   258,   258,   259,   259,   260,
01605      260,   260,   261,   262,   262,   262,   263,   264,   265,   266,
01606      266,   267,   267,   268,   268,   269,   269,   270,   270,   271,
01607      271,   272,   272,   273,   273,   274,   275,   274,   276,   277,
01608      274,   278,   278,   278,   278,   279,   280,   280,   280,   280,
01609      281,   282,   282,   282,   282,   283,   283,   283,   283,   283,
01610      284,   284,   284,   284,   284,   284,   284,   285,   285,   286,
01611      286,   287,   287,   288,   289,   288,   288,   290,   290,   291,
01612      291,   291,   291,   291,   291,   291,   291,   291,   291,   291,
01613      291,   291,   291,   291,   292,   292,   292,   292,   293,   293,
01614      294,   294,   295,   295,   296,   297,   298,   298,   299,   299,
01615      300,   300,   301,   301,   302,   302,   303,   304,   304,   305,
01616      306,   305,   307,   307,   308,   308,   309,   309,   310,   310,
01617      310,   311,   311,   311,   311,   312,   312,   312,   313,   313,
01618      314,   314,   315,   315,   316,   317,   318,   318,   318,   319,
01619      319,   320,   320,   321
01620 };
01621 
01622 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01623 static const yytype_uint8 yyr2[] =
01624 {
01625        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01626        0,     5,     4,     2,     1,     1,     3,     2,     0,     4,
01627        3,     3,     3,     2,     3,     3,     3,     3,     3,     4,
01628        1,     3,     3,     6,     5,     5,     5,     5,     3,     3,
01629        3,     3,     1,     3,     3,     1,     3,     3,     3,     2,
01630        1,     1,     1,     1,     1,     4,     4,     0,     5,     2,
01631        3,     4,     5,     4,     5,     2,     2,     2,     2,     2,
01632        1,     3,     1,     3,     1,     2,     3,     5,     2,     4,
01633        2,     4,     1,     3,     1,     3,     2,     3,     1,     3,
01634        1,     1,     4,     3,     3,     3,     3,     2,     1,     1,
01635        1,     4,     3,     3,     3,     3,     2,     1,     1,     1,
01636        2,     1,     3,     1,     1,     1,     1,     1,     1,     1,
01637        1,     1,     1,     0,     4,     1,     1,     1,     1,     1,
01638        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01639        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01640        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01641        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01642        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01643        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01644        1,     1,     1,     1,     1,     3,     5,     3,     5,     6,
01645        5,     5,     5,     5,     4,     3,     3,     3,     3,     3,
01646        3,     3,     3,     3,     4,     4,     2,     2,     3,     3,
01647        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
01648        3,     2,     2,     3,     3,     3,     3,     0,     4,     6,
01649        1,     1,     1,     2,     4,     2,     3,     1,     1,     1,
01650        1,     2,     4,     2,     1,     2,     2,     4,     1,     0,
01651        2,     2,     2,     1,     1,     2,     3,     4,     3,     4,
01652        2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01653        0,     4,     0,     4,     3,     3,     2,     3,     3,     1,
01654        4,     3,     1,     0,     6,     4,     3,     2,     1,     2,
01655        2,     6,     6,     0,     0,     7,     0,     0,     7,     5,
01656        4,     0,     0,     9,     0,     6,     0,     0,     8,     0,
01657        5,     0,     6,     0,     0,     9,     1,     1,     1,     1,
01658        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01659        1,     1,     1,     1,     2,     1,     1,     1,     5,     1,
01660        2,     1,     1,     1,     3,     1,     3,     1,     4,     6,
01661        3,     5,     2,     4,     1,     3,     6,     8,     4,     6,
01662        4,     2,     6,     2,     4,     6,     2,     4,     2,     4,
01663        1,     1,     1,     3,     1,     4,     1,     2,     1,     3,
01664        1,     1,     0,     0,     4,     4,     1,     3,     3,     0,
01665        5,     2,     4,     4,     2,     4,     4,     3,     3,     3,
01666        2,     1,     4,     0,     5,     0,     5,     5,     1,     1,
01667        6,     1,     1,     1,     1,     2,     1,     2,     1,     1,
01668        1,     1,     1,     1,     1,     2,     3,     3,     3,     3,
01669        3,     0,     3,     1,     2,     3,     3,     0,     3,     0,
01670        2,     0,     2,     0,     2,     1,     0,     3,     0,     0,
01671        5,     1,     1,     1,     1,     2,     1,     1,     1,     1,
01672        3,     1,     1,     2,     2,     1,     1,     1,     1,     1,
01673        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01674        1,     1,     1,     1,     0,     4,     2,     3,     2,     6,
01675        8,     4,     6,     4,     6,     2,     4,     6,     2,     4,
01676        2,     4,     1,     0,     1,     1,     1,     1,     1,     1,
01677        1,     3,     1,     3,     3,     3,     1,     3,     1,     3,
01678        1,     1,     2,     1,     1,     1,     2,     2,     1,     1,
01679        0,     4,     1,     2,     1,     3,     3,     2,     1,     1,
01680        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01681        0,     1,     0,     1,     2,     2,     0,     1,     1,     1,
01682        1,     1,     2,     0
01683 };
01684 
01685 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
01686    Performed when YYTABLE doesn't specify something else to do.  Zero
01687    means the default is an error.  */
01688 static const yytype_uint16 yydefact[] =
01689 {
01690        2,     0,     0,     1,     0,   338,   339,   340,     0,   331,
01691      332,   333,   336,   334,   335,   337,   326,   327,   328,   329,
01692      289,   259,   259,   481,   480,   482,   483,   562,     0,   562,
01693       10,     0,   485,   484,   486,   475,   550,   477,   476,   478,
01694      479,   471,   472,   433,   491,   492,     0,     0,     0,     0,
01695        0,   573,   573,    82,   392,   451,   449,   451,   453,   441,
01696      447,     0,     0,     0,     3,   560,     6,     9,    30,    42,
01697       45,    53,    52,     0,    70,     0,    74,    84,     0,    50,
01698      240,     0,   280,     0,     0,   303,   306,   560,     0,     0,
01699        0,     0,    54,   298,   271,   272,   432,   434,   273,   274,
01700      275,   276,   430,   431,   429,   487,   488,   277,     0,   278,
01701      259,     5,     8,   164,   175,   165,   188,   161,   181,   171,
01702      170,   191,   192,   186,   169,   168,   163,   189,   193,   194,
01703      173,   162,   176,   180,   182,   174,   167,   183,   190,   185,
01704      184,   177,   187,   172,   160,   179,   178,   159,   166,   157,
01705      158,   154,   155,   156,   113,   115,   114,   149,   150,   146,
01706      128,   129,   130,   137,   134,   136,   131,   132,   151,   152,
01707      138,   139,   143,   133,   135,   125,   126,   127,   140,   141,
01708      142,   144,   145,   147,   148,   153,   118,   120,   122,    23,
01709      116,   117,   119,   121,     0,     0,     0,     0,     0,     0,
01710        0,   254,     0,   241,   264,    68,   258,   573,     0,   487,
01711      488,     0,   278,   573,   544,    69,    67,   562,    66,     0,
01712      573,   410,    65,   562,   563,     0,     0,    18,   237,     0,
01713        0,   326,   327,   289,   292,   411,   216,     0,     0,   217,
01714      286,     0,     0,     0,   560,    15,   562,    72,    14,   282,
01715        0,   566,   566,   242,     0,     0,   566,   542,   562,     0,
01716        0,     0,    80,   330,     0,    90,    91,    98,   300,   393,
01717      468,   467,   469,   466,     0,   465,     0,     0,     0,     0,
01718        0,     0,     0,   473,   474,    49,   231,   232,   569,   570,
01719        4,   571,   561,     0,     0,     0,     0,     0,     0,     0,
01720      399,   401,     0,    86,     0,    78,    75,     0,     0,     0,
01721        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01722        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01723        0,     0,     0,     0,     0,   573,     0,     0,    51,     0,
01724        0,     0,     0,   560,     0,   561,     0,   352,   351,     0,
01725        0,   487,   488,   278,   108,   109,     0,     0,   111,     0,
01726        0,   487,   488,   278,   319,   184,   177,   187,   172,   154,
01727      155,   156,   113,   114,   540,   321,   539,     0,     0,     0,
01728      415,   413,   299,   435,     0,     0,   404,    59,   297,   123,
01729      547,   286,   265,   261,     0,     0,     0,   255,   263,     0,
01730      573,     0,     0,     0,     0,   256,   562,     0,   291,   260,
01731      562,   250,   573,   573,   249,   562,   296,    48,    20,    22,
01732       21,     0,   293,     0,     0,     0,     0,     0,     0,    17,
01733      562,   284,    13,   561,    71,   562,   287,   568,   567,   243,
01734      568,   245,   288,   543,     0,    97,   473,   474,    88,    83,
01735        0,     0,   573,     0,   513,   455,   458,   456,   470,   452,
01736      436,   450,   437,   438,   454,   439,   440,     0,   443,   445,
01737        0,   446,     0,     0,   572,     7,    24,    25,    26,    27,
01738       28,    46,    47,   573,     0,    31,    40,     0,    41,   562,
01739        0,    76,    87,    44,    43,     0,   195,   264,    39,   213,
01740      221,   226,   227,   228,   223,   225,   235,   236,   229,   230,
01741      206,   207,   233,   234,   562,   222,   224,   218,   219,   220,
01742      208,   209,   210,   211,   212,   551,   556,   552,   557,   409,
01743      259,   407,   562,   551,   553,   552,   554,   408,   259,     0,
01744      573,   343,     0,   342,     0,     0,     0,     0,     0,     0,
01745      286,     0,   573,     0,   311,   316,   108,   109,   110,     0,
01746      494,   314,   493,     0,   573,     0,     0,     0,   513,   559,
01747      558,   323,   551,   552,   259,   259,   573,   573,    32,   197,
01748       38,   205,    57,    60,     0,   195,   546,     0,   266,   262,
01749      573,   555,   552,   562,   551,   552,   545,   290,   564,   246,
01750      251,   253,   295,    19,     0,   238,     0,    29,     0,   573,
01751      204,    73,    16,   283,   566,     0,    81,    94,    96,   562,
01752      551,   552,   519,   516,   515,   514,   517,     0,   531,   535,
01753      534,   530,   513,     0,   396,   518,   520,   522,   573,   528,
01754      573,   533,   573,     0,   512,   459,     0,   442,   444,   448,
01755      214,   215,   384,   573,     0,   382,   381,   270,     0,    85,
01756       79,     0,     0,     0,     0,     0,     0,   406,    63,     0,
01757      412,     0,     0,   248,   405,    61,   247,   341,   281,   573,
01758      573,   421,   573,   344,   573,   346,   304,   345,   307,     0,
01759        0,   310,   555,   285,   562,   551,   552,     0,     0,   496,
01760        0,     0,   108,   109,   112,   562,     0,   562,   513,     0,
01761        0,     0,   403,    56,   402,    55,     0,     0,     0,   573,
01762      124,   267,   257,     0,     0,   412,     0,     0,   573,   562,
01763       11,   244,    89,    92,     0,   519,     0,   364,   355,   357,
01764      562,   353,   573,     0,     0,   394,     0,   505,   538,     0,
01765      508,   532,     0,   510,   536,     0,   461,   462,   463,   457,
01766      464,   519,     0,   573,     0,   573,   526,   573,   573,   380,
01767      386,     0,     0,   268,    77,   196,     0,    37,   202,    36,
01768      203,    64,   565,     0,    34,   200,    35,   201,    62,   422,
01769      423,   573,   424,     0,   573,   349,     0,     0,   347,     0,
01770        0,     0,   309,     0,     0,   412,     0,   317,     0,     0,
01771      412,   320,   541,   562,     0,   498,   324,     0,     0,   198,
01772        0,     0,   252,   294,   524,   562,     0,   362,     0,   521,
01773      562,     0,     0,   523,   573,   573,   537,   573,   529,   573,
01774      573,     0,     0,   390,   387,   388,   391,     0,   383,   371,
01775      373,     0,   376,     0,   378,   400,   269,   239,    33,   199,
01776        0,     0,   426,   350,     0,    12,   428,     0,   301,   302,
01777        0,     0,   266,   573,   312,     0,   495,   315,   497,   322,
01778      513,   416,   414,     0,   354,   365,     0,   360,   356,   395,
01779      398,   397,     0,   501,     0,   503,     0,   509,     0,   506,
01780      511,   460,     0,   525,     0,   385,   573,   573,   573,   527,
01781      573,   573,     0,   425,     0,    99,   100,   107,     0,   427,
01782        0,   305,   308,   418,   419,   417,     0,     0,     0,    58,
01783        0,   363,     0,   358,   573,   573,   573,   573,   286,     0,
01784      389,     0,   368,     0,   370,   377,     0,   374,   379,   106,
01785        0,   573,     0,   573,   573,     0,   318,     0,   361,     0,
01786      502,     0,   499,   504,   507,   555,   285,   573,   573,   573,
01787      573,   555,   105,   562,   551,   552,   420,   348,   313,   325,
01788      359,   573,   369,     0,   366,   372,   375,   412,   500,   573,
01789      367
01790 };
01791 
01792 /* YYDEFGOTO[NTERM-NUM].  */
01793 static const yytype_int16 yydefgoto[] =
01794 {
01795       -1,     1,     2,    64,    65,    66,   229,   539,   540,   244,
01796      245,   421,    68,    69,   339,    70,    71,   583,   719,    72,
01797       73,   246,    74,    75,    76,   449,    77,   202,   358,   359,
01798      186,   187,   188,   189,   584,   536,   191,    79,   423,   204,
01799      250,   529,   674,   410,   411,   218,   219,   206,   397,   412,
01800      488,    80,   337,   435,   604,   341,   800,   342,   801,   697,
01801      926,   701,   698,   875,   566,   568,   711,   880,   237,    82,
01802       83,    84,    85,    86,    87,    88,    89,    90,    91,   678,
01803      542,   686,   797,   798,   350,   738,   739,   740,   763,   654,
01804      655,   764,   844,   845,   268,   269,   454,   633,   745,   301,
01805      483,    92,    93,   388,   577,   576,   549,   925,   680,   791,
01806      861,   865,    94,    95,    96,    97,    98,    99,   100,   280,
01807      467,   101,   282,   276,   274,   278,   459,   646,   645,   755,
01808      759,   102,   275,   103,   104,   209,   210,   107,   211,   212,
01809      561,   700,   709,   710,   635,   636,   637,   638,   639,   766,
01810      767,   640,   641,   642,   643,   836,   747,   377,   567,   255,
01811      413,   214,   238,   608,   531,   571,   290,   407,   408,   670,
01812      439,   543,   345,   248
01813 };
01814 
01815 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01816    STATE-NUM.  */
01817 #define YYPACT_NINF -747
01818 static const yytype_int16 yypact[] =
01819 {
01820     -747,    81,  2552,  -747,  7102,  -747,  -747,  -747,  6615,  -747,
01821     -747,  -747,  -747,  -747,  -747,  -747,  7320,  7320,  -747,  -747,
01822     7320,  3237,  2814,  -747,  -747,  -747,  -747,   100,  6476,   -31,
01823     -747,   -26,  -747,  -747,  -747,  5715,  2955,  -747,  -747,  5842,
01824     -747,  -747,  -747,  -747,  -747,  -747,  8519,  8519,    83,  4434,
01825     8628,  7538,  7865,  6878,  -747,  6337,  -747,  -747,  -747,   -24,
01826       29,   252,  8737,  8519,  -747,   193,  -747,  1104,  -747,   458,
01827     -747,  -747,   129,    77,  -747,    69,  8846,  -747,   139,  2797,
01828       22,    41,  -747,  8628,  8628,  -747,  -747,  5078,  8951,  9056,
01829     9161,  5588,    33,    46,  -747,  -747,   157,  -747,  -747,  -747,
01830     -747,  -747,  -747,  -747,  -747,    25,    58,  -747,   179,   613,
01831       51,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01832     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01833     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01834     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01835     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01836     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01837     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01838     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,   134,
01839     -747,  -747,  -747,  -747,   182,  8519,   279,  4564,  8519,  8519,
01840     8519,  -747,   263,  2797,   260,  -747,  -747,   237,   207,    43,
01841      206,   298,   254,   265,  -747,  -747,  -747,  4969,  -747,  7320,
01842     7320,  -747,  -747,  5208,  -747,  8628,   661,  -747,   272,   287,
01843     4694,  -747,  -747,  -747,   295,   307,  -747,   304,    51,   416,
01844      619,  7211,  4434,   384,   193,  1104,   -31,   399,  -747,   458,
01845      419,   221,   300,  -747,   260,   430,   300,  -747,   -31,   497,
01846      501,  9266,   442,  -747,   351,   366,   383,   409,  -747,  -747,
01847     -747,  -747,  -747,  -747,   644,  -747,   754,   813,   605,   464,
01848      819,   478,    68,   530,   532,  -747,  -747,  -747,  -747,  -747,
01849     -747,  -747,  5317,  8628,  8628,  8628,  8628,  7211,  8628,  8628,
01850     -747,  -747,  7974,  -747,  4434,  6990,   470,  7974,  8519,  8519,
01851     8519,  8519,  8519,  8519,  8519,  8519,  8519,  8519,  8519,  8519,
01852     8519,  8519,  8519,  8519,  8519,  8519,  8519,  8519,  8519,  8519,
01853     8519,  8519,  8519,  8519,  9548,  7320,  9625,  3609,   458,    86,
01854       86,  8628,  8628,   193,   597,   480,   562,  -747,  -747,   454,
01855      601,    54,    76,    99,   331,   349,  8628,   481,  -747,    45,
01856      473,  -747,  -747,  -747,  -747,   217,   286,   305,   318,   321,
01857      347,   363,   376,   381,  -747,  -747,  -747,   391, 10549, 10549,
01858     -747,  -747,  -747,  -747,  8737,  8737,  -747,   535,  -747,  -747,
01859     -747,   388,  -747,  -747,  8519,  8519,  7429,  -747,  -747,  9702,
01860     7320,  9779,  8519,  8519,  7647,  -747,   -31,   492,  -747,  -747,
01861      -31,  -747,   506,   539,  -747,   106,  -747,  -747,  -747,  -747,
01862     -747,  6615,  -747,  8519,  4029,   508,  9702,  9779,  8519,  1104,
01863      -31,  -747,  -747,  5445,   541,   -31,  -747,  7756,  -747,  -747,
01864     7865,  -747,  -747,  -747,   272,   510,  -747,  -747,  -747,   543,
01865     9266,  9856,  7320,  9933,   774,  -747,  -747,  -747,  -747,  -747,
01866     -747,  -747,  -747,  -747,  -747,  -747,  -747,   313,  -747,  -747,
01867      491,  -747,  8519,  8519,  -747,  -747,  -747,  -747,  -747,  -747,
01868     -747,  -747,  -747,    32,  8519,  -747,   545,   546,  -747,   -31,
01869     9266,   551,  -747,  -747,  -747,   566,  9473,  -747,  -747,   416,
01870     2184,  2184,  2184,  2184,   781,   781,  2273,  2938,  2184,  2184,
01871     1364,  1364,   662,   662,  2656,   781,   781,   927,   927,   768,
01872      397,   397,   416,   416,   416,  3378,  6083,  3464,  6197,  -747,
01873      307,  -747,   -31,   647,  -747,   660,  -747,  -747,  3096,   650,
01874      688,  -747,  3754,   685,  4174,    56,    56,   597,  8083,   650,
01875      112, 10010,  7320, 10087,  -747,   458,  -747,   510,  -747,   193,
01876     -747,  -747,  -747, 10164,  7320, 10241,  3609,  8628,  1131,  -747,
01877     -747,  -747,  -747,  -747,  1739,  1739,    32,    32,  -747, 10608,
01878     -747,  2797,  -747,  -747,  6615, 10627,  -747,  8519,   260,  -747,
01879      265,  5969,  2673,   -31,   490,   500,  -747,  -747,  -747,  -747,
01880     7429,  7647,  -747,  -747,  8628,  2797,   570,  -747,   307,   307,
01881     2797,   213,  1104,  -747,   300,  9266,   543,   505,   282,   -31,
01882       38,   261,   603,  -747,  -747,  -747,  -747,   972,  -747,  -747,
01883     -747,  -747,  1223,    66,  -747,  -747,  -747,  -747,   580,  -747,
01884      583,   683,   589,   687,  -747,  -747,   893,  -747,  -747,  -747,
01885      416,   416,  -747,   576,  4839,  -747,  -747,   604,  8192,  -747,
01886      543,  9266,  8737,  8519,   630,  8737,  8737,  -747,   535,   608,
01887      677,  8737,  8737,  -747,  -747,   535,  -747,  -747,  -747,  8301,
01888      740,  -747,   588,  -747,   740,  -747,  -747,  -747,  -747,   650,
01889       44,  -747,   239,   257,   -31,   141,   145,  8628,   193,  -747,
01890     8628,  3609,   505,   282,  -747,   -31,   650,   106,  1223,  3609,
01891      193,  6754,  -747,  -747,  -747,  -747,  4839,  4694,  8519,    32,
01892     -747,  -747,  -747,  8519,  8519,   507,  8519,  8519,   636,   106,
01893     -747,  -747,  -747,   291,  8519,  -747,   972,   457,  -747,   651,
01894      -31,  -747,   639,  4839,  4694,  -747,  1223,  -747,  -747,  1223,
01895     -747,  -747,   598,  -747,  -747,  4694,  -747,  -747,  -747,  -747,
01896     -747,   681,  1017,   639,   679,   654,  -747,   656,   657,  -747,
01897     -747,   789,  8519,   664,   543,  2797,  8519,  -747,  2797,  -747,
01898     2797,  -747,  -747,  8737,  -747,  2797,  -747,  2797,  -747,   545,
01899     -747,   713,  -747,  4304,   796,  -747,  8628,   650,  -747,   650,
01900     4839,  4839,  -747,  8410,  3899,   189,    56,  -747,   193,   650,
01901     -747,  -747,  -747,   -31,   650,  -747,  -747,   799,   673,  2797,
01902     4694,  8519,  7647,  -747,  -747,   -31,   884,   671,  1079,  -747,
01903      -31,   803,   686,  -747,   676,   678,  -747,   684,  -747,   694,
01904      684,   690,  9371,  -747,   699,  -747,  -747,   711,  -747,  1251,
01905     -747,  1251,  -747,   598,  -747,  -747,   700,  2797,  -747,  2797,
01906     9476,    86,  -747,  -747,  4839,  -747,  -747,    86,  -747,  -747,
01907      650,   650,  -747,   365,  -747,  3609,  -747,  -747,  -747,  -747,
01908     1131,  -747,  -747,   706,  -747,   707,   884,   716,  -747,  -747,
01909     -747,  -747,  1223,  -747,   598,  -747,   598,  -747,   598,  -747,
01910     -747,  -747,   790,   520,  1017,  -747,   708,   715,   684,  -747,
01911      717,   684,   797,  -747,   523,   366,   383,   409,  3609,  -747,
01912     3754,  -747,  -747,  -747,  -747,  -747,  4839,   650,  3609,  -747,
01913      884,   707,   884,   721,   684,   727,   684,   684,  -747, 10318,
01914     -747,  1251,  -747,   598,  -747,  -747,   598,  -747,  -747,   510,
01915    10395,  7320, 10472,   688,   588,   650,  -747,   650,   707,   884,
01916     -747,   598,  -747,  -747,  -747,   730,   731,   684,   735,   684,
01917      684,    55,   282,   -31,   128,   158,  -747,  -747,  -747,  -747,
01918      707,   684,  -747,   598,  -747,  -747,  -747,   163,  -747,   684,
01919     -747
01920 };
01921 
01922 /* YYPGOTO[NTERM-NUM].  */
01923 static const yytype_int16 yypgoto[] =
01924 {
01925     -747,  -747,  -747,   452,  -747,    28,  -747,  -545,   277,  -747,
01926       39,  -747,  -293,   184,   -58,    71,  -747,  -169,  -747,    -7,
01927      791,  -142,   -13,   -37,  -747,  -396,   -29,  1623,  -312,   788,
01928      -54,  -747,   -25,  -747,  -747,    20,  -747,  1066,  -747,   -45,
01929     -747,    11,    47,  -324,   115,     5,  -747,  -322,  -196,    53,
01930     -295,     8,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,
01931     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,     2,  -747,
01932     -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,  -747,   205,
01933     -338,  -516,   -72,  -618,  -747,  -722,  -671,   147,  -747,  -489,
01934     -747,  -600,  -747,   -12,  -747,  -747,  -747,  -747,  -747,  -747,
01935     -747,  -747,  -747,   798,  -747,  -747,  -531,  -747,   -50,  -747,
01936     -747,  -747,  -747,  -747,  -747,   811,  -747,  -747,  -747,  -747,
01937     -747,  -747,  -747,  -747,   856,  -747,  -140,  -747,  -747,  -747,
01938     -747,     7,  -747,    12,  -747,  1268,  1605,   823,  1289,  1575,
01939     -747,  -747,    35,  -387,  -697,  -568,  -690,   273,  -696,  -746,
01940       72,   181,  -747,  -526,  -747,  -449,   270,  -747,  -747,  -747,
01941       97,  -360,   758,  -276,  -747,  -747,   -56,    -4,   278,  -585,
01942     -214,     6,   -18,    -2
01943 };
01944 
01945 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
01946    positive, shift that token.  If negative, reduce the rule which
01947    number is the opposite.  If YYTABLE_NINF, syntax error.  */
01948 #define YYTABLE_NINF -574
01949 static const yytype_int16 yytable[] =
01950 {
01951      111,   273,   544,   227,    81,   644,    81,   254,   725,   201,
01952      201,   532,   498,   201,   493,   192,   689,   405,   208,   208,
01953      193,   706,   208,   225,   262,   228,   340,   222,   190,   343,
01954      688,   344,   112,   221,   733,   192,   247,   375,   441,   306,
01955      193,    67,   443,    67,   596,   558,   559,   292,   190,   253,
01956      257,    81,   208,   838,   616,   264,   833,   541,   530,   741,
01957      538,   263,   794,   -93,   208,   846,   799,   634,  -103,   207,
01958      207,   291,   380,   207,   589,   190,   593,   380,   264,   -99,
01959      596,     3,   589,   685,   263,   208,   208,   716,   717,   208,
01960      349,   360,   360,   291,   660,   743,   263,   263,   263,   541,
01961      430,  -100,   574,   575,   251,   909,   888,  -330,   652,   805,
01962      230,   190,  -489,   213,   213,   387,   224,   213,   378,   644,
01963      810,   386,   279,   530,  -107,   538,   334,   768,   619,   470,
01964     -489,   205,   215,   285,   -99,   216,   461,  -106,   464,   240,
01965      468,  -102,   830,   298,   299,  -490,   653,   -93,   252,   256,
01966      390,   609,   -99,   392,   393,   885,   809,   300,   560,   833,
01967     -330,  -330,   489,   847,   814,   -90,  -102,  -100,   741,   827,
01968     -104,  -104,   379,   744,   471,   281,  -101,   609,   -93,   335,
01969      336,   -93,   381,   644,   803,   -93,   302,   381,   432,   288,
01970      288,   289,   289,   220,   -90,   909,   838,  -551,   -91,    81,
01971     -103,   288,  -103,   289,   769,   398,   833,   846,   888,   303,
01972      201,   398,   201,   201,  -101,   931,   -91,   405,   414,   208,
01973      835,   208,   208,   839,   448,   208,   433,   208,   694,   247,
01974      820,   288,    81,   289,   249,   476,   477,   478,   479,   -98,
01975      705,   596,   223,    81,    81,   742,   221,   224,   307,   386,
01976      291,   704,   -97,   224,   444,   923,    56,   486,   741,   644,
01977      741,   958,   497,   264,  -103,   774,   384,   338,   338,   263,
01978      207,   338,   207,  -102,   389,  -102,   491,   609,   589,   589,
01979      429,   -93,  -105,   545,   546,   -95,   -95,   547,   980,   609,
01980      874,   247,   399,  -490,    81,   208,   208,   208,   208,    81,
01981      208,   208,  -481,  -104,   208,  -104,    81,   264,  -101,   208,
01982     -101,   283,   284,   263,   213,  -100,   213,  -412,   741,   933,
01983      475,   813,   -71,   907,   223,   910,   243,   648,   201,   -92,
01984      927,    67,   406,   414,   409,   391,   480,   208,   288,    81,
01985      289,   403,   924,   208,   208,   400,   401,   537,   395,   291,
01986      586,   588,   804,   -85,   528,   487,  -481,  -548,   208,   254,
01987      487,   437,   741,  -107,   741,   562,   935,  -285,   438,   493,
01988      -95,  -480,   394,   485,   455,  -549,  -412,   396,   494,   -94,
01989      793,  -551,   548,   957,   790,   402,   208,   208,   987,   426,
01990     -482,   741,   588,   201,   722,   254,   603,   -96,   414,  -552,
01991      731,   -95,   208,  -483,   -95,   404,  -485,   415,   -95,   417,
01992      398,   398,   537,   448,   422,   968,  -475,   456,   457,   528,
01993     -285,  -285,   111,   424,  -552,  -480,    81,  -412,   192,  -412,
01994     -412,   644,  -484,   193,  -478,    81,   451,   217,   537,   657,
01995      440,   190,   400,   427,  -482,   201,   528,   438,  -486,   220,
01996      414,  -487,   264,   448,   208,   578,   580,  -483,   263,   647,
01997     -485,  -475,   596,    67,   537,   308,  -478,  -548,  -488,  -475,
01998     -475,   528,   612,  -548,   243,   428,   569,   338,   338,   338,
01999      338,   656,   481,   482,   308,  -549,  -484,  -478,  -478,   452,
02000      453,  -549,   264,   590,  -278,   298,   299,  -106,   263,   781,
02001      589,   416,  -486,   497,  -487,  -487,   788,   425,   -70,   735,
02002      664,   623,   624,   625,   626,  -475,   331,   332,   333,   243,
02003     -478,  -488,  -488,   918,   434,   338,   338,   431,   669,   920,
02004      570,  -555,   722,   556,   614,   668,   676,   557,   681,   551,
02005      555,   667,   721,   675,    81,   201,    81,  -278,  -278,   673,
02006      414,   687,   687,   445,   208,   588,   254,   201,   563,   720,
02007      446,   447,   414,   436,   537,   699,   208,   442,    81,   208,
02008      465,   528,   676,   676,   656,   656,   537,   726,   732,   713,
02009      715,   243,   450,   528,   469,   673,   673,   727,   398,   669,
02010     -555,   192,   552,   553,   821,  -286,   193,   826,   472,  -102,
02011      473,   690,   796,   793,   190,   939,   208,   676,   950,  -104,
02012      492,   564,   565,   773,   548,   669,  -101,   264,   550,   667,
02013      673,   712,   714,   263,   448,   474,   554,   973,   761,   582,
02014      623,   624,   625,   626,   789,   598,   748,   649,   748,   806,
02015      748,  -555,   808,  -555,  -555,   607,   600,  -551,  -286,  -286,
02016      735,   770,   623,   624,   625,   626,    81,   816,   564,   565,
02017      677,   951,   952,   264,   208,   627,   455,   208,   208,   263,
02018      463,   628,   629,   208,   208,   662,   609,   792,   795,   601,
02019      795,   -85,   795,   615,   597,  -264,   658,   627,   599,   824,
02020      669,   661,   630,   602,   629,   631,   679,   728,   683,   208,
02021      385,   669,   208,    81,   807,   455,   428,   730,   611,   456,
02022      457,    81,   734,   613,   630,   418,   815,   656,    81,    81,
02023      746,   762,  -107,   749,   419,   420,   398,   856,  -106,   752,
02024      308,   190,   487,   494,   671,   751,   777,   779,   867,   754,
02025      770,   776,   784,   786,  -265,    81,    81,   672,   456,   457,
02026      458,   707,   782,   -98,   691,   793,  -102,    81,   872,   -97,
02027      110,   770,   110,   748,   783,   748,   748,   659,   735,  -104,
02028      623,   624,   625,   626,   110,   110,   822,   254,   110,   329,
02029      330,   331,   332,   333,   762,   208,  -101,   -93,   729,   862,
02030      842,   828,   866,   848,   849,    81,   851,   853,   208,   855,
02031      -95,   860,    81,    81,  -266,   864,    81,   110,   110,   881,
02032      882,   886,   687,   890,   876,   455,   892,   -92,   894,   682,
02033      110,   684,    81,   891,   896,   905,   622,   901,   623,   624,
02034      625,   626,   748,   748,   898,   748,   308,   748,   748,   904,
02035     -267,   110,   110,   929,   903,   110,   938,   930,   941,   308,
02036      263,   321,   322,   949,   858,   943,   932,   946,   456,   457,
02037      460,   959,   914,   627,   321,   322,    81,   961,   263,   628,
02038      629,   795,  -551,  -552,   455,   983,   606,    81,   364,   347,
02039      455,   338,   977,   825,   338,   329,   330,   331,   332,   333,
02040      630,   382,   940,   631,   802,   326,   327,   328,   329,   330,
02041      331,   332,   333,   976,   748,   748,   748,   383,   748,   748,
02042      750,   811,   753,   277,   376,   928,   632,   456,   457,   462,
02043       81,   906,    81,   456,   457,   466,   765,   834,    81,     0,
02044       81,   771,   748,   748,   748,   748,   735,     0,   623,   624,
02045      625,   626,     0,     0,   201,     0,     0,   756,   757,   414,
02046      758,   681,   795,   208,     0,   110,    44,    45,     0,   528,
02047        0,     0,     0,   537,     0,   748,   748,   748,   748,   669,
02048      528,     0,     0,   736,     0,   110,     0,   110,   110,   748,
02049      338,   110,     0,   110,     0,   812,     0,   748,   110,     0,
02050        0,     0,     0,   817,   818,   308,     0,     0,     0,   110,
02051      110,     0,   868,     0,   869,     0,     0,   823,     0,     0,
02052      321,   322,     0,     0,   877,     0,     0,     0,   829,   879,
02053      831,   832,   837,     0,   735,   840,   623,   624,   625,   626,
02054        0,     0,   841,     0,     0,   850,     0,   852,   854,     0,
02055        0,     0,     0,   328,   329,   330,   331,   332,   333,     0,
02056      110,   110,   110,   110,   110,   110,   110,   110,     0,     0,
02057      110,   736,   110,     0,     0,   110,     0,   737,     0,   843,
02058      863,   623,   624,   625,   626,   921,   922,   870,   871,     0,
02059        0,   873,   203,   203,     0,     0,   203,     0,     0,     0,
02060        0,   878,     0,   110,     0,   110,     0,   883,     0,   110,
02061      110,     0,     0,   884,   893,   895,     0,   897,   889,   899,
02062      900,     0,   236,   239,   110,     0,     0,   203,   203,     0,
02063        0,     0,     0,     0,   908,     0,   911,     0,   286,   287,
02064        0,   735,   956,   623,   624,   625,   626,     0,     0,     0,
02065        0,   919,   110,   110,   293,   294,   295,   296,   297,     0,
02066        0,     0,     0,     0,     0,     0,     0,     0,   110,     0,
02067      978,     0,   979,     0,     0,   934,     0,   936,   736,     0,
02068        0,   937,     0,     0,   887,     0,   942,   944,   945,     0,
02069      947,   948,   110,   622,     0,   623,   624,   625,   626,     0,
02070        0,   110,     0,     0,     0,   953,     0,   954,     0,     0,
02071        0,     0,     0,   955,   960,   962,   963,   964,     0,     0,
02072      110,     0,     0,     0,   967,     0,   969,     0,     0,   970,
02073      627,     0,     0,     0,     0,     0,   628,   629,     0,     0,
02074        0,     0,     0,     0,   981,     0,     0,   982,   984,   985,
02075      986,     0,     0,     0,     0,     0,     0,   630,     0,     0,
02076      631,   988,     0,     0,     0,     0,   989,     0,     0,   990,
02077        0,   203,     0,     0,   203,   203,   286,     0,     0,     0,
02078      105,     0,   105,   708,     0,   622,     0,   623,   624,   625,
02079      626,     0,     0,   203,     0,   203,   203,     0,     0,     0,
02080        0,   108,     0,   108,     0,     0,     0,     0,     0,     0,
02081      110,     0,   110,   761,     0,   623,   624,   625,   626,     0,
02082      110,     0,   627,     0,     0,     0,     0,   105,   628,   629,
02083        0,   265,   110,     0,   110,   110,     0,     0,     0,     0,
02084        0,     0,     0,     0,     0,     0,     0,     0,   108,   630,
02085      627,     0,   631,     0,   265,     0,   628,   629,     0,     0,
02086        0,     0,     0,     0,     0,     0,   351,   361,   361,   361,
02087        0,     0,   110,     0,     0,     0,     0,   630,   203,     0,
02088      631,     0,     0,   496,   499,   500,   501,   502,   503,   504,
02089      505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
02090      515,   516,   517,   518,   519,   520,   521,   522,   523,   524,
02091        0,   203,     0,     0,     0,     0,     0,     0,     0,     0,
02092        0,     0,   110,     0,     0,     0,     0,     0,     0,     0,
02093      110,     0,     0,   110,   110,     0,     0,     0,     0,   110,
02094      110,     0,   308,   309,   310,   311,   312,   313,   314,   315,
02095      316,   317,   318,  -574,  -574,     0,     0,   321,   322,     0,
02096      579,   581,     0,     0,     0,   110,     0,     0,   110,   110,
02097      585,   203,   203,     0,     0,   105,   203,   110,   579,   581,
02098      203,     0,     0,     0,   110,   110,   324,   325,   326,   327,
02099      328,   329,   330,   331,   332,   333,   108,     0,     0,   605,
02100        0,     0,     0,     0,   610,     0,     0,     0,   105,     0,
02101        0,   110,   110,   203,     0,     0,   203,     0,     0,   105,
02102      105,     0,     0,   110,     0,     0,     0,     0,   203,   108,
02103        0,     0,     0,     0,     0,     0,     0,     0,     0,   265,
02104      108,   108,     0,     0,     0,     0,     0,     0,   650,   651,
02105        0,   110,     0,     0,     0,     0,     0,     0,     0,     0,
02106      203,   110,     0,     0,   110,     0,     0,     0,   110,   110,
02107      105,     0,   110,     0,     0,   105,     0,     0,     0,     0,
02108        0,     0,   105,   265,     0,     0,     0,   109,   110,   109,
02109        0,   108,     0,     0,     0,     0,   108,     0,     0,     0,
02110        0,     0,     0,   108,     0,     0,     0,     0,     0,     0,
02111        0,     0,     0,     0,     0,   105,     0,   106,     0,   106,
02112        0,     0,     0,     0,   203,     0,     0,     0,   203,     0,
02113        0,     0,   110,     0,   109,    78,   108,    78,   267,     0,
02114      203,     0,     0,   110,     0,     0,     0,     0,     0,     0,
02115        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02116        0,   267,     0,   203,   106,     0,     0,     0,   266,     0,
02117        0,     0,     0,   353,   363,   363,   203,   203,     0,     0,
02118        0,     0,    78,     0,     0,     0,   110,     0,   110,     0,
02119        0,   266,     0,     0,   110,     0,   110,     0,     0,     0,
02120        0,     0,   105,   352,   362,   362,   362,     0,     0,     0,
02121        0,   105,     0,     0,     0,     0,     0,     0,     0,   110,
02122        0,   348,     0,   108,     0,     0,     0,     0,   265,     0,
02123        0,     0,   108,     0,   203,     0,     0,     0,   585,   775,
02124        0,   778,   780,     0,     0,     0,     0,   785,   787,  -573,
02125        0,     0,     0,     0,     0,   203,     0,  -573,  -573,  -573,
02126        0,     0,  -573,  -573,  -573,     0,  -573,     0,   265,     0,
02127        0,     0,     0,     0,     0,     0,  -573,     0,     0,     0,
02128        0,     0,   109,     0,     0,     0,  -573,  -573,     0,  -573,
02129     -573,  -573,  -573,  -573,   819,     0,     0,     0,     0,   778,
02130      780,     0,   785,   787,     0,     0,     0,     0,     0,     0,
02131      203,     0,   106,     0,     0,   109,     0,     0,     0,     0,
02132      105,     0,   105,     0,     0,     0,   109,   109,     0,     0,
02133       78,     0,     0,     0,  -573,     0,     0,     0,     0,     0,
02134        0,   108,     0,   108,   105,   106,   267,     0,   203,     0,
02135        0,     0,   857,     0,     0,     0,   106,   106,     0,   859,
02136        0,     0,     0,    78,     0,   108,     0,     0,     0,     0,
02137        0,     0,     0,     0,    78,    78,   266,   109,     0,   203,
02138        0,     0,   109,     0,     0,     0,  -573,     0,  -573,   109,
02139      267,   220,  -573,   265,  -573,     0,  -573,   859,   203,     0,
02140        0,     0,     0,     0,     0,     0,     0,   106,     0,     0,
02141        0,     0,   106,     0,     0,     0,     0,     0,     0,   106,
02142      266,     0,   109,     0,     0,    78,     0,     0,     0,     0,
02143       78,     0,   105,     0,     0,     0,     0,    78,     0,   265,
02144      495,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02145        0,     0,   106,   108,     0,     0,     0,     0,     0,     0,
02146        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02147       78,     0,     0,     0,     0,     0,     0,     0,     0,   105,
02148        0,     0,     0,     0,     0,     0,     0,   105,     0,     0,
02149        0,     0,     0,     0,   105,   105,     0,     0,     0,     0,
02150      108,     0,     0,     0,     0,     0,     0,     0,   108,   109,
02151        0,     0,     0,     0,     0,   108,   108,     0,   109,     0,
02152        0,   105,   105,     0,     0,     0,     0,   203,     0,     0,
02153        0,     0,     0,   105,     0,   267,     0,     0,     0,   106,
02154        0,     0,   108,   108,     0,     0,     0,     0,   106,     0,
02155        0,     0,     0,     0,   108,     0,     0,    78,     0,     0,
02156        0,     0,     0,     0,     0,   266,    78,     0,     0,     0,
02157        0,   105,     0,     0,     0,   267,     0,     0,   105,   105,
02158        0,     0,   105,     0,     0,     0,     0,     0,     0,     0,
02159        0,     0,   108,     0,     0,     0,     0,     0,   105,   108,
02160      108,     0,     0,   108,     0,   266,     0,     0,     0,     0,
02161        0,     0,     0,     0,     0,     0,     0,     0,     0,   108,
02162      361,     0,     0,     0,     0,     0,     0,   109,     0,   109,
02163        0,     0,     0,     0,     0,     0,     0,     0,   915,     0,
02164        0,     0,   105,     0,     0,     0,     0,     0,     0,     0,
02165        0,   109,     0,   105,     0,     0,     0,   106,     0,   106,
02166        0,     0,     0,   108,     0,     0,     0,     0,     0,     0,
02167        0,     0,     0,     0,   108,    78,     0,    78,     0,     0,
02168        0,   106,     0,     0,     0,     0,     0,     0,     0,     0,
02169        0,     0,     0,     0,     0,     0,   105,     0,   105,    78,
02170      267,     0,     0,     0,   105,     0,   105,     0,     0,     0,
02171        0,     0,     0,     0,     0,     0,     0,   108,     0,   108,
02172        0,     0,     0,     0,     0,   108,     0,   108,     0,     0,
02173      266,   760,     0,     0,     0,     0,     0,     0,     0,   109,
02174        0,     0,     0,     0,     0,     0,   267,     0,     0,     0,
02175        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02176        0,     0,   308,  -574,  -574,  -574,  -574,   313,   314,   106,
02177        0,  -574,  -574,     0,     0,     0,   266,   321,   322,     0,
02178        0,     0,     0,     0,     0,     0,   109,    78,     0,     0,
02179        0,     0,     0,     0,   109,   495,     0,     0,     0,     0,
02180        0,   109,   109,     0,     0,     0,   324,   325,   326,   327,
02181      328,   329,   330,   331,   332,   333,   106,     0,     0,     0,
02182        0,     0,     0,     0,   106,     0,     0,     0,   109,   109,
02183        0,   106,   106,     0,    78,     0,     0,     0,     0,     0,
02184      109,     0,    78,     0,     0,     0,     0,     0,     0,    78,
02185       78,   308,   309,   310,   311,   312,   313,   314,   106,   106,
02186      317,   318,     0,     0,     0,     0,   321,   322,     0,     0,
02187      106,     0,     0,     0,     0,     0,    78,    78,   109,     0,
02188        0,     0,     0,     0,     0,   109,   109,     0,    78,   109,
02189        0,     0,     0,     0,     0,   324,   325,   326,   327,   328,
02190      329,   330,   331,   332,   333,   109,     0,     0,   106,     0,
02191        0,     0,     0,     0,     0,   106,   106,     0,     0,   106,
02192        0,     0,     0,     0,     0,     0,    78,   363,     0,     0,
02193        0,     0,     0,    78,    78,   106,     0,    78,     0,     0,
02194        0,     0,     0,     0,     0,   917,     0,     0,     0,   109,
02195        0,     0,     0,    78,     0,     0,     0,   362,     0,     0,
02196      109,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02197        0,     0,     0,     0,     0,   916,     0,     0,     0,   106,
02198        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02199      106,     0,     0,   913,     0,     0,     0,    78,     0,     0,
02200        0,     0,     0,   109,     0,   109,     0,     0,    78,     0,
02201        0,   109,     0,   109,     0,     0,     0,     0,     0,     0,
02202        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02203        0,     0,     0,   106,     0,   106,     0,     0,     0,     0,
02204        0,   106,     0,   106,     0,     0,     0,     0,     0,     0,
02205        0,    78,     0,    78,     0,     0,     0,     0,     0,    78,
02206        0,    78,  -573,     4,     0,     5,     6,     7,     8,     9,
02207        0,     0,     0,    10,    11,     0,     0,     0,    12,     0,
02208       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02209        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02210        0,    27,     0,     0,     0,     0,     0,    28,    29,    30,
02211       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02212        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02213        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02214        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02215        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02216       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02217        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02218        0,     0,     0,  -285,    61,    62,    63,     0,     0,     0,
02219        0,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,     0,
02220     -285,     0,     0,     0,     0,     0,     0,  -573,     0,  -573,
02221     -285,  -285,  -285,     0,     0,     0,     0,     0,     0,     0,
02222     -285,  -285,     0,  -285,  -285,  -285,  -285,  -285,     0,     0,
02223        0,     0,     0,     0,   308,   309,   310,   311,   312,   313,
02224      314,   315,   316,   317,   318,   319,   320,     0,     0,   321,
02225      322,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02226     -285,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,     0,
02227      724,  -285,     0,     0,     0,     0,   323,  -285,   324,   325,
02228      326,   327,   328,   329,   330,   331,   332,   333,     0,     0,
02229     -285,     0,  -105,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02230     -285,  -285,  -285,  -285,  -285,     0,     0,     0,     0,     0,
02231        0,     0,     0,   224,     0,     0,     0,     0,     0,     0,
02232     -285,  -285,  -285,  -285,  -411,     0,  -285,  -285,  -285,     0,
02233     -285,     0,  -411,  -411,  -411,     0,     0,  -411,  -411,  -411,
02234        0,  -411,     0,     0,     0,     0,     0,     0,     0,     0,
02235     -411,  -411,  -411,     0,     0,     0,     0,     0,     0,     0,
02236        0,  -411,  -411,     0,  -411,  -411,  -411,  -411,  -411,     0,
02237        0,     0,     0,     0,     0,   308,   309,   310,   311,   312,
02238      313,   314,   315,   316,   317,   318,   319,   320,     0,     0,
02239      321,   322,  -411,  -411,  -411,  -411,  -411,  -411,  -411,  -411,
02240     -411,  -411,  -411,  -411,  -411,     0,     0,  -411,  -411,  -411,
02241        0,     0,  -411,     0,     0,     0,     0,   323,  -411,   324,
02242      325,   326,   327,   328,   329,   330,   331,   332,   333,     0,
02243        0,     0,     0,     0,  -411,     0,  -411,  -411,  -411,  -411,
02244     -411,  -411,  -411,  -411,  -411,  -411,     0,     0,     0,     0,
02245        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02246     -411,  -411,  -411,  -411,  -411,  -279,   220,  -411,  -411,  -411,
02247        0,  -411,     0,  -279,  -279,  -279,     0,     0,  -279,  -279,
02248     -279,     0,  -279,     0,     0,     0,     0,     0,     0,     0,
02249        0,     0,  -279,  -279,  -279,     0,     0,     0,     0,     0,
02250        0,     0,  -279,  -279,     0,  -279,  -279,  -279,  -279,  -279,
02251        0,     0,     0,     0,     0,     0,   308,   309,   310,   311,
02252      312,   313,   314,   315,     0,   317,   318,     0,     0,     0,
02253        0,   321,   322,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02254     -279,  -279,  -279,  -279,  -279,  -279,     0,     0,  -279,  -279,
02255     -279,     0,     0,  -279,     0,     0,     0,     0,     0,  -279,
02256      324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
02257        0,     0,  -279,     0,     0,  -279,  -279,  -279,  -279,  -279,
02258     -279,  -279,  -279,  -279,  -279,  -279,  -279,     0,     0,     0,
02259        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02260        0,     0,  -279,  -279,  -279,  -279,  -573,     0,  -279,  -279,
02261     -279,     0,  -279,     0,  -573,  -573,  -573,     0,     0,  -573,
02262     -573,  -573,     0,  -573,     0,     0,     0,     0,     0,     0,
02263        0,     0,  -573,  -573,  -573,     0,     0,     0,     0,     0,
02264        0,     0,     0,  -573,  -573,     0,  -573,  -573,  -573,  -573,
02265     -573,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02266        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02267        0,     0,     0,     0,  -573,  -573,  -573,  -573,  -573,  -573,
02268     -573,  -573,  -573,  -573,  -573,  -573,  -573,     0,     0,  -573,
02269     -573,  -573,     0,     0,  -573,     0,     0,     0,     0,     0,
02270     -573,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02271        0,     0,     0,     0,     0,     0,  -573,     0,  -573,  -573,
02272     -573,  -573,  -573,  -573,  -573,  -573,  -573,  -573,     0,     0,
02273        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02274        0,     0,  -573,  -573,  -573,  -573,  -573,  -292,   220,  -573,
02275     -573,  -573,     0,  -573,     0,  -292,  -292,  -292,     0,     0,
02276     -292,  -292,  -292,     0,  -292,     0,     0,     0,     0,     0,
02277        0,     0,     0,     0,  -292,  -292,     0,     0,     0,     0,
02278        0,     0,     0,     0,  -292,  -292,     0,  -292,  -292,  -292,
02279     -292,  -292,     0,     0,     0,     0,     0,     0,     0,     0,
02280        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02281        0,     0,     0,     0,     0,  -292,  -292,  -292,  -292,  -292,
02282     -292,  -292,  -292,  -292,  -292,  -292,  -292,  -292,     0,     0,
02283     -292,  -292,  -292,     0,     0,  -292,     0,     0,     0,     0,
02284        0,  -292,     0,     0,     0,     0,     0,     0,     0,     0,
02285        0,     0,     0,     0,     0,     0,     0,  -292,     0,  -292,
02286     -292,  -292,  -292,  -292,  -292,  -292,  -292,  -292,  -292,     0,
02287        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02288        0,     0,     0,     0,  -292,  -292,  -292,  -292,  -555,   217,
02289     -292,  -292,  -292,     0,  -292,     0,  -555,  -555,  -555,     0,
02290        0,     0,  -555,  -555,     0,  -555,     0,     0,     0,     0,
02291        0,     0,     0,     0,  -555,     0,     0,     0,     0,     0,
02292        0,     0,     0,     0,     0,  -555,  -555,     0,  -555,  -555,
02293     -555,  -555,  -555,     0,     0,     0,     0,     0,     0,     0,
02294        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02295        0,     0,     0,     0,     0,     0,  -555,  -555,  -555,  -555,
02296     -555,  -555,  -555,  -555,  -555,  -555,  -555,  -555,  -555,     0,
02297        0,  -555,  -555,  -555,  -285,   665,     0,     0,     0,     0,
02298        0,     0,  -285,  -285,  -285,     0,     0,     0,  -285,  -285,
02299        0,  -285,     0,     0,     0,     0,     0,  -103,  -555,     0,
02300     -555,  -555,  -555,  -555,  -555,  -555,  -555,  -555,  -555,  -555,
02301        0,  -285,  -285,     0,  -285,  -285,  -285,  -285,  -285,     0,
02302        0,     0,     0,     0,  -555,  -555,  -555,  -555,   -94,     0,
02303        0,  -555,     0,  -555,     0,  -555,     0,     0,     0,     0,
02304        0,     0,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02305     -285,  -285,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,
02306        0,   666,     0,     0,     0,     0,     0,     0,     0,     0,
02307        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02308        0,     0,     0,  -105,  -285,     0,  -285,  -285,  -285,  -285,
02309     -285,  -285,  -285,  -285,  -285,  -285,     0,     0,     0,     0,
02310        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02311        0,  -285,  -285,  -285,   -96,     0,     0,  -285,     0,  -285,
02312      241,  -285,     5,     6,     7,     8,     9,  -573,  -573,  -573,
02313       10,    11,     0,     0,  -573,    12,     0,    13,    14,    15,
02314       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02315       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02316        0,     0,     0,     0,    28,    29,     0,    31,    32,    33,
02317       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02318        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02319        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02320        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02321        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02322       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02323        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02324        0,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02325        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02326        0,     0,     0,     0,  -573,   241,  -573,     5,     6,     7,
02327        8,     9,     0,     0,  -573,    10,    11,     0,  -573,  -573,
02328       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02329        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02330       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02331       29,     0,    31,    32,    33,    34,    35,    36,    37,    38,
02332       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02333       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02334        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02335       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02336        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02337        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02338        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02339        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02340        0,     0,     0,     0,     0,     0,     0,     0,     0,  -573,
02341      241,  -573,     5,     6,     7,     8,     9,     0,     0,  -573,
02342       10,    11,     0,     0,  -573,    12,  -573,    13,    14,    15,
02343       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02344       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02345        0,     0,     0,     0,    28,    29,     0,    31,    32,    33,
02346       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02347        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02348        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02349        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02350        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02351       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02352        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02353        0,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02354        4,     0,     5,     6,     7,     8,     9,     0,     0,     0,
02355       10,    11,     0,     0,  -573,    12,  -573,    13,    14,    15,
02356       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02357       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02358        0,     0,     0,     0,    28,    29,    30,    31,    32,    33,
02359       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02360        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02361        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02362        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02363        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02364       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02365        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02366        0,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02367        0,     0,     0,     0,     0,     0,  -573,     0,     0,     0,
02368        0,     0,     0,     0,  -573,   241,  -573,     5,     6,     7,
02369        8,     9,     0,     0,  -573,    10,    11,     0,     0,  -573,
02370       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02371        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02372       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02373       29,     0,    31,    32,    33,    34,    35,    36,    37,    38,
02374       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02375       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02376        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02377       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02378        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02379        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02380        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02381        0,     0,     0,     0,     0,   241,     0,     5,     6,     7,
02382        8,     9,     0,  -573,  -573,    10,    11,     0,     0,  -573,
02383       12,  -573,    13,    14,    15,    16,    17,    18,    19,     0,
02384        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02385       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02386       29,     0,    31,    32,    33,    34,    35,    36,    37,    38,
02387       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02388       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02389        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02390       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02391        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02392        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02393        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02394        0,     0,     0,     0,     0,   241,     0,     5,     6,     7,
02395        8,     9,     0,     0,     0,    10,    11,     0,     0,  -573,
02396       12,  -573,    13,    14,    15,    16,    17,    18,    19,     0,
02397        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02398       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02399       29,     0,    31,    32,    33,    34,    35,    36,    37,    38,
02400       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02401       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02402        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02403       48,     0,     0,   242,    50,     0,    51,    52,     0,    53,
02404        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02405        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02406        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02407        0,     0,     0,     0,     0,   241,     0,     5,     6,     7,
02408        8,     9,     0,     0,     0,    10,    11,  -573,     0,  -573,
02409       12,  -573,    13,    14,    15,    16,    17,    18,    19,     0,
02410        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02411       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02412       29,     0,    31,    32,    33,    34,    35,    36,    37,    38,
02413       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02414       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02415        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02416       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02417        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02418        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02419        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02420        0,     0,     0,     0,     0,   241,     0,     5,     6,     7,
02421        8,     9,     0,     0,     0,    10,    11,  -573,     0,  -573,
02422       12,  -573,    13,    14,    15,    16,    17,    18,    19,     0,
02423        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02424       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02425       29,     0,    31,    32,    33,    34,    35,    36,    37,    38,
02426       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02427       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02428        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02429       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02430        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02431        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02432        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02433        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02434        0,  -573,     0,     0,     0,     0,     0,     0,     0,  -573,
02435      241,  -573,     5,     6,     7,     8,     9,     0,     0,  -573,
02436       10,    11,     0,     0,     0,    12,     0,    13,    14,    15,
02437       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02438       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02439        0,     0,     0,     0,    28,    29,     0,    31,    32,    33,
02440       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02441        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02442        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02443        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02444        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02445       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02446        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02447        0,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02448        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02449       10,    11,     0,     0,  -573,    12,  -573,    13,    14,    15,
02450       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02451       21,    22,    23,    24,    25,    26,     0,     0,   194,     0,
02452        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02453       34,    35,    36,    37,    38,    39,    40,   195,    41,    42,
02454        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02455        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02456        0,     0,     0,     0,     0,   196,     0,     0,   197,    50,
02457        0,    51,    52,     0,   198,   199,    54,    55,    56,    57,
02458       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02459        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02460       11,    61,   200,    63,    12,     0,    13,    14,    15,    16,
02461       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02462       22,    23,    24,    25,    26,     0,   224,    27,     0,     0,
02463        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02464       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02465       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02466        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02467        0,     0,     0,     0,   196,     0,     0,   197,    50,     0,
02468       51,    52,     0,     0,     0,    54,    55,    56,    57,    58,
02469       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02470        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02471       61,    62,    63,     0,     0,     0,     0,     0,     0,     0,
02472        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02473       11,     0,     0,   288,    12,   289,    13,    14,    15,    16,
02474       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02475       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02476        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02477       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02478       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02479        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02480        0,     0,     0,     0,   196,     0,     0,   197,    50,     0,
02481       51,    52,     0,     0,     0,    54,    55,    56,    57,    58,
02482       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02483        5,     6,     7,     8,     9,     0,     0,     0,    10,    11,
02484       61,    62,    63,    12,     0,    13,    14,    15,    16,    17,
02485       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02486       23,    24,    25,    26,     0,   224,    27,     0,     0,     0,
02487        0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
02488       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02489       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02490        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02491        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02492       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02493       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02494        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02495       62,    63,     0,     0,     0,     0,     0,     0,     5,     6,
02496        7,     8,     9,     0,     0,     0,    10,    11,     0,     0,
02497        0,    12,   474,    13,    14,    15,    16,    17,    18,    19,
02498        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02499       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02500       28,    29,     0,    31,    32,    33,    34,    35,    36,    37,
02501       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02502        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02503        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02504        0,    48,     0,     0,    49,    50,     0,    51,    52,     0,
02505       53,     0,    54,    55,    56,    57,    58,    59,    60,     0,
02506        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02507        0,     0,     0,     0,     0,     0,     0,    61,    62,    63,
02508        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02509        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02510      474,   113,   114,   115,   116,   117,   118,   119,   120,   121,
02511      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02512      132,   133,   134,   135,   136,     0,     0,     0,   137,   138,
02513      139,   365,   366,   367,   368,   144,   145,   146,     0,     0,
02514        0,     0,     0,   147,   148,   149,   150,   369,   370,   371,
02515      372,   155,    37,    38,   373,    40,     0,     0,     0,     0,
02516        0,     0,     0,     0,   157,   158,   159,   160,   161,   162,
02517      163,   164,   165,     0,     0,   166,   167,     0,     0,   168,
02518      169,   170,   171,     0,     0,     0,     0,     0,     0,     0,
02519        0,     0,     0,   172,     0,     0,     0,     0,     0,     0,
02520        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02521      173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
02522        0,   183,   184,     0,     0,     0,     0,     0,  -548,  -548,
02523     -548,     0,  -548,     0,     0,     0,  -548,  -548,     0,   185,
02524      374,  -548,     0,  -548,  -548,  -548,  -548,  -548,  -548,  -548,
02525        0,  -548,     0,     0,     0,  -548,  -548,  -548,  -548,  -548,
02526     -548,  -548,     0,     0,  -548,     0,     0,     0,     0,     0,
02527        0,  -548,     0,     0,  -548,  -548,  -548,  -548,  -548,  -548,
02528     -548,  -548,  -548,  -548,  -548,  -548,     0,  -548,  -548,  -548,
02529        0,  -548,  -548,     0,     0,     0,     0,     0,     0,     0,
02530        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02531        0,  -548,     0,     0,  -548,  -548,     0,  -548,  -548,     0,
02532     -548,  -548,  -548,  -548,  -548,  -548,  -548,  -548,  -548,     0,
02533        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02534        0,     0,     0,     0,     0,     0,     0,  -548,  -548,  -548,
02535        0,     0,     0,     0,     0,  -549,  -549,  -549,     0,  -549,
02536        0,  -548,     0,  -549,  -549,     0,     0,  -548,  -549,     0,
02537     -549,  -549,  -549,  -549,  -549,  -549,  -549,     0,  -549,     0,
02538        0,     0,  -549,  -549,  -549,  -549,  -549,  -549,  -549,     0,
02539        0,  -549,     0,     0,     0,     0,     0,     0,  -549,     0,
02540        0,  -549,  -549,  -549,  -549,  -549,  -549,  -549,  -549,  -549,
02541     -549,  -549,  -549,     0,  -549,  -549,  -549,     0,  -549,  -549,
02542        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02543        0,     0,     0,     0,     0,     0,     0,     0,  -549,     0,
02544        0,  -549,  -549,     0,  -549,  -549,     0,  -549,  -549,  -549,
02545     -549,  -549,  -549,  -549,  -549,  -549,     0,     0,     0,     0,
02546        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02547        0,     0,     0,     0,  -549,  -549,  -549,     0,     0,     0,
02548        0,     0,  -551,  -551,  -551,     0,  -551,     0,  -549,     0,
02549     -551,  -551,     0,     0,  -549,  -551,     0,  -551,  -551,  -551,
02550     -551,  -551,  -551,  -551,     0,     0,     0,     0,     0,  -551,
02551     -551,  -551,  -551,  -551,  -551,  -551,     0,     0,  -551,     0,
02552        0,     0,     0,     0,     0,  -551,     0,     0,  -551,  -551,
02553     -551,  -551,  -551,  -551,  -551,  -551,  -551,  -551,  -551,  -551,
02554        0,  -551,  -551,  -551,     0,  -551,  -551,     0,     0,     0,
02555        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02556        0,     0,     0,     0,     0,  -551,   723,     0,  -551,  -551,
02557        0,  -551,  -551,     0,  -551,  -551,  -551,  -551,  -551,  -551,
02558     -551,  -551,  -551,     0,     0,     0,     0,     0,  -103,     0,
02559        0,     0,     0,     0,     0,     0,  -553,  -553,  -553,     0,
02560     -553,  -551,  -551,  -551,  -553,  -553,     0,     0,     0,  -553,
02561        0,  -553,  -553,  -553,  -553,  -553,  -553,  -553,     0,     0,
02562        0,  -551,     0,  -553,  -553,  -553,  -553,  -553,  -553,  -553,
02563        0,     0,  -553,     0,     0,     0,     0,     0,     0,  -553,
02564        0,     0,  -553,  -553,  -553,  -553,  -553,  -553,  -553,  -553,
02565     -553,  -553,  -553,  -553,     0,  -553,  -553,  -553,     0,  -553,
02566     -553,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02567        0,     0,     0,     0,     0,     0,     0,     0,     0,  -553,
02568        0,     0,  -553,  -553,     0,  -553,  -553,     0,  -553,  -553,
02569     -553,  -553,  -553,  -553,  -553,  -553,  -553,     0,     0,     0,
02570        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02571     -554,  -554,  -554,     0,  -554,  -553,  -553,  -553,  -554,  -554,
02572        0,     0,     0,  -554,     0,  -554,  -554,  -554,  -554,  -554,
02573     -554,  -554,     0,     0,     0,  -553,     0,  -554,  -554,  -554,
02574     -554,  -554,  -554,  -554,     0,     0,  -554,     0,     0,     0,
02575        0,     0,     0,  -554,     0,     0,  -554,  -554,  -554,  -554,
02576     -554,  -554,  -554,  -554,  -554,  -554,  -554,  -554,     0,  -554,
02577     -554,  -554,     0,  -554,  -554,     0,     0,     0,     0,     0,
02578        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02579        0,     0,     0,  -554,     0,     0,  -554,  -554,     0,  -554,
02580     -554,     0,  -554,  -554,  -554,  -554,  -554,  -554,  -554,  -554,
02581     -554,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02582        0,     0,     0,     0,     0,     0,     0,     0,     0,  -554,
02583     -554,  -554,     0,     0,     0,     0,     0,     0,     0,     0,
02584        0,     0,     0,     0,     0,     0,     0,     0,     0,  -554,
02585      113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
02586      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02587      133,   134,   135,   136,     0,     0,     0,   137,   138,   139,
02588      140,   141,   142,   143,   144,   145,   146,     0,     0,     0,
02589        0,     0,   147,   148,   149,   150,   151,   152,   153,   154,
02590      155,   270,   271,   156,   272,     0,     0,     0,     0,     0,
02591        0,     0,     0,   157,   158,   159,   160,   161,   162,   163,
02592      164,   165,     0,     0,   166,   167,     0,     0,   168,   169,
02593      170,   171,     0,     0,     0,     0,     0,     0,     0,     0,
02594        0,     0,   172,     0,     0,     0,     0,     0,     0,     0,
02595        0,     0,     0,     0,     0,     0,     0,     0,     0,   173,
02596      174,   175,   176,   177,   178,   179,   180,   181,   182,     0,
02597      183,   184,     0,     0,     0,     0,     0,     0,     0,     0,
02598        0,     0,     0,     0,     0,     0,     0,     0,   185,   113,
02599      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
02600      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02601      134,   135,   136,     0,     0,     0,   137,   138,   139,   140,
02602      141,   142,   143,   144,   145,   146,     0,     0,     0,     0,
02603        0,   147,   148,   149,   150,   151,   152,   153,   154,   155,
02604      226,     0,   156,     0,     0,     0,     0,     0,     0,     0,
02605        0,     0,   157,   158,   159,   160,   161,   162,   163,   164,
02606      165,     0,     0,   166,   167,     0,     0,   168,   169,   170,
02607      171,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02608        0,   172,     0,     0,    55,     0,     0,     0,     0,     0,
02609        0,     0,     0,     0,     0,     0,     0,     0,   173,   174,
02610      175,   176,   177,   178,   179,   180,   181,   182,     0,   183,
02611      184,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02612        0,     0,     0,     0,     0,     0,     0,   185,   113,   114,
02613      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
02614      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
02615      135,   136,     0,     0,     0,   137,   138,   139,   140,   141,
02616      142,   143,   144,   145,   146,     0,     0,     0,     0,     0,
02617      147,   148,   149,   150,   151,   152,   153,   154,   155,     0,
02618        0,   156,     0,     0,     0,     0,     0,     0,     0,     0,
02619        0,   157,   158,   159,   160,   161,   162,   163,   164,   165,
02620        0,     0,   166,   167,     0,     0,   168,   169,   170,   171,
02621        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02622      172,     0,     0,    55,     0,     0,     0,     0,     0,     0,
02623        0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
02624      176,   177,   178,   179,   180,   181,   182,     0,   183,   184,
02625        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02626        0,     0,     0,     0,     0,     0,   185,   113,   114,   115,
02627      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
02628      126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
02629      136,     0,     0,     0,   137,   138,   139,   140,   141,   142,
02630      143,   144,   145,   146,     0,     0,     0,     0,     0,   147,
02631      148,   149,   150,   151,   152,   153,   154,   155,     0,     0,
02632      156,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02633      157,   158,   159,   160,   161,   162,   163,   164,   165,     0,
02634        0,   166,   167,     0,     0,   168,   169,   170,   171,     0,
02635        0,     0,     0,     0,     0,     0,     0,     0,     0,   172,
02636        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02637        0,     0,     0,     0,     0,     0,   173,   174,   175,   176,
02638      177,   178,   179,   180,   181,   182,     0,   183,   184,     0,
02639        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02640       11,     0,     0,     0,    12,   185,    13,    14,    15,   231,
02641      232,    18,    19,     0,     0,     0,     0,     0,   233,   234,
02642      235,    23,    24,    25,    26,     0,     0,   194,     0,     0,
02643        0,     0,     0,     0,   258,     0,     0,    32,    33,    34,
02644       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02645       43,    44,    45,     0,     0,     0,     0,     0,     0,     0,
02646        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02647        0,     0,     0,     0,   259,     0,     0,   197,    50,     0,
02648       51,    52,     0,     0,     0,    54,    55,    56,    57,    58,
02649       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02650        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02651      260,    10,    11,     0,     0,     0,    12,     0,    13,    14,
02652       15,   231,   232,    18,    19,     0,     0,     0,   261,     0,
02653      233,   234,   235,    23,    24,    25,    26,     0,     0,   194,
02654        0,     0,     0,     0,     0,     0,   258,     0,     0,    32,
02655       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02656       42,     0,    43,    44,    45,     0,     0,     0,     0,     0,
02657        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02658        0,     0,     0,     0,     0,     0,   259,     0,     0,   197,
02659       50,     0,    51,    52,     0,     0,     0,    54,    55,    56,
02660       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02661        0,     0,     0,     0,     0,     5,     6,     7,     8,     9,
02662        0,     0,   260,    10,    11,     0,     0,     0,    12,     0,
02663       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02664      490,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02665        0,    27,     0,     0,     0,     0,     0,    28,    29,    30,
02666       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02667        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02668        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02669        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02670        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02671       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02672        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02673        0,     0,    10,    11,    61,    62,    63,    12,     0,    13,
02674       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02675        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02676       27,     0,     0,     0,     0,     0,    28,    29,     0,    31,
02677       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02678       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02679        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02680        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02681       49,    50,     0,    51,    52,     0,    53,     0,    54,    55,
02682       56,    57,    58,    59,    60,     0,     0,     0,     0,     0,
02683        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02684        0,    10,    11,    61,    62,    63,    12,     0,    13,    14,
02685       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02686       20,    21,    22,    23,    24,    25,    26,     0,     0,   194,
02687        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02688       33,    34,    35,    36,    37,    38,    39,    40,   195,    41,
02689       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02690        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02691        0,     0,     0,     0,     0,     0,   196,     0,     0,   197,
02692       50,     0,    51,    52,     0,   198,   199,    54,    55,    56,
02693       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02694        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02695       10,    11,    61,   200,    63,    12,     0,    13,    14,    15,
02696      231,   232,    18,    19,     0,     0,     0,     0,     0,   233,
02697      234,   235,    23,    24,    25,    26,     0,     0,   194,     0,
02698        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02699       34,    35,    36,    37,    38,    39,    40,   195,    41,    42,
02700        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02701        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02702        0,     0,     0,     0,     0,   196,     0,     0,   197,    50,
02703        0,    51,    52,     0,   587,   199,    54,    55,    56,    57,
02704       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02705        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02706       11,    61,   200,    63,    12,     0,    13,    14,    15,   231,
02707      232,    18,    19,     0,     0,     0,     0,     0,   233,   234,
02708      235,    23,    24,    25,    26,     0,     0,   194,     0,     0,
02709        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02710       35,    36,    37,    38,    39,    40,   195,    41,    42,     0,
02711       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02712        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02713        0,     0,     0,     0,   196,     0,     0,   197,    50,     0,
02714       51,    52,     0,   198,     0,    54,    55,    56,    57,    58,
02715       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02716        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02717       61,   200,    63,    12,     0,    13,    14,    15,   231,   232,
02718       18,    19,     0,     0,     0,     0,     0,   233,   234,   235,
02719       23,    24,    25,    26,     0,     0,   194,     0,     0,     0,
02720        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02721       36,    37,    38,    39,    40,   195,    41,    42,     0,    43,
02722       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02723        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02724        0,     0,     0,   196,     0,     0,   197,    50,     0,    51,
02725       52,     0,     0,   199,    54,    55,    56,    57,    58,    59,
02726       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02727        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02728      200,    63,    12,     0,    13,    14,    15,   231,   232,    18,
02729       19,     0,     0,     0,     0,     0,   233,   234,   235,    23,
02730       24,    25,    26,     0,     0,   194,     0,     0,     0,     0,
02731        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02732       37,    38,    39,    40,   195,    41,    42,     0,    43,    44,
02733       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02734        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02735        0,     0,   196,     0,     0,   197,    50,     0,    51,    52,
02736        0,   587,     0,    54,    55,    56,    57,    58,    59,    60,
02737        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02738        7,     0,     9,     0,     0,     0,    10,    11,    61,   200,
02739       63,    12,     0,    13,    14,    15,   231,   232,    18,    19,
02740        0,     0,     0,     0,     0,   233,   234,   235,    23,    24,
02741       25,    26,     0,     0,   194,     0,     0,     0,     0,     0,
02742        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02743       38,    39,    40,   195,    41,    42,     0,    43,    44,    45,
02744        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02745        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02746        0,   196,     0,     0,   197,    50,     0,    51,    52,     0,
02747        0,     0,    54,    55,    56,    57,    58,    59,    60,     0,
02748        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02749        0,     9,     0,     0,     0,    10,    11,    61,   200,    63,
02750       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02751        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02752       26,     0,     0,   194,     0,     0,     0,     0,     0,     0,
02753       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02754       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02755       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02756        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02757      196,     0,     0,   197,    50,     0,    51,    52,     0,   484,
02758        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02759        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02760        9,     0,     0,     0,    10,    11,    61,   200,    63,    12,
02761        0,    13,    14,    15,   231,   232,    18,    19,     0,     0,
02762        0,     0,     0,   233,   234,   235,    23,    24,    25,    26,
02763        0,     0,   194,     0,     0,     0,     0,     0,     0,    29,
02764        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02765       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02766       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02767        0,     0,     0,     0,     0,     0,     0,     0,     0,   196,
02768        0,     0,   197,    50,     0,    51,    52,     0,   198,     0,
02769       54,    55,    56,    57,    58,    59,    60,     0,     0,     0,
02770        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02771        0,     0,     0,    10,    11,    61,   200,    63,    12,     0,
02772       13,    14,    15,   231,   232,    18,    19,     0,     0,     0,
02773        0,     0,   233,   234,   235,    23,    24,    25,    26,     0,
02774        0,   194,     0,     0,     0,     0,     0,     0,    29,     0,
02775        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02776        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02777        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02778        0,     0,     0,     0,     0,     0,     0,     0,   196,     0,
02779        0,   197,    50,     0,    51,    52,     0,   772,     0,    54,
02780       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02781        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02782        0,     0,    10,    11,    61,   200,    63,    12,     0,    13,
02783       14,    15,   231,   232,    18,    19,     0,     0,     0,     0,
02784        0,   233,   234,   235,    23,    24,    25,    26,     0,     0,
02785      194,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02786       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02787       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02788        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02789        0,     0,     0,     0,     0,     0,     0,   196,     0,     0,
02790      197,    50,     0,    51,    52,     0,   484,     0,    54,    55,
02791       56,    57,    58,    59,    60,     0,     0,     0,     0,     0,
02792        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02793        0,    10,    11,    61,   200,    63,    12,     0,    13,    14,
02794       15,   231,   232,    18,    19,     0,     0,     0,     0,     0,
02795      233,   234,   235,    23,    24,    25,    26,     0,     0,   194,
02796        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02797       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02798       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02799        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02800        0,     0,     0,     0,     0,     0,   196,     0,     0,   197,
02801       50,     0,    51,    52,     0,   587,     0,    54,    55,    56,
02802       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02803        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02804       10,    11,    61,   200,    63,    12,     0,    13,    14,    15,
02805      231,   232,    18,    19,     0,     0,     0,     0,     0,   233,
02806      234,   235,    23,    24,    25,    26,     0,     0,   194,     0,
02807        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02808       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02809        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02810        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02811        0,     0,     0,     0,     0,   196,     0,     0,   197,    50,
02812        0,    51,    52,     0,     0,     0,    54,    55,    56,    57,
02813       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02814        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02815       11,    61,   200,    63,    12,     0,    13,    14,    15,    16,
02816       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02817       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02818        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02819       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02820       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02821        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02822        0,     0,     0,     0,   196,     0,     0,   197,    50,     0,
02823       51,    52,     0,     0,     0,    54,    55,    56,    57,    58,
02824       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02825        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02826       61,    62,    63,    12,     0,    13,    14,    15,    16,    17,
02827       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02828       23,    24,    25,    26,     0,     0,   194,     0,     0,     0,
02829        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02830       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02831       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02832        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02833        0,     0,     0,   196,     0,     0,   197,    50,     0,    51,
02834       52,     0,     0,     0,    54,    55,    56,    57,    58,    59,
02835       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02836        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02837      200,    63,    12,     0,    13,    14,    15,   231,   232,    18,
02838       19,     0,     0,     0,     0,     0,   233,   234,   235,    23,
02839       24,    25,    26,     0,     0,   194,     0,     0,     0,     0,
02840        0,     0,   258,     0,     0,    32,    33,    34,    35,    36,
02841       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02842       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02843        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02844        0,     0,   259,     0,     0,   304,    50,     0,    51,    52,
02845        0,   305,     0,    54,    55,    56,    57,    58,    59,    60,
02846        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02847        0,     0,    10,    11,     0,     0,     0,    12,   260,    13,
02848       14,    15,   231,   232,    18,    19,     0,     0,     0,     0,
02849        0,   233,   234,   235,    23,    24,    25,    26,     0,     0,
02850      194,     0,     0,     0,     0,     0,     0,   258,     0,     0,
02851       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02852       41,    42,     0,    43,    44,    45,     0,     0,     0,     0,
02853        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02854        0,     0,     0,     0,     0,     0,     0,   346,     0,     0,
02855       49,    50,     0,    51,    52,     0,    53,     0,    54,    55,
02856       56,    57,    58,    59,    60,     0,     0,     0,     0,     5,
02857        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02858        0,     0,    12,   260,    13,    14,    15,   231,   232,    18,
02859       19,     0,     0,     0,     0,     0,   233,   234,   235,    23,
02860       24,    25,    26,     0,     0,   194,     0,     0,     0,     0,
02861        0,     0,   258,     0,     0,    32,    33,    34,   354,    36,
02862       37,    38,   355,    40,     0,    41,    42,     0,    43,    44,
02863       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02864        0,     0,     0,     0,     0,     0,     0,     0,     0,   356,
02865        0,     0,   357,     0,     0,   197,    50,     0,    51,    52,
02866        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02867        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02868        0,     0,    10,    11,     0,     0,     0,    12,   260,    13,
02869       14,    15,   231,   232,    18,    19,     0,     0,     0,     0,
02870        0,   233,   234,   235,    23,    24,    25,    26,     0,     0,
02871      194,     0,     0,     0,     0,     0,     0,   258,     0,     0,
02872       32,    33,    34,   354,    36,    37,    38,   355,    40,     0,
02873       41,    42,     0,    43,    44,    45,     0,     0,     0,     0,
02874        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02875        0,     0,     0,     0,     0,     0,     0,   357,     0,     0,
02876      197,    50,     0,    51,    52,     0,     0,     0,    54,    55,
02877       56,    57,    58,    59,    60,     0,     0,     0,     0,     5,
02878        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02879        0,     0,    12,   260,    13,    14,    15,   231,   232,    18,
02880       19,     0,     0,     0,     0,     0,   233,   234,   235,    23,
02881       24,    25,    26,     0,     0,   194,     0,     0,     0,     0,
02882        0,     0,   258,     0,     0,    32,    33,    34,    35,    36,
02883       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02884       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02885        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02886        0,     0,   259,     0,     0,   304,    50,     0,    51,    52,
02887        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02888        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02889        0,     0,    10,    11,     0,     0,     0,    12,   260,    13,
02890       14,    15,   231,   232,    18,    19,     0,     0,     0,     0,
02891        0,   233,   234,   235,    23,    24,    25,    26,     0,     0,
02892      194,     0,     0,     0,     0,     0,     0,   258,     0,     0,
02893       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02894       41,    42,     0,    43,    44,    45,     0,     0,     0,     0,
02895        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02896        0,     0,     0,     0,     0,     0,     0,   902,     0,     0,
02897      197,    50,     0,    51,    52,     0,     0,     0,    54,    55,
02898       56,    57,    58,    59,    60,     0,     0,     0,     0,     5,
02899        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02900        0,     0,    12,   260,    13,    14,    15,   231,   232,    18,
02901       19,     0,     0,     0,     0,     0,   233,   234,   235,    23,
02902       24,    25,    26,     0,     0,   194,     0,   663,     0,     0,
02903        0,     0,   258,     0,     0,    32,    33,    34,    35,    36,
02904       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02905       45,   308,   309,   310,   311,   312,   313,   314,   315,   316,
02906      317,   318,   319,   320,     0,     0,   321,   322,     0,     0,
02907        0,     0,   912,     0,     0,   197,    50,     0,    51,    52,
02908        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02909        0,     0,     0,   323,     0,   324,   325,   326,   327,   328,
02910      329,   330,   331,   332,   333,     0,     0,     0,   260,     0,
02911      525,   526,     0,     0,   527,     0,     0,     0,     0,     0,
02912        0,     0,     0,  -241,   157,   158,   159,   160,   161,   162,
02913      163,   164,   165,     0,     0,   166,   167,     0,     0,   168,
02914      169,   170,   171,     0,     0,     0,     0,     0,     0,     0,
02915        0,     0,     0,   172,     0,     0,     0,     0,     0,     0,
02916        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02917      173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
02918        0,   183,   184,     0,     0,     0,     0,   533,   534,     0,
02919        0,   535,     0,     0,     0,     0,     0,     0,     0,   185,
02920      220,   157,   158,   159,   160,   161,   162,   163,   164,   165,
02921        0,     0,   166,   167,     0,     0,   168,   169,   170,   171,
02922        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02923      172,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02924        0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
02925      176,   177,   178,   179,   180,   181,   182,     0,   183,   184,
02926        0,     0,     0,     0,   591,   526,     0,     0,   592,     0,
02927        0,     0,     0,     0,     0,     0,   185,   220,   157,   158,
02928      159,   160,   161,   162,   163,   164,   165,     0,     0,   166,
02929      167,     0,     0,   168,   169,   170,   171,     0,     0,     0,
02930        0,     0,     0,     0,     0,     0,     0,   172,     0,     0,
02931        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02932        0,     0,     0,     0,   173,   174,   175,   176,   177,   178,
02933      179,   180,   181,   182,     0,   183,   184,     0,     0,     0,
02934        0,   594,   534,     0,     0,   595,     0,     0,     0,     0,
02935        0,     0,     0,   185,   220,   157,   158,   159,   160,   161,
02936      162,   163,   164,   165,     0,     0,   166,   167,     0,     0,
02937      168,   169,   170,   171,     0,     0,     0,     0,     0,     0,
02938        0,     0,     0,     0,   172,     0,     0,     0,     0,     0,
02939        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02940        0,   173,   174,   175,   176,   177,   178,   179,   180,   181,
02941      182,     0,   183,   184,     0,     0,     0,     0,   617,   526,
02942        0,     0,   618,     0,     0,     0,     0,     0,     0,     0,
02943      185,   220,   157,   158,   159,   160,   161,   162,   163,   164,
02944      165,     0,     0,   166,   167,     0,     0,   168,   169,   170,
02945      171,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02946        0,   172,     0,     0,     0,     0,     0,     0,     0,     0,
02947        0,     0,     0,     0,     0,     0,     0,     0,   173,   174,
02948      175,   176,   177,   178,   179,   180,   181,   182,     0,   183,
02949      184,     0,     0,     0,     0,   620,   534,     0,     0,   621,
02950        0,     0,     0,     0,     0,     0,     0,   185,   220,   157,
02951      158,   159,   160,   161,   162,   163,   164,   165,     0,     0,
02952      166,   167,     0,     0,   168,   169,   170,   171,     0,     0,
02953        0,     0,     0,     0,     0,     0,     0,     0,   172,     0,
02954        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02955        0,     0,     0,     0,     0,   173,   174,   175,   176,   177,
02956      178,   179,   180,   181,   182,     0,   183,   184,     0,     0,
02957        0,     0,   692,   526,     0,     0,   693,     0,     0,     0,
02958        0,     0,     0,     0,   185,   220,   157,   158,   159,   160,
02959      161,   162,   163,   164,   165,     0,     0,   166,   167,     0,
02960        0,   168,   169,   170,   171,     0,     0,     0,     0,     0,
02961        0,     0,     0,     0,     0,   172,     0,     0,     0,     0,
02962        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02963        0,     0,   173,   174,   175,   176,   177,   178,   179,   180,
02964      181,   182,     0,   183,   184,     0,     0,     0,     0,   695,
02965      534,     0,     0,   696,     0,     0,     0,     0,     0,     0,
02966        0,   185,   220,   157,   158,   159,   160,   161,   162,   163,
02967      164,   165,     0,     0,   166,   167,     0,     0,   168,   169,
02968      170,   171,     0,     0,     0,     0,     0,     0,     0,     0,
02969        0,     0,   172,     0,     0,     0,     0,     0,     0,     0,
02970        0,     0,     0,     0,     0,     0,     0,     0,     0,   173,
02971      174,   175,   176,   177,   178,   179,   180,   181,   182,     0,
02972      183,   184,     0,     0,     0,     0,   702,   526,     0,     0,
02973      703,     0,     0,     0,     0,     0,     0,     0,   185,   220,
02974      157,   158,   159,   160,   161,   162,   163,   164,   165,     0,
02975        0,   166,   167,     0,     0,   168,   169,   170,   171,     0,
02976        0,     0,     0,     0,     0,     0,     0,     0,     0,   172,
02977        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02978        0,     0,     0,     0,     0,     0,   173,   174,   175,   176,
02979      177,   178,   179,   180,   181,   182,     0,   183,   184,     0,
02980        0,     0,     0,   572,   534,     0,     0,   573,     0,     0,
02981        0,     0,     0,     0,     0,   185,   220,   157,   158,   159,
02982      160,   161,   162,   163,   164,   165,     0,     0,   166,   167,
02983        0,     0,   168,   169,   170,   171,     0,     0,     0,     0,
02984        0,     0,     0,     0,     0,     0,   172,     0,     0,     0,
02985        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02986        0,     0,     0,   173,   174,   175,   176,   177,   178,   179,
02987      180,   181,   182,     0,   183,   184,     0,     0,     0,     0,
02988      965,   526,     0,     0,   966,     0,     0,     0,     0,     0,
02989        0,     0,   185,   220,   157,   158,   159,   160,   161,   162,
02990      163,   164,   165,     0,     0,   166,   167,     0,     0,   168,
02991      169,   170,   171,     0,     0,     0,     0,     0,     0,     0,
02992        0,     0,     0,   172,     0,     0,     0,     0,     0,     0,
02993        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02994      173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
02995        0,   183,   184,     0,     0,     0,     0,   971,   526,     0,
02996        0,   972,     0,     0,     0,     0,     0,     0,     0,   185,
02997      220,   157,   158,   159,   160,   161,   162,   163,   164,   165,
02998        0,     0,   166,   167,     0,     0,   168,   169,   170,   171,
02999        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03000      172,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03001        0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
03002      176,   177,   178,   179,   180,   181,   182,     0,   183,   184,
03003        0,     0,     0,     0,   974,   534,     0,     0,   975,     0,
03004        0,     0,     0,     0,     0,     0,   185,   220,   157,   158,
03005      159,   160,   161,   162,   163,   164,   165,     0,     0,   166,
03006      167,     0,     0,   168,   169,   170,   171,     0,     0,     0,
03007        0,     0,     0,     0,     0,     0,     0,   172,     0,     0,
03008        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03009        0,     0,     0,     0,   173,   174,   175,   176,   177,   178,
03010      179,   180,   181,   182,     0,   183,   184,     0,     0,     0,
03011        0,   572,   534,     0,     0,   573,     0,     0,     0,     0,
03012        0,     0,     0,   185,   220,   157,   158,   159,   160,   161,
03013      162,   163,   164,   165,     0,     0,   166,   167,     0,     0,
03014      168,   169,   170,   171,     0,     0,     0,     0,     0,     0,
03015        0,     0,     0,     0,   172,     0,     0,     0,     0,     0,
03016        0,     0,   718,     0,     0,     0,     0,     0,     0,     0,
03017        0,   173,   174,   175,   176,   177,   178,   179,   180,   181,
03018      182,   663,   183,   184,     0,     0,   308,   309,   310,   311,
03019      312,   313,   314,   315,   316,   317,   318,   319,   320,     0,
03020      185,   321,   322,     0,     0,   308,   309,   310,   311,   312,
03021      313,   314,   315,   316,   317,   318,   319,   320,     0,     0,
03022      321,   322,     0,     0,     0,     0,     0,     0,   323,     0,
03023      324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
03024        0,     0,     0,     0,     0,     0,     0,   323,     0,   324,
03025      325,   326,   327,   328,   329,   330,   331,   332,   333
03026 };
03027 
03028 #define yypact_value_is_default(Yystate) \
03029   (!!((Yystate) == (-747)))
03030 
03031 #define yytable_value_is_error(Yytable_value) \
03032   (!!((Yytable_value) == (-574)))
03033 
03034 static const yytype_int16 yycheck[] =
03035 {
03036        2,    55,   340,    28,     2,   454,     4,    52,   593,    16,
03037       17,   335,   307,    20,   307,     8,   547,   213,    16,    17,
03038        8,   566,    20,    27,    53,    29,    84,    22,     8,    87,
03039      546,    87,     4,    22,   619,    28,    49,    91,   252,    76,
03040       28,     2,   256,     4,   404,   357,     1,    65,    28,    51,
03041       52,    49,    50,   749,   450,    53,   746,    13,   334,   627,
03042      336,    53,   680,    25,    62,   762,   684,   454,    13,    16,
03043       17,    65,    26,    20,   396,    55,   400,    26,    76,    25,
03044      440,     0,   404,    27,    76,    83,    84,   576,   577,    87,
03045       88,    89,    90,    87,   490,    29,    88,    89,    90,    13,
03046      242,    25,   378,   379,    51,   851,   828,    85,    76,   694,
03047      136,    91,    87,    16,    17,   110,   147,    20,    85,   568,
03048      705,   110,   146,   399,    25,   401,    85,   653,   452,    61,
03049       87,    16,    17,    62,   109,    20,   276,    25,   278,    56,
03050      280,    13,   742,    37,    38,    87,   114,   109,    51,    52,
03051      195,   427,   109,   198,   199,   826,   701,    28,   113,   849,
03052      138,   139,   304,   763,   709,   140,    25,   109,   736,   737,
03053       25,    13,   139,   107,   106,   146,    13,   453,   140,   138,
03054      139,   143,   136,   632,   140,   147,   109,   136,   244,   145,
03055      145,   147,   147,   142,   140,   941,   892,   142,   140,   197,
03056      145,   145,   147,   147,   653,   207,   896,   904,   930,   140,
03057      217,   213,   219,   220,    25,   886,   140,   413,   220,   217,
03058      746,   219,   220,   749,   261,   223,   244,   225,   552,   242,
03059      719,   145,   230,   147,    50,   293,   294,   295,   296,   140,
03060      564,   601,   142,   241,   242,   632,   235,   147,   109,   238,
03061      244,   563,   140,   147,   258,   873,    99,   302,   826,   708,
03062      828,   932,   307,   261,    25,   661,    87,    83,    84,   261,
03063      217,    87,   219,   145,   140,   147,   305,   553,   600,   601,
03064      241,   140,    25,   341,   342,   140,    25,   343,   959,   565,
03065      806,   304,    85,    87,   292,   293,   294,   295,   296,   297,
03066      298,   299,    85,   145,   302,   147,   304,   305,   145,   307,
03067      147,    59,    60,   305,   217,   109,   219,    26,   886,   887,
03068      292,   708,   109,   849,   142,   851,    49,   467,   335,   140,
03069      875,   292,   217,   335,   219,    56,   297,   335,   145,   337,
03070      147,    87,   873,   341,   342,   138,   139,   336,    88,   343,
03071      395,   396,   690,   140,   334,   302,   139,    26,   356,   404,
03072      307,   140,   930,   109,   932,   359,   892,    85,   147,   662,
03073      109,    85,   109,   302,    61,    26,    85,   140,   307,   140,
03074       15,   142,    17,   928,   679,    87,   384,   385,   973,    85,
03075       85,   959,   437,   400,   590,   440,   421,   140,   400,   142,
03076      614,   140,   400,    85,   143,   140,    85,   223,   147,   225,
03077      412,   413,   401,   450,   142,   941,    85,   104,   105,   399,
03078      138,   139,   424,   136,   142,   139,   424,   136,   421,   138,
03079      139,   880,    85,   421,    85,   433,    85,   142,   427,   484,
03080      140,   421,   138,   139,   139,   452,   426,   147,    85,   142,
03081      452,    85,   450,   490,   452,   384,   385,   139,   450,   146,
03082      139,    85,   822,   424,   453,    68,    85,   136,    85,   138,
03083      139,   451,   433,   142,   197,    87,    85,   293,   294,   295,
03084      296,   483,   298,   299,    68,   136,   139,   138,   139,   138,
03085      139,   142,   490,   396,    85,    37,    38,   109,   490,   668,
03086      822,   223,   139,   548,   138,   139,   675,   230,   109,    52,
03087      514,    54,    55,    56,    57,   139,   119,   120,   121,   242,
03088      139,   138,   139,   861,   246,   341,   342,   143,   532,   867,
03089      139,    26,   728,    52,   437,   530,   538,    56,   540,    85,
03090      356,   530,   587,   538,   542,   552,   544,   138,   139,   538,
03091      552,   545,   546,    56,   552,   600,   601,   564,    85,   584,
03092       59,    60,   564,   144,   553,   559,   564,   137,   566,   567,
03093      106,   551,   574,   575,   576,   577,   565,    87,   615,   574,
03094      575,   304,   140,   563,   106,   574,   575,    87,   590,   593,
03095       85,   584,   138,   139,    87,    85,   584,   140,    68,   109,
03096       68,   548,    14,    15,   584,    85,   604,   609,    85,   109,
03097      140,   138,   139,   658,    17,   619,   109,   615,    56,   608,
03098      609,   574,   575,   615,   661,   145,    25,   951,    52,    94,
03099       54,    55,    56,    57,   679,   143,   638,   146,   640,   697,
03100      642,   136,   700,   138,   139,   137,   140,   142,   138,   139,
03101       52,   653,    54,    55,    56,    57,   654,   711,   138,   139,
03102       10,   138,   139,   661,   662,    89,    61,   665,   666,   661,
03103       65,    95,    96,   671,   672,   109,   952,   679,   680,   140,
03104      682,   140,   684,   140,   406,   140,   140,    89,   410,   734,
03105      694,   140,   116,   415,    96,   119,     8,   600,    13,   697,
03106       87,   705,   700,   701,   698,    61,    87,   137,   430,   104,
03107      105,   709,   109,   435,   116,    54,   710,   719,   716,   717,
03108      140,   145,   109,   140,    63,    64,   728,   772,   109,   140,
03109       68,   711,   679,   662,    87,    52,   665,   666,   796,    52,
03110      742,   111,   671,   672,   140,   743,   744,    87,   104,   105,
03111      106,   567,   144,   140,   549,    15,   109,   755,   803,   140,
03112        2,   763,     4,   765,    87,   767,   768,   489,    52,   109,
03113       54,    55,    56,    57,    16,    17,   140,   822,    20,   117,
03114      118,   119,   120,   121,   145,   783,   109,   140,   604,   791,
03115      109,   140,   794,   114,   140,   793,   140,   140,   796,    10,
03116      140,    88,   800,   801,   140,     9,   804,    49,    50,    10,
03117      137,   140,   806,    10,   808,    61,   140,   140,   140,   542,
03118       62,   544,   820,   137,   140,   114,    52,   137,    54,    55,
03119       56,    57,   834,   835,   140,   837,    68,   839,   840,   140,
03120      140,    83,    84,   137,   842,    87,    56,   140,   140,    68,
03121      842,    83,    84,    56,   783,   140,   140,   140,   104,   105,
03122      106,   140,   860,    89,    83,    84,   864,   140,   860,    95,
03123       96,   873,   142,   142,    61,   140,   424,   875,    90,    88,
03124       61,   697,   954,   736,   700,   117,   118,   119,   120,   121,
03125      116,    93,   904,   119,   689,   114,   115,   116,   117,   118,
03126      119,   120,   121,   953,   906,   907,   908,    96,   910,   911,
03127      640,   706,   642,    57,    91,   880,   142,   104,   105,   106,
03128      918,   849,   920,   104,   105,   106,   653,   746,   926,    -1,
03129      928,   654,   934,   935,   936,   937,    52,    -1,    54,    55,
03130       56,    57,    -1,    -1,   951,    -1,    -1,    54,    55,   951,
03131       57,   953,   954,   951,    -1,   197,    63,    64,    -1,   939,
03132       -1,    -1,    -1,   952,    -1,   967,   968,   969,   970,   973,
03133      950,    -1,    -1,    89,    -1,   217,    -1,   219,   220,   981,
03134      796,   223,    -1,   225,    -1,   707,    -1,   989,   230,    -1,
03135       -1,    -1,    -1,   716,   717,    68,    -1,    -1,    -1,   241,
03136      242,    -1,   797,    -1,   799,    -1,    -1,   729,    -1,    -1,
03137       83,    84,    -1,    -1,   809,    -1,    -1,    -1,   740,   814,
03138      743,   744,   749,    -1,    52,   752,    54,    55,    56,    57,
03139       -1,    -1,   755,    -1,    -1,   765,    -1,   767,   768,    -1,
03140       -1,    -1,    -1,   116,   117,   118,   119,   120,   121,    -1,
03141      292,   293,   294,   295,   296,   297,   298,   299,    -1,    -1,
03142      302,    89,   304,    -1,    -1,   307,    -1,    95,    -1,    52,
03143      793,    54,    55,    56,    57,   870,   871,   800,   801,    -1,
03144       -1,   804,    16,    17,    -1,    -1,    20,    -1,    -1,    -1,
03145       -1,   813,    -1,   335,    -1,   337,    -1,   820,    -1,   341,
03146      342,    -1,    -1,   825,   834,   835,    -1,   837,   830,   839,
03147      840,    -1,    46,    47,   356,    -1,    -1,    51,    52,    -1,
03148       -1,    -1,    -1,    -1,   851,    -1,   853,    -1,    62,    63,
03149       -1,    52,   927,    54,    55,    56,    57,    -1,    -1,    -1,
03150       -1,   864,   384,   385,    40,    41,    42,    43,    44,    -1,
03151       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   400,    -1,
03152      955,    -1,   957,    -1,    -1,   892,    -1,   894,    89,    -1,
03153       -1,   898,    -1,    -1,    95,    -1,   906,   907,   908,    -1,
03154      910,   911,   424,    52,    -1,    54,    55,    56,    57,    -1,
03155       -1,   433,    -1,    -1,    -1,   918,    -1,   920,    -1,    -1,
03156       -1,    -1,    -1,   926,   934,   935,   936,   937,    -1,    -1,
03157      452,    -1,    -1,    -1,   941,    -1,   943,    -1,    -1,   946,
03158       89,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
03159       -1,    -1,    -1,    -1,   961,    -1,    -1,   967,   968,   969,
03160      970,    -1,    -1,    -1,    -1,    -1,    -1,   116,    -1,    -1,
03161      119,   981,    -1,    -1,    -1,    -1,   983,    -1,    -1,   989,
03162       -1,   195,    -1,    -1,   198,   199,   200,    -1,    -1,    -1,
03163        2,    -1,     4,   142,    -1,    52,    -1,    54,    55,    56,
03164       57,    -1,    -1,   217,    -1,   219,   220,    -1,    -1,    -1,
03165       -1,     2,    -1,     4,    -1,    -1,    -1,    -1,    -1,    -1,
03166      542,    -1,   544,    52,    -1,    54,    55,    56,    57,    -1,
03167      552,    -1,    89,    -1,    -1,    -1,    -1,    49,    95,    96,
03168       -1,    53,   564,    -1,   566,   567,    -1,    -1,    -1,    -1,
03169       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    49,   116,
03170       89,    -1,   119,    -1,    76,    -1,    95,    96,    -1,    -1,
03171       -1,    -1,    -1,    -1,    -1,    -1,    88,    89,    90,    91,
03172       -1,    -1,   604,    -1,    -1,    -1,    -1,   116,   302,    -1,
03173      119,    -1,    -1,   307,   308,   309,   310,   311,   312,   313,
03174      314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
03175      324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
03176       -1,   335,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03177       -1,    -1,   654,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03178      662,    -1,    -1,   665,   666,    -1,    -1,    -1,    -1,   671,
03179      672,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03180       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    -1,
03181      384,   385,    -1,    -1,    -1,   697,    -1,    -1,   700,   701,
03182      394,   395,   396,    -1,    -1,   197,   400,   709,   402,   403,
03183      404,    -1,    -1,    -1,   716,   717,   112,   113,   114,   115,
03184      116,   117,   118,   119,   120,   121,   197,    -1,    -1,   423,
03185       -1,    -1,    -1,    -1,   428,    -1,    -1,    -1,   230,    -1,
03186       -1,   743,   744,   437,    -1,    -1,   440,    -1,    -1,   241,
03187      242,    -1,    -1,   755,    -1,    -1,    -1,    -1,   452,   230,
03188       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   261,
03189      241,   242,    -1,    -1,    -1,    -1,    -1,    -1,   472,   473,
03190       -1,   783,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03191      484,   793,    -1,    -1,   796,    -1,    -1,    -1,   800,   801,
03192      292,    -1,   804,    -1,    -1,   297,    -1,    -1,    -1,    -1,
03193       -1,    -1,   304,   305,    -1,    -1,    -1,     2,   820,     4,
03194       -1,   292,    -1,    -1,    -1,    -1,   297,    -1,    -1,    -1,
03195       -1,    -1,    -1,   304,    -1,    -1,    -1,    -1,    -1,    -1,
03196       -1,    -1,    -1,    -1,    -1,   337,    -1,     2,    -1,     4,
03197       -1,    -1,    -1,    -1,   548,    -1,    -1,    -1,   552,    -1,
03198       -1,    -1,   864,    -1,    49,     2,   337,     4,    53,    -1,
03199      564,    -1,    -1,   875,    -1,    -1,    -1,    -1,    -1,    -1,
03200       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03201       -1,    76,    -1,   587,    49,    -1,    -1,    -1,    53,    -1,
03202       -1,    -1,    -1,    88,    89,    90,   600,   601,    -1,    -1,
03203       -1,    -1,    49,    -1,    -1,    -1,   918,    -1,   920,    -1,
03204       -1,    76,    -1,    -1,   926,    -1,   928,    -1,    -1,    -1,
03205       -1,    -1,   424,    88,    89,    90,    91,    -1,    -1,    -1,
03206       -1,   433,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   951,
03207       -1,    88,    -1,   424,    -1,    -1,    -1,    -1,   450,    -1,
03208       -1,    -1,   433,    -1,   658,    -1,    -1,    -1,   662,   663,
03209       -1,   665,   666,    -1,    -1,    -1,    -1,   671,   672,     0,
03210       -1,    -1,    -1,    -1,    -1,   679,    -1,     8,     9,    10,
03211       -1,    -1,    13,    14,    15,    -1,    17,    -1,   490,    -1,
03212       -1,    -1,    -1,    -1,    -1,    -1,    27,    -1,    -1,    -1,
03213       -1,    -1,   197,    -1,    -1,    -1,    37,    38,    -1,    40,
03214       41,    42,    43,    44,   718,    -1,    -1,    -1,    -1,   723,
03215      724,    -1,   726,   727,    -1,    -1,    -1,    -1,    -1,    -1,
03216      734,    -1,   197,    -1,    -1,   230,    -1,    -1,    -1,    -1,
03217      542,    -1,   544,    -1,    -1,    -1,   241,   242,    -1,    -1,
03218      197,    -1,    -1,    -1,    85,    -1,    -1,    -1,    -1,    -1,
03219       -1,   542,    -1,   544,   566,   230,   261,    -1,   772,    -1,
03220       -1,    -1,   776,    -1,    -1,    -1,   241,   242,    -1,   783,
03221       -1,    -1,    -1,   230,    -1,   566,    -1,    -1,    -1,    -1,
03222       -1,    -1,    -1,    -1,   241,   242,   261,   292,    -1,   803,
03223       -1,    -1,   297,    -1,    -1,    -1,   137,    -1,   139,   304,
03224      305,   142,   143,   615,   145,    -1,   147,   821,   822,    -1,
03225       -1,    -1,    -1,    -1,    -1,    -1,    -1,   292,    -1,    -1,
03226       -1,    -1,   297,    -1,    -1,    -1,    -1,    -1,    -1,   304,
03227      305,    -1,   337,    -1,    -1,   292,    -1,    -1,    -1,    -1,
03228      297,    -1,   654,    -1,    -1,    -1,    -1,   304,    -1,   661,
03229      307,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03230       -1,    -1,   337,   654,    -1,    -1,    -1,    -1,    -1,    -1,
03231       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03232      337,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   701,
03233       -1,    -1,    -1,    -1,    -1,    -1,    -1,   709,    -1,    -1,
03234       -1,    -1,    -1,    -1,   716,   717,    -1,    -1,    -1,    -1,
03235      701,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   709,   424,
03236       -1,    -1,    -1,    -1,    -1,   716,   717,    -1,   433,    -1,
03237       -1,   743,   744,    -1,    -1,    -1,    -1,   951,    -1,    -1,
03238       -1,    -1,    -1,   755,    -1,   450,    -1,    -1,    -1,   424,
03239       -1,    -1,   743,   744,    -1,    -1,    -1,    -1,   433,    -1,
03240       -1,    -1,    -1,    -1,   755,    -1,    -1,   424,    -1,    -1,
03241       -1,    -1,    -1,    -1,    -1,   450,   433,    -1,    -1,    -1,
03242       -1,   793,    -1,    -1,    -1,   490,    -1,    -1,   800,   801,
03243       -1,    -1,   804,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03244       -1,    -1,   793,    -1,    -1,    -1,    -1,    -1,   820,   800,
03245      801,    -1,    -1,   804,    -1,   490,    -1,    -1,    -1,    -1,
03246       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   820,
03247      842,    -1,    -1,    -1,    -1,    -1,    -1,   542,    -1,   544,
03248       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   860,    -1,
03249       -1,    -1,   864,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03250       -1,   566,    -1,   875,    -1,    -1,    -1,   542,    -1,   544,
03251       -1,    -1,    -1,   864,    -1,    -1,    -1,    -1,    -1,    -1,
03252       -1,    -1,    -1,    -1,   875,   542,    -1,   544,    -1,    -1,
03253       -1,   566,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03254       -1,    -1,    -1,    -1,    -1,    -1,   918,    -1,   920,   566,
03255      615,    -1,    -1,    -1,   926,    -1,   928,    -1,    -1,    -1,
03256       -1,    -1,    -1,    -1,    -1,    -1,    -1,   918,    -1,   920,
03257       -1,    -1,    -1,    -1,    -1,   926,    -1,   928,    -1,    -1,
03258      615,   646,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   654,
03259       -1,    -1,    -1,    -1,    -1,    -1,   661,    -1,    -1,    -1,
03260       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03261       -1,    -1,    68,    69,    70,    71,    72,    73,    74,   654,
03262       -1,    77,    78,    -1,    -1,    -1,   661,    83,    84,    -1,
03263       -1,    -1,    -1,    -1,    -1,    -1,   701,   654,    -1,    -1,
03264       -1,    -1,    -1,    -1,   709,   662,    -1,    -1,    -1,    -1,
03265       -1,   716,   717,    -1,    -1,    -1,   112,   113,   114,   115,
03266      116,   117,   118,   119,   120,   121,   701,    -1,    -1,    -1,
03267       -1,    -1,    -1,    -1,   709,    -1,    -1,    -1,   743,   744,
03268       -1,   716,   717,    -1,   701,    -1,    -1,    -1,    -1,    -1,
03269      755,    -1,   709,    -1,    -1,    -1,    -1,    -1,    -1,   716,
03270      717,    68,    69,    70,    71,    72,    73,    74,   743,   744,
03271       77,    78,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
03272      755,    -1,    -1,    -1,    -1,    -1,   743,   744,   793,    -1,
03273       -1,    -1,    -1,    -1,    -1,   800,   801,    -1,   755,   804,
03274       -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,
03275      117,   118,   119,   120,   121,   820,    -1,    -1,   793,    -1,
03276       -1,    -1,    -1,    -1,    -1,   800,   801,    -1,    -1,   804,
03277       -1,    -1,    -1,    -1,    -1,    -1,   793,   842,    -1,    -1,
03278       -1,    -1,    -1,   800,   801,   820,    -1,   804,    -1,    -1,
03279       -1,    -1,    -1,    -1,    -1,   860,    -1,    -1,    -1,   864,
03280       -1,    -1,    -1,   820,    -1,    -1,    -1,   842,    -1,    -1,
03281      875,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03282       -1,    -1,    -1,    -1,    -1,   860,    -1,    -1,    -1,   864,
03283       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03284      875,    -1,    -1,   860,    -1,    -1,    -1,   864,    -1,    -1,
03285       -1,    -1,    -1,   918,    -1,   920,    -1,    -1,   875,    -1,
03286       -1,   926,    -1,   928,    -1,    -1,    -1,    -1,    -1,    -1,
03287       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03288       -1,    -1,    -1,   918,    -1,   920,    -1,    -1,    -1,    -1,
03289       -1,   926,    -1,   928,    -1,    -1,    -1,    -1,    -1,    -1,
03290       -1,   918,    -1,   920,    -1,    -1,    -1,    -1,    -1,   926,
03291       -1,   928,     0,     1,    -1,     3,     4,     5,     6,     7,
03292       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,
03293       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03294       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03295       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03296       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03297       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03298       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03299       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03300       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03301       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03302       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03303       -1,    -1,    -1,     0,   122,   123,   124,    -1,    -1,    -1,
03304       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03305       17,    -1,    -1,    -1,    -1,    -1,    -1,   145,    -1,   147,
03306       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03307       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03308       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03309       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03310       84,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03311       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03312       87,    88,    -1,    -1,    -1,    -1,   110,    94,   112,   113,
03313      114,   115,   116,   117,   118,   119,   120,   121,    -1,    -1,
03314      107,    -1,   109,   110,   111,   112,   113,   114,   115,   116,
03315      117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,
03316       -1,    -1,    -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,
03317      137,   138,   139,   140,     0,    -1,   143,   144,   145,    -1,
03318      147,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03319       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03320       26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03321       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03322       -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,
03323       73,    74,    75,    76,    77,    78,    79,    80,    -1,    -1,
03324       83,    84,    68,    69,    70,    71,    72,    73,    74,    75,
03325       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03326       -1,    -1,    88,    -1,    -1,    -1,    -1,   110,    94,   112,
03327      113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
03328       -1,    -1,    -1,    -1,   110,    -1,   112,   113,   114,   115,
03329      116,   117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,
03330       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03331      136,   137,   138,   139,   140,     0,   142,   143,   144,   145,
03332       -1,   147,    -1,     8,     9,    10,    -1,    -1,    13,    14,
03333       15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03334       -1,    -1,    27,    28,    29,    -1,    -1,    -1,    -1,    -1,
03335       -1,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03336       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03337       72,    73,    74,    75,    -1,    77,    78,    -1,    -1,    -1,
03338       -1,    83,    84,    68,    69,    70,    71,    72,    73,    74,
03339       75,    76,    77,    78,    79,    80,    -1,    -1,    83,    84,
03340       85,    -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,
03341      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03342       -1,    -1,   107,    -1,    -1,   110,   111,   112,   113,   114,
03343      115,   116,   117,   118,   119,   120,   121,    -1,    -1,    -1,
03344       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03345       -1,    -1,   137,   138,   139,   140,     0,    -1,   143,   144,
03346      145,    -1,   147,    -1,     8,     9,    10,    -1,    -1,    13,
03347       14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,
03348       -1,    -1,    26,    27,    28,    -1,    -1,    -1,    -1,    -1,
03349       -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03350       44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03351       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03352       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03353       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03354       84,    85,    -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,
03355       94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03356       -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,   112,   113,
03357      114,   115,   116,   117,   118,   119,   120,   121,    -1,    -1,
03358       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03359       -1,    -1,   136,   137,   138,   139,   140,     0,   142,   143,
03360      144,   145,    -1,   147,    -1,     8,     9,    10,    -1,    -1,
03361       13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,
03362       -1,    -1,    -1,    -1,    27,    28,    -1,    -1,    -1,    -1,
03363       -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,
03364       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03365       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03366       -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,
03367       73,    74,    75,    76,    77,    78,    79,    80,    -1,    -1,
03368       83,    84,    85,    -1,    -1,    88,    -1,    -1,    -1,    -1,
03369       -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03370       -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,   112,
03371      113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
03372       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03373       -1,    -1,    -1,    -1,   137,   138,   139,   140,     0,   142,
03374      143,   144,   145,    -1,   147,    -1,     8,     9,    10,    -1,
03375       -1,    -1,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03376       -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,
03377       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03378       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03379       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03380       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03381       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03382       -1,    83,    84,    85,     0,    87,    -1,    -1,    -1,    -1,
03383       -1,    -1,     8,     9,    10,    -1,    -1,    -1,    14,    15,
03384       -1,    17,    -1,    -1,    -1,    -1,    -1,   109,   110,    -1,
03385      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03386       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03387       -1,    -1,    -1,    -1,   136,   137,   138,   139,   140,    -1,
03388       -1,   143,    -1,   145,    -1,   147,    -1,    -1,    -1,    -1,
03389       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03390       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03391       -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03392       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03393       -1,    -1,    -1,   109,   110,    -1,   112,   113,   114,   115,
03394      116,   117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,
03395       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03396       -1,   137,   138,   139,   140,    -1,    -1,   143,    -1,   145,
03397        1,   147,     3,     4,     5,     6,     7,     8,     9,    10,
03398       11,    12,    -1,    -1,    15,    16,    -1,    18,    19,    20,
03399       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03400       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03401       -1,    -1,    -1,    -1,    45,    46,    -1,    48,    49,    50,
03402       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03403       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03404       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03405       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03406       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03407      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03408       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03409       -1,   122,   123,   124,    -1,    -1,    -1,    -1,    -1,    -1,
03410       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03411       -1,    -1,    -1,    -1,   145,     1,   147,     3,     4,     5,
03412        6,     7,    -1,    -1,    10,    11,    12,    -1,    14,    15,
03413       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03414       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03415       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03416       46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
03417       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03418       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03419       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03420       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03421       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03422       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03423       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03424       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03425       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,
03426        1,   147,     3,     4,     5,     6,     7,    -1,    -1,    10,
03427       11,    12,    -1,    -1,    15,    16,    17,    18,    19,    20,
03428       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03429       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03430       -1,    -1,    -1,    -1,    45,    46,    -1,    48,    49,    50,
03431       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03432       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03433       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03434       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03435       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03436      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03437       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03438       -1,   122,   123,   124,    -1,    -1,    -1,    -1,    -1,    -1,
03439        1,    -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,
03440       11,    12,    -1,    -1,   145,    16,   147,    18,    19,    20,
03441       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03442       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03443       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
03444       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03445       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03446       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03447       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03448       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03449      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03450       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03451       -1,   122,   123,   124,    -1,    -1,    -1,    -1,    -1,    -1,
03452       -1,    -1,    -1,    -1,    -1,    -1,   137,    -1,    -1,    -1,
03453       -1,    -1,    -1,    -1,   145,     1,   147,     3,     4,     5,
03454        6,     7,    -1,    -1,    10,    11,    12,    -1,    -1,    15,
03455       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03456       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03457       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03458       46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
03459       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03460       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03461       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03462       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03463       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03464       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03465       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03466       -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,     5,
03467        6,     7,    -1,     9,    10,    11,    12,    -1,    -1,   145,
03468       16,   147,    18,    19,    20,    21,    22,    23,    24,    -1,
03469       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03470       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03471       46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
03472       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03473       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03474       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03475       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03476       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03477       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03478       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03479       -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,     5,
03480        6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,   145,
03481       16,   147,    18,    19,    20,    21,    22,    23,    24,    -1,
03482       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03483       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03484       46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
03485       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03486       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03487       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03488       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03489       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03490       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03491       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03492       -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,     5,
03493        6,     7,    -1,    -1,    -1,    11,    12,   143,    -1,   145,
03494       16,   147,    18,    19,    20,    21,    22,    23,    24,    -1,
03495       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03496       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03497       46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
03498       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03499       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03500       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03501       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03502       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03503       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03504       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03505       -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,     5,
03506        6,     7,    -1,    -1,    -1,    11,    12,   143,    -1,   145,
03507       16,   147,    18,    19,    20,    21,    22,    23,    24,    -1,
03508       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03509       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03510       46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
03511       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03512       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03513       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03514       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03515       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03516       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03517       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03518       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03519       -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,
03520        1,   147,     3,     4,     5,     6,     7,    -1,    -1,    10,
03521       11,    12,    -1,    -1,    -1,    16,    -1,    18,    19,    20,
03522       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03523       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03524       -1,    -1,    -1,    -1,    45,    46,    -1,    48,    49,    50,
03525       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03526       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03527       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03528       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03529       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03530      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03531       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03532       -1,   122,   123,   124,    -1,    -1,    -1,    -1,    -1,    -1,
03533       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03534       11,    12,    -1,    -1,   145,    16,   147,    18,    19,    20,
03535       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03536       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03537       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03538       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03539       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03540       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03541       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03542       -1,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
03543      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03544       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03545       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03546       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03547       32,    33,    34,    35,    36,    -1,   147,    39,    -1,    -1,
03548       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03549       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03550       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03551       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03552       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03553       92,    93,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03554      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03555       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03556      122,   123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03557       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03558       12,    -1,    -1,   145,    16,   147,    18,    19,    20,    21,
03559       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03560       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03561       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03562       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03563       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03564       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03565       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03566       92,    93,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03567      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03568        3,     4,     5,     6,     7,    -1,    -1,    -1,    11,    12,
03569      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03570       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03571       33,    34,    35,    36,    -1,   147,    39,    -1,    -1,    -1,
03572       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03573       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03574       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03575       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03576       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03577       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03578      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03579       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03580      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03581        5,     6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,
03582       -1,    16,   145,    18,    19,    20,    21,    22,    23,    24,
03583       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03584       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03585       45,    46,    -1,    48,    49,    50,    51,    52,    53,    54,
03586       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03587       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03588       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03589       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03590       95,    -1,    97,    98,    99,   100,   101,   102,   103,    -1,
03591       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03592       -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
03593       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03594       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03595      145,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03596       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03597       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03598       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03599       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03600       52,    53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,
03601       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03602       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03603       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03604       -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,
03605       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03606      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03607       -1,   123,   124,    -1,    -1,    -1,    -1,    -1,     3,     4,
03608        5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,   141,
03609      142,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03610       -1,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03611       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03612       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03613       55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
03614       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03615       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03616       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03617       95,    96,    97,    98,    99,   100,   101,   102,   103,    -1,
03618       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03619       -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
03620       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03621       -1,   136,    -1,    11,    12,    -1,    -1,   142,    16,    -1,
03622       18,    19,    20,    21,    22,    23,    24,    -1,    26,    -1,
03623       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03624       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03625       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03626       58,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03627       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03628       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03629       -1,    89,    90,    -1,    92,    93,    -1,    95,    96,    97,
03630       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03631       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03632       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03633       -1,    -1,     3,     4,     5,    -1,     7,    -1,   136,    -1,
03634       11,    12,    -1,    -1,   142,    16,    -1,    18,    19,    20,
03635       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03636       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03637       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03638       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03639       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03640       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03641       -1,    -1,    -1,    -1,    -1,    86,    87,    -1,    89,    90,
03642       -1,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
03643      101,   102,   103,    -1,    -1,    -1,    -1,    -1,   109,    -1,
03644       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03645        7,   122,   123,   124,    11,    12,    -1,    -1,    -1,    16,
03646       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03647       -1,   142,    -1,    30,    31,    32,    33,    34,    35,    36,
03648       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03649       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03650       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03651       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03652       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03653       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    96,
03654       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03655       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03656        3,     4,     5,    -1,     7,   122,   123,   124,    11,    12,
03657       -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,    22,
03658       23,    24,    -1,    -1,    -1,   142,    -1,    30,    31,    32,
03659       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03660       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03661       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03662       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03663       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03664       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03665       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03666      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03667       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03668      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03669       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   142,
03670        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
03671       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
03672       23,    24,    25,    26,    -1,    -1,    -1,    30,    31,    32,
03673       33,    34,    35,    36,    37,    38,    39,    -1,    -1,    -1,
03674       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03675       53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,
03676       -1,    -1,    -1,    66,    67,    68,    69,    70,    71,    72,
03677       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
03678       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03679       -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03680       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,
03681      113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
03682      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03683       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     3,
03684        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03685       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03686       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03687       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03688       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03689       54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03690       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
03691       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03692       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03693       -1,    95,    -1,    -1,    98,    -1,    -1,    -1,    -1,    -1,
03694       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,
03695      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03696      124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03697       -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,
03698        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03699       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03700       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03701       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03702       45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
03703       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03704       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03705       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03706       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03707       95,    -1,    -1,    98,    -1,    -1,    -1,    -1,    -1,    -1,
03708       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
03709      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
03710       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03711       -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,     5,
03712        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03713       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03714       26,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03715       36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    45,
03716       46,    47,    48,    49,    50,    51,    52,    53,    -1,    -1,
03717       56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03718       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
03719       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
03720       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
03721       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03722       -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,
03723      116,   117,   118,   119,   120,   121,    -1,   123,   124,    -1,
03724       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03725       12,    -1,    -1,    -1,    16,   141,    18,    19,    20,    21,
03726       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03727       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03728       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03729       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03730       62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03731       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03732       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03733       92,    93,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03734      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03735       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03736      122,    11,    12,    -1,    -1,    -1,    16,    -1,    18,    19,
03737       20,    21,    22,    23,    24,    -1,    -1,    -1,   140,    -1,
03738       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03739       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03740       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03741       60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,
03742       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03743       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03744       90,    -1,    92,    93,    -1,    -1,    -1,    97,    98,    99,
03745      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03746       -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
03747       -1,    -1,   122,    11,    12,    -1,    -1,    -1,    16,    -1,
03748       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03749      140,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03750       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03751       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03752       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03753       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03754       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03755       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03756       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03757       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03758       -1,    -1,    11,    12,   122,   123,   124,    16,    -1,    18,
03759       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03760       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03761       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,    48,
03762       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03763       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03764       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03765       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03766       89,    90,    -1,    92,    93,    -1,    95,    -1,    97,    98,
03767       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
03768       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03769       -1,    11,    12,   122,   123,   124,    16,    -1,    18,    19,
03770       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03771       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03772       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03773       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03774       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03775       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03776       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03777       90,    -1,    92,    93,    -1,    95,    96,    97,    98,    99,
03778      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03779       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03780       11,    12,   122,   123,   124,    16,    -1,    18,    19,    20,
03781       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03782       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03783       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03784       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03785       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03786       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03787       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03788       -1,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
03789      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03790       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03791       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03792       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03793       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03794       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03795       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03796       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03797       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03798       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03799       92,    93,    -1,    95,    -1,    97,    98,    99,   100,   101,
03800      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03801        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03802      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03803       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03804       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03805       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03806       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03807       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03808       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03809       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03810       93,    -1,    -1,    96,    97,    98,    99,   100,   101,   102,
03811      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03812        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03813      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03814       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03815       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03816       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03817       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03818       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03819       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03820       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03821       -1,    95,    -1,    97,    98,    99,   100,   101,   102,   103,
03822       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03823        5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03824      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03825       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03826       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03827       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03828       55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
03829       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03830       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03831       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03832       -1,    -1,    97,    98,    99,   100,   101,   102,   103,    -1,
03833       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03834       -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,   124,
03835       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03836       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03837       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03838       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03839       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03840       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03841       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03842       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03843       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03844       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03845        7,    -1,    -1,    -1,    11,    12,   122,   123,   124,    16,
03846       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03847       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03848       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03849       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03850       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03851       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03852       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03853       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03854       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03855       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03856       -1,    -1,    -1,    11,    12,   122,   123,   124,    16,    -1,
03857       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03858       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03859       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03860       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03861       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03862       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03863       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03864       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03865       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03866       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03867       -1,    -1,    11,    12,   122,   123,   124,    16,    -1,    18,
03868       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03869       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03870       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03871       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03872       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03873       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03874       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03875       89,    90,    -1,    92,    93,    -1,    95,    -1,    97,    98,
03876       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
03877       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03878       -1,    11,    12,   122,   123,   124,    16,    -1,    18,    19,
03879       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03880       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03881       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03882       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03883       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03884       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03885       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03886       90,    -1,    92,    93,    -1,    95,    -1,    97,    98,    99,
03887      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03888       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03889       11,    12,   122,   123,   124,    16,    -1,    18,    19,    20,
03890       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03891       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03892       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03893       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03894       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03895       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03896       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03897       -1,    92,    93,    -1,    -1,    -1,    97,    98,    99,   100,
03898      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03899       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03900       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03901       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03902       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03903       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03904       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03905       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03906       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03907       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03908       92,    93,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03909      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03910        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03911      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03912       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03913       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03914       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03915       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03916       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03917       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03918       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03919       93,    -1,    -1,    -1,    97,    98,    99,   100,   101,   102,
03920      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03921        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03922      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03923       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03924       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03925       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03926       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03927       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03928       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03929       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03930       -1,    95,    -1,    97,    98,    99,   100,   101,   102,   103,
03931       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03932       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   122,    18,
03933       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03934       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03935       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03936       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03937       59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,
03938       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03939       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03940       89,    90,    -1,    92,    93,    -1,    95,    -1,    97,    98,
03941       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,     3,
03942        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03943       -1,    -1,    16,   122,    18,    19,    20,    21,    22,    23,
03944       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03945       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03946       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03947       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03948       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03949       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    83,
03950       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03951       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03952       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03953       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   122,    18,
03954       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03955       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03956       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03957       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03958       59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,
03959       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03960       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03961       89,    90,    -1,    92,    93,    -1,    -1,    -1,    97,    98,
03962       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,     3,
03963        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03964       -1,    -1,    16,   122,    18,    19,    20,    21,    22,    23,
03965       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03966       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03967       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03968       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03969       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03970       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03971       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03972       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03973       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03974       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   122,    18,
03975       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03976       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03977       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03978       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03979       59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,
03980       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03981       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03982       89,    90,    -1,    92,    93,    -1,    -1,    -1,    97,    98,
03983       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,     3,
03984        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03985       -1,    -1,    16,   122,    18,    19,    20,    21,    22,    23,
03986       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03987       34,    35,    36,    -1,    -1,    39,    -1,    44,    -1,    -1,
03988       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03989       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03990       64,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03991       77,    78,    79,    80,    -1,    -1,    83,    84,    -1,    -1,
03992       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03993       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03994       -1,    -1,    -1,   110,    -1,   112,   113,   114,   115,   116,
03995      117,   118,   119,   120,   121,    -1,    -1,    -1,   122,    -1,
03996       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
03997       -1,    -1,    -1,   140,    66,    67,    68,    69,    70,    71,
03998       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03999       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04000       -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,
04001       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04002      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
04003       -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,
04004       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,
04005      142,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04006       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04007       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04008       95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04009       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
04010      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
04011       -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,
04012       -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,
04013       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
04014       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
04015       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,
04016       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04017       -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
04018      118,   119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,
04019       -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,
04020       -1,    -1,    -1,   141,   142,    66,    67,    68,    69,    70,
04021       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
04022       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
04023       -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,
04024       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04025       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
04026      121,    -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,
04027       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04028      141,   142,    66,    67,    68,    69,    70,    71,    72,    73,
04029       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
04030       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04031       -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04032       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,
04033      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
04034      124,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,
04035       -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,
04036       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
04037       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
04038       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,
04039       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04040       -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,
04041      117,   118,   119,   120,   121,    -1,   123,   124,    -1,    -1,
04042       -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,
04043       -1,    -1,    -1,    -1,   141,   142,    66,    67,    68,    69,
04044       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
04045       -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,
04046       -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,
04047       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04048       -1,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
04049      120,   121,    -1,   123,   124,    -1,    -1,    -1,    -1,    52,
04050       53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,
04051       -1,   141,   142,    66,    67,    68,    69,    70,    71,    72,
04052       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
04053       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04054       -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04055       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,
04056      113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
04057      123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,
04058       56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,
04059       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
04060       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
04061       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
04062       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04063       -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,
04064      116,   117,   118,   119,   120,   121,    -1,   123,   124,    -1,
04065       -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,
04066       -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,    68,
04067       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
04068       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
04069       -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
04070       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04071       -1,    -1,    -1,   112,   113,   114,   115,   116,   117,   118,
04072      119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,    -1,
04073       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
04074       -1,    -1,   141,   142,    66,    67,    68,    69,    70,    71,
04075       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04076       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04077       -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,
04078       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04079      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
04080       -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,
04081       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,
04082      142,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04083       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04084       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04085       95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04086       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
04087      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
04088       -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,
04089       -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,
04090       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
04091       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
04092       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,
04093       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04094       -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
04095      118,   119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,
04096       -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,
04097       -1,    -1,    -1,   141,   142,    66,    67,    68,    69,    70,
04098       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
04099       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
04100       -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,
04101       -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04102       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
04103      121,    44,   123,   124,    -1,    -1,    68,    69,    70,    71,
04104       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
04105      141,    83,    84,    -1,    -1,    68,    69,    70,    71,    72,
04106       73,    74,    75,    76,    77,    78,    79,    80,    -1,    -1,
04107       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,
04108      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
04109       -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,   112,
04110      113,   114,   115,   116,   117,   118,   119,   120,   121
04111 };
04112 
04113 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04114    symbol of state STATE-NUM.  */
04115 static const yytype_uint16 yystos[] =
04116 {
04117        0,   149,   150,     0,     1,     3,     4,     5,     6,     7,
04118       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04119       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04120       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04121       57,    59,    60,    62,    63,    64,    66,    67,    86,    89,
04122       90,    92,    93,    95,    97,    98,    99,   100,   101,   102,
04123      103,   122,   123,   124,   151,   152,   153,   158,   160,   161,
04124      163,   164,   167,   168,   170,   171,   172,   174,   175,   185,
04125      199,   216,   217,   218,   219,   220,   221,   222,   223,   224,
04126      225,   226,   249,   250,   260,   261,   262,   263,   264,   265,
04127      266,   269,   279,   281,   282,   283,   284,   285,   286,   287,
04128      310,   321,   153,     3,     4,     5,     6,     7,     8,     9,
04129       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
04130       20,    21,    22,    23,    24,    25,    26,    30,    31,    32,
04131       33,    34,    35,    36,    37,    38,    39,    45,    46,    47,
04132       48,    49,    50,    51,    52,    53,    56,    66,    67,    68,
04133       69,    70,    71,    72,    73,    74,    77,    78,    81,    82,
04134       83,    84,    95,   112,   113,   114,   115,   116,   117,   118,
04135      119,   120,   121,   123,   124,   141,   178,   179,   180,   181,
04136      183,   184,   279,   281,    39,    58,    86,    89,    95,    96,
04137      123,   167,   175,   185,   187,   192,   195,   197,   216,   283,
04138      284,   286,   287,   308,   309,   192,   192,   142,   193,   194,
04139      142,   189,   193,   142,   147,   315,    54,   180,   315,   154,
04140      136,    21,    22,    30,    31,    32,   185,   216,   310,   185,
04141       56,     1,    89,   156,   157,   158,   169,   170,   321,   161,
04142      188,   197,   308,   321,   187,   307,   308,   321,    46,    86,
04143      122,   140,   174,   199,   216,   283,   284,   287,   242,   243,
04144       54,    55,    57,   178,   272,   280,   271,   272,   273,   146,
04145      267,   146,   270,    59,    60,   163,   185,   185,   145,   147,
04146      314,   319,   320,    40,    41,    42,    43,    44,    37,    38,
04147       28,   247,   109,   140,    89,    95,   171,   109,    68,    69,
04148       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
04149       80,    83,    84,   110,   112,   113,   114,   115,   116,   117,
04150      118,   119,   120,   121,    85,   138,   139,   200,   161,   162,
04151      162,   203,   205,   162,   314,   320,    86,   168,   175,   216,
04152      232,   283,   284,   287,    52,    56,    83,    86,   176,   177,
04153      216,   283,   284,   287,   177,    33,    34,    35,    36,    49,
04154       50,    51,    52,    56,   142,   178,   285,   305,    85,   139,
04155       26,   136,   251,   263,    87,    87,   189,   193,   251,   140,
04156      187,    56,   187,   187,   109,    88,   140,   196,   321,    85,
04157      138,   139,    87,    87,   140,   196,   192,   315,   316,   192,
04158      191,   192,   197,   308,   321,   161,   316,   161,    54,    63,
04159       64,   159,   142,   186,   136,   156,    85,   139,    87,   158,
04160      169,   143,   314,   320,   316,   201,   144,   140,   147,   318,
04161      140,   318,   137,   318,   315,    56,    59,    60,   171,   173,
04162      140,    85,   138,   139,   244,    61,   104,   105,   106,   274,
04163      106,   274,   106,    65,   274,   106,   106,   268,   274,   106,
04164       61,   106,    68,    68,   145,   153,   162,   162,   162,   162,
04165      158,   161,   161,   248,    95,   163,   187,   197,   198,   169,
04166      140,   174,   140,   160,   163,   175,   185,   187,   198,   185,
04167      185,   185,   185,   185,   185,   185,   185,   185,   185,   185,
04168      185,   185,   185,   185,   185,   185,   185,   185,   185,   185,
04169      185,   185,   185,   185,   185,    52,    53,    56,   183,   189,
04170      311,   312,   191,    52,    53,    56,   183,   189,   311,   155,
04171      156,    13,   228,   319,   228,   162,   162,   314,    17,   254,
04172       56,    85,   138,   139,    25,   161,    52,    56,   176,     1,
04173      113,   288,   319,    85,   138,   139,   212,   306,   213,    85,
04174      139,   313,    52,    56,   311,   311,   253,   252,   163,   185,
04175      163,   185,    94,   165,   182,   185,   187,    95,   187,   195,
04176      308,    52,    56,   191,    52,    56,   309,   316,   143,   316,
04177      140,   140,   316,   180,   202,   185,   151,   137,   311,   311,
04178      185,   316,   158,   316,   308,   140,   173,    52,    56,   191,
04179       52,    56,    52,    54,    55,    56,    57,    89,    95,    96,
04180      116,   119,   142,   245,   291,   292,   293,   294,   295,   296,
04181      299,   300,   301,   302,   303,   276,   275,   146,   274,   146,
04182      185,   185,    76,   114,   237,   238,   321,   187,   140,   316,
04183      173,   140,   109,    44,   315,    87,    87,   189,   193,   315,
04184      317,    87,    87,   189,   190,   193,   321,    10,   227,     8,
04185      256,   321,   156,    13,   156,    27,   229,   319,   229,   254,
04186      197,   227,    52,    56,   191,    52,    56,   207,   210,   319,
04187      289,   209,    52,    56,   176,   191,   155,   161,   142,   290,
04188      291,   214,   190,   193,   190,   193,   237,   237,    44,   166,
04189      180,   187,   196,    87,    87,   317,    87,    87,   308,   161,
04190      137,   318,   171,   317,   109,    52,    89,    95,   233,   234,
04191      235,   293,   291,    29,   107,   246,   140,   304,   321,   140,
04192      304,    52,   140,   304,    52,   277,    54,    55,    57,   278,
04193      287,    52,   145,   236,   239,   295,   297,   298,   301,   303,
04194      321,   156,    95,   187,   173,   185,   111,   163,   185,   163,
04195      185,   165,   144,    87,   163,   185,   163,   185,   165,   187,
04196      198,   257,   321,    15,   231,   321,    14,   230,   231,   231,
04197      204,   206,   227,   140,   228,   317,   162,   319,   162,   155,
04198      317,   227,   316,   291,   155,   319,   178,   156,   156,   185,
04199      237,    87,   140,   316,   187,   235,   140,   293,   140,   316,
04200      239,   156,   156,   294,   299,   301,   303,   295,   296,   301,
04201      295,   156,   109,    52,   240,   241,   292,   239,   114,   140,
04202      304,   140,   304,   140,   304,    10,   187,   185,   163,   185,
04203       88,   258,   321,   156,     9,   259,   321,   162,   227,   227,
04204      156,   156,   187,   156,   229,   211,   319,   227,   316,   227,
04205      215,    10,   137,   156,   316,   234,   140,    95,   233,   316,
04206       10,   137,   140,   304,   140,   304,   140,   304,   140,   304,
04207      304,   137,    86,   216,   140,   114,   298,   301,   295,   297,
04208      301,   295,    86,   175,   216,   283,   284,   287,   228,   156,
04209      228,   227,   227,   231,   254,   255,   208,   155,   290,   137,
04210      140,   234,   140,   293,   295,   301,   295,   295,    56,    85,
04211      241,   140,   304,   140,   304,   304,   140,   304,   304,    56,
04212       85,   138,   139,   156,   156,   156,   227,   155,   234,   140,
04213      304,   140,   304,   304,   304,    52,    56,   295,   301,   295,
04214      295,    52,    56,   191,    52,    56,   256,   230,   227,   227,
04215      234,   295,   304,   140,   304,   304,   304,   317,   304,   295,
04216      304
04217 };
04218 
04219 #define yyerrok         (yyerrstatus = 0)
04220 #define yyclearin       (yychar = YYEMPTY)
04221 #define YYEMPTY         (-2)
04222 #define YYEOF           0
04223 
04224 #define YYACCEPT        goto yyacceptlab
04225 #define YYABORT         goto yyabortlab
04226 #define YYERROR         goto yyerrorlab
04227 
04228 
04229 /* Like YYERROR except do call yyerror.  This remains here temporarily
04230    to ease the transition to the new meaning of YYERROR, for GCC.
04231    Once GCC version 2 has supplanted version 1, this can go.  However,
04232    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04233    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04234    discussed.  */
04235 
04236 #define YYFAIL          goto yyerrlab
04237 #if defined YYFAIL
04238   /* This is here to suppress warnings from the GCC cpp's
04239      -Wunused-macros.  Normally we don't worry about that warning, but
04240      some users do, and we want to make it easy for users to remove
04241      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04242 #endif
04243 
04244 #define YYRECOVERING()  (!!yyerrstatus)
04245 
04246 #define YYBACKUP(Token, Value)                                  \
04247 do                                                              \
04248   if (yychar == YYEMPTY)                                        \
04249     {                                                           \
04250       yychar = (Token);                                         \
04251       yylval = (Value);                                         \
04252       YYPOPSTACK (yylen);                                       \
04253       yystate = *yyssp;                                         \
04254       goto yybackup;                                            \
04255     }                                                           \
04256   else                                                          \
04257     {                                                           \
04258       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04259       YYERROR;                                                  \
04260     }                                                           \
04261 while (YYID (0))
04262 
04263 /* Error token number */
04264 #define YYTERROR        1
04265 #define YYERRCODE       256
04266 
04267 
04268 /* This macro is provided for backward compatibility. */
04269 #ifndef YY_LOCATION_PRINT
04270 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04271 #endif
04272 
04273 
04274 /* YYLEX -- calling `yylex' with the right arguments.  */
04275 #ifdef YYLEX_PARAM
04276 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04277 #else
04278 # define YYLEX yylex (&yylval, parser)
04279 #endif
04280 
04281 /* Enable debugging if requested.  */
04282 #if YYDEBUG
04283 
04284 # ifndef YYFPRINTF
04285 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04286 #  define YYFPRINTF fprintf
04287 # endif
04288 
04289 # define YYDPRINTF(Args)                        \
04290 do {                                            \
04291   if (yydebug)                                  \
04292     YYFPRINTF Args;                             \
04293 } while (YYID (0))
04294 
04295 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04296 do {                                                                      \
04297   if (yydebug)                                                            \
04298     {                                                                     \
04299       YYFPRINTF (stderr, "%s ", Title);                                   \
04300       yy_symbol_print (stderr,                                            \
04301                   Type, Value, parser); \
04302       YYFPRINTF (stderr, "\n");                                           \
04303     }                                                                     \
04304 } while (YYID (0))
04305 
04306 
04307 /*--------------------------------.
04308 | Print this symbol on YYOUTPUT.  |
04309 `--------------------------------*/
04310 
04311 /*ARGSUSED*/
04312 #if (defined __STDC__ || defined __C99__FUNC__ \
04313      || defined __cplusplus || defined _MSC_VER)
04314 static void
04315 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04316 #else
04317 static void
04318 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04319     FILE *yyoutput;
04320     int yytype;
04321     YYSTYPE const * const yyvaluep;
04322     struct parser_params *parser;
04323 #endif
04324 {
04325   FILE *yyo = yyoutput;
04326   YYUSE (yyo);
04327   if (!yyvaluep)
04328     return;
04329   YYUSE (parser);
04330 # ifdef YYPRINT
04331   if (yytype < YYNTOKENS)
04332     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04333 # else
04334   YYUSE (yyoutput);
04335 # endif
04336   YYUSE (yytype);
04337 }
04338 
04339 
04340 /*--------------------------------.
04341 | Print this symbol on YYOUTPUT.  |
04342 `--------------------------------*/
04343 
04344 #if (defined __STDC__ || defined __C99__FUNC__ \
04345      || defined __cplusplus || defined _MSC_VER)
04346 static void
04347 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04348 #else
04349 static void
04350 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04351     FILE *yyoutput;
04352     int yytype;
04353     YYSTYPE const * const yyvaluep;
04354     struct parser_params *parser;
04355 #endif
04356 {
04357   if (yytype < YYNTOKENS)
04358     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04359   else
04360     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04361 
04362   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04363   YYFPRINTF (yyoutput, ")");
04364 }
04365 
04366 /*------------------------------------------------------------------.
04367 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04368 | TOP (included).                                                   |
04369 `------------------------------------------------------------------*/
04370 
04371 #if (defined __STDC__ || defined __C99__FUNC__ \
04372      || defined __cplusplus || defined _MSC_VER)
04373 static void
04374 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04375 #else
04376 static void
04377 yy_stack_print (yybottom, yytop)
04378     yytype_int16 *yybottom;
04379     yytype_int16 *yytop;
04380 #endif
04381 {
04382   YYFPRINTF (stderr, "Stack now");
04383   for (; yybottom <= yytop; yybottom++)
04384     {
04385       int yybot = *yybottom;
04386       YYFPRINTF (stderr, " %d", yybot);
04387     }
04388   YYFPRINTF (stderr, "\n");
04389 }
04390 
04391 # define YY_STACK_PRINT(Bottom, Top)                            \
04392 do {                                                            \
04393   if (yydebug)                                                  \
04394     yy_stack_print ((Bottom), (Top));                           \
04395 } while (YYID (0))
04396 
04397 
04398 /*------------------------------------------------.
04399 | Report that the YYRULE is going to be reduced.  |
04400 `------------------------------------------------*/
04401 
04402 #if (defined __STDC__ || defined __C99__FUNC__ \
04403      || defined __cplusplus || defined _MSC_VER)
04404 static void
04405 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04406 #else
04407 static void
04408 yy_reduce_print (yyvsp, yyrule, parser)
04409     YYSTYPE *yyvsp;
04410     int yyrule;
04411     struct parser_params *parser;
04412 #endif
04413 {
04414   int yynrhs = yyr2[yyrule];
04415   int yyi;
04416   unsigned long int yylno = yyrline[yyrule];
04417   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04418              yyrule - 1, yylno);
04419   /* The symbols being reduced.  */
04420   for (yyi = 0; yyi < yynrhs; yyi++)
04421     {
04422       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04423       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04424                        &(yyvsp[(yyi + 1) - (yynrhs)])
04425                                        , parser);
04426       YYFPRINTF (stderr, "\n");
04427     }
04428 }
04429 
04430 # define YY_REDUCE_PRINT(Rule)          \
04431 do {                                    \
04432   if (yydebug)                          \
04433     yy_reduce_print (yyvsp, Rule, parser); \
04434 } while (YYID (0))
04435 
04436 /* Nonzero means print parse trace.  It is left uninitialized so that
04437    multiple parsers can coexist.  */
04438 #ifndef yydebug
04439 int yydebug;
04440 #endif
04441 #else /* !YYDEBUG */
04442 # define YYDPRINTF(Args)
04443 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04444 # define YY_STACK_PRINT(Bottom, Top)
04445 # define YY_REDUCE_PRINT(Rule)
04446 #endif /* !YYDEBUG */
04447 
04448 
04449 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04450 #ifndef YYINITDEPTH
04451 # define YYINITDEPTH 200
04452 #endif
04453 
04454 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04455    if the built-in stack extension method is used).
04456 
04457    Do not make this value too large; the results are undefined if
04458    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04459    evaluated with infinite-precision integer arithmetic.  */
04460 
04461 #ifndef YYMAXDEPTH
04462 # define YYMAXDEPTH 10000
04463 #endif
04464 
04465 
04466 #if YYERROR_VERBOSE
04467 
04468 # ifndef yystrlen
04469 #  if defined __GLIBC__ && defined _STRING_H
04470 #   define yystrlen strlen
04471 #  else
04472 /* Return the length of YYSTR.  */
04473 #if (defined __STDC__ || defined __C99__FUNC__ \
04474      || defined __cplusplus || defined _MSC_VER)
04475 static YYSIZE_T
04476 yystrlen (const char *yystr)
04477 #else
04478 static YYSIZE_T
04479 yystrlen (yystr)
04480     const char *yystr;
04481 #endif
04482 {
04483   YYSIZE_T yylen;
04484   for (yylen = 0; yystr[yylen]; yylen++)
04485     continue;
04486   return yylen;
04487 }
04488 #  endif
04489 # endif
04490 
04491 # ifndef yystpcpy
04492 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04493 #   define yystpcpy stpcpy
04494 #  else
04495 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04496    YYDEST.  */
04497 #if (defined __STDC__ || defined __C99__FUNC__ \
04498      || defined __cplusplus || defined _MSC_VER)
04499 static char *
04500 yystpcpy (char *yydest, const char *yysrc)
04501 #else
04502 static char *
04503 yystpcpy (yydest, yysrc)
04504     char *yydest;
04505     const char *yysrc;
04506 #endif
04507 {
04508   char *yyd = yydest;
04509   const char *yys = yysrc;
04510 
04511   while ((*yyd++ = *yys++) != '\0')
04512     continue;
04513 
04514   return yyd - 1;
04515 }
04516 #  endif
04517 # endif
04518 
04519 # ifndef yytnamerr
04520 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04521    quotes and backslashes, so that it's suitable for yyerror.  The
04522    heuristic is that double-quoting is unnecessary unless the string
04523    contains an apostrophe, a comma, or backslash (other than
04524    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04525    null, do not copy; instead, return the length of what the result
04526    would have been.  */
04527 static YYSIZE_T
04528 yytnamerr (char *yyres, const char *yystr)
04529 {
04530   if (*yystr == '"')
04531     {
04532       YYSIZE_T yyn = 0;
04533       char const *yyp = yystr;
04534 
04535       for (;;)
04536         switch (*++yyp)
04537           {
04538           case '\'':
04539           case ',':
04540             goto do_not_strip_quotes;
04541 
04542           case '\\':
04543             if (*++yyp != '\\')
04544               goto do_not_strip_quotes;
04545             /* Fall through.  */
04546           default:
04547             if (yyres)
04548               yyres[yyn] = *yyp;
04549             yyn++;
04550             break;
04551 
04552           case '"':
04553             if (yyres)
04554               yyres[yyn] = '\0';
04555             return yyn;
04556           }
04557     do_not_strip_quotes: ;
04558     }
04559 
04560   if (! yyres)
04561     return yystrlen (yystr);
04562 
04563   return yystpcpy (yyres, yystr) - yyres;
04564 }
04565 # endif
04566 
04567 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
04568    about the unexpected token YYTOKEN for the state stack whose top is
04569    YYSSP.
04570 
04571    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
04572    not large enough to hold the message.  In that case, also set
04573    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
04574    required number of bytes is too large to store.  */
04575 static int
04576 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
04577                 yytype_int16 *yyssp, int yytoken)
04578 {
04579   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
04580   YYSIZE_T yysize = yysize0;
04581   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04582   /* Internationalized format string. */
04583   const char *yyformat = YY_NULL;
04584   /* Arguments of yyformat. */
04585   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04586   /* Number of reported tokens (one for the "unexpected", one per
04587      "expected"). */
04588   int yycount = 0;
04589 
04590   /* There are many possibilities here to consider:
04591      - Assume YYFAIL is not used.  It's too flawed to consider.  See
04592        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
04593        for details.  YYERROR is fine as it does not invoke this
04594        function.
04595      - If this state is a consistent state with a default action, then
04596        the only way this function was invoked is if the default action
04597        is an error action.  In that case, don't check for expected
04598        tokens because there are none.
04599      - The only way there can be no lookahead present (in yychar) is if
04600        this state is a consistent state with a default action.  Thus,
04601        detecting the absence of a lookahead is sufficient to determine
04602        that there is no unexpected or expected token to report.  In that
04603        case, just report a simple "syntax error".
04604      - Don't assume there isn't a lookahead just because this state is a
04605        consistent state with a default action.  There might have been a
04606        previous inconsistent state, consistent state with a non-default
04607        action, or user semantic action that manipulated yychar.
04608      - Of course, the expected token list depends on states to have
04609        correct lookahead information, and it depends on the parser not
04610        to perform extra reductions after fetching a lookahead from the
04611        scanner and before detecting a syntax error.  Thus, state merging
04612        (from LALR or IELR) and default reductions corrupt the expected
04613        token list.  However, the list is correct for canonical LR with
04614        one exception: it will still contain any token that will not be
04615        accepted due to an error action in a later state.
04616   */
04617   if (yytoken != YYEMPTY)
04618     {
04619       int yyn = yypact[*yyssp];
04620       yyarg[yycount++] = yytname[yytoken];
04621       if (!yypact_value_is_default (yyn))
04622         {
04623           /* Start YYX at -YYN if negative to avoid negative indexes in
04624              YYCHECK.  In other words, skip the first -YYN actions for
04625              this state because they are default actions.  */
04626           int yyxbegin = yyn < 0 ? -yyn : 0;
04627           /* Stay within bounds of both yycheck and yytname.  */
04628           int yychecklim = YYLAST - yyn + 1;
04629           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04630           int yyx;
04631 
04632           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04633             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
04634                 && !yytable_value_is_error (yytable[yyx + yyn]))
04635               {
04636                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04637                   {
04638                     yycount = 1;
04639                     yysize = yysize0;
04640                     break;
04641                   }
04642                 yyarg[yycount++] = yytname[yyx];
04643                 {
04644                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
04645                   if (! (yysize <= yysize1
04646                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04647                     return 2;
04648                   yysize = yysize1;
04649                 }
04650               }
04651         }
04652     }
04653 
04654   switch (yycount)
04655     {
04656 # define YYCASE_(N, S)                      \
04657       case N:                               \
04658         yyformat = S;                       \
04659       break
04660       YYCASE_(0, YY_("syntax error"));
04661       YYCASE_(1, YY_("syntax error, unexpected %s"));
04662       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
04663       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
04664       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
04665       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
04666 # undef YYCASE_
04667     }
04668 
04669   {
04670     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
04671     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04672       return 2;
04673     yysize = yysize1;
04674   }
04675 
04676   if (*yymsg_alloc < yysize)
04677     {
04678       *yymsg_alloc = 2 * yysize;
04679       if (! (yysize <= *yymsg_alloc
04680              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
04681         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
04682       return 1;
04683     }
04684 
04685   /* Avoid sprintf, as that infringes on the user's name space.
04686      Don't have undefined behavior even if the translation
04687      produced a string with the wrong number of "%s"s.  */
04688   {
04689     char *yyp = *yymsg;
04690     int yyi = 0;
04691     while ((*yyp = *yyformat) != '\0')
04692       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
04693         {
04694           yyp += yytnamerr (yyp, yyarg[yyi++]);
04695           yyformat += 2;
04696         }
04697       else
04698         {
04699           yyp++;
04700           yyformat++;
04701         }
04702   }
04703   return 0;
04704 }
04705 #endif /* YYERROR_VERBOSE */
04706 
04707 /*-----------------------------------------------.
04708 | Release the memory associated to this symbol.  |
04709 `-----------------------------------------------*/
04710 
04711 /*ARGSUSED*/
04712 #if (defined __STDC__ || defined __C99__FUNC__ \
04713      || defined __cplusplus || defined _MSC_VER)
04714 static void
04715 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04716 #else
04717 static void
04718 yydestruct (yymsg, yytype, yyvaluep, parser)
04719     const char *yymsg;
04720     int yytype;
04721     YYSTYPE *yyvaluep;
04722     struct parser_params *parser;
04723 #endif
04724 {
04725   YYUSE (yyvaluep);
04726   YYUSE (parser);
04727 
04728   if (!yymsg)
04729     yymsg = "Deleting";
04730   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04731 
04732   YYUSE (yytype);
04733 }
04734 
04735 
04736 
04737 
04738 /*----------.
04739 | yyparse.  |
04740 `----------*/
04741 
04742 #ifdef YYPARSE_PARAM
04743 #if (defined __STDC__ || defined __C99__FUNC__ \
04744      || defined __cplusplus || defined _MSC_VER)
04745 int
04746 yyparse (void *YYPARSE_PARAM)
04747 #else
04748 int
04749 yyparse (YYPARSE_PARAM)
04750     void *YYPARSE_PARAM;
04751 #endif
04752 #else /* ! YYPARSE_PARAM */
04753 #if (defined __STDC__ || defined __C99__FUNC__ \
04754      || defined __cplusplus || defined _MSC_VER)
04755 int
04756 yyparse (struct parser_params *parser)
04757 #else
04758 int
04759 yyparse (parser)
04760     struct parser_params *parser;
04761 #endif
04762 #endif
04763 {
04764 /* The lookahead symbol.  */
04765 int yychar;
04766 
04767 
04768 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
04769 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
04770 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
04771     _Pragma ("GCC diagnostic push") \
04772     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
04773     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
04774 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
04775     _Pragma ("GCC diagnostic pop")
04776 #else
04777 /* Default value used for initialization, for pacifying older GCCs
04778    or non-GCC compilers.  */
04779 static YYSTYPE yyval_default;
04780 # define YY_INITIAL_VALUE(Value) = Value
04781 #endif
04782 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
04783 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
04784 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
04785 #endif
04786 #ifndef YY_INITIAL_VALUE
04787 # define YY_INITIAL_VALUE(Value) /* Nothing. */
04788 #endif
04789 
04790 /* The semantic value of the lookahead symbol.  */
04791 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
04792 
04793     /* Number of syntax errors so far.  */
04794     int yynerrs;
04795 
04796     int yystate;
04797     /* Number of tokens to shift before error messages enabled.  */
04798     int yyerrstatus;
04799 
04800     /* The stacks and their tools:
04801        `yyss': related to states.
04802        `yyvs': related to semantic values.
04803 
04804        Refer to the stacks through separate pointers, to allow yyoverflow
04805        to reallocate them elsewhere.  */
04806 
04807     /* The state stack.  */
04808     yytype_int16 yyssa[YYINITDEPTH];
04809     yytype_int16 *yyss;
04810     yytype_int16 *yyssp;
04811 
04812     /* The semantic value stack.  */
04813     YYSTYPE yyvsa[YYINITDEPTH];
04814     YYSTYPE *yyvs;
04815     YYSTYPE *yyvsp;
04816 
04817     YYSIZE_T yystacksize;
04818 
04819   int yyn;
04820   int yyresult;
04821   /* Lookahead token as an internal (translated) token number.  */
04822   int yytoken = 0;
04823   /* The variables used to return semantic value and location from the
04824      action routines.  */
04825   YYSTYPE yyval;
04826 
04827 #if YYERROR_VERBOSE
04828   /* Buffer for error messages, and its allocated size.  */
04829   char yymsgbuf[128];
04830   char *yymsg = yymsgbuf;
04831   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
04832 #endif
04833 
04834 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
04835 
04836   /* The number of symbols on the RHS of the reduced rule.
04837      Keep to zero when no symbol should be popped.  */
04838   int yylen = 0;
04839 
04840   yyssp = yyss = yyssa;
04841   yyvsp = yyvs = yyvsa;
04842   yystacksize = YYINITDEPTH;
04843 
04844   YYDPRINTF ((stderr, "Starting parse\n"));
04845 
04846   yystate = 0;
04847   yyerrstatus = 0;
04848   yynerrs = 0;
04849   yychar = YYEMPTY; /* Cause a token to be read.  */
04850   goto yysetstate;
04851 
04852 /*------------------------------------------------------------.
04853 | yynewstate -- Push a new state, which is found in yystate.  |
04854 `------------------------------------------------------------*/
04855  yynewstate:
04856   /* In all cases, when you get here, the value and location stacks
04857      have just been pushed.  So pushing a state here evens the stacks.  */
04858   yyssp++;
04859 
04860  yysetstate:
04861   *yyssp = yystate;
04862 
04863   if (yyss + yystacksize - 1 <= yyssp)
04864     {
04865       /* Get the current used size of the three stacks, in elements.  */
04866       YYSIZE_T yysize = yyssp - yyss + 1;
04867 
04868 #ifdef yyoverflow
04869       {
04870         /* Give user a chance to reallocate the stack.  Use copies of
04871            these so that the &'s don't force the real ones into
04872            memory.  */
04873         YYSTYPE *yyvs1 = yyvs;
04874         yytype_int16 *yyss1 = yyss;
04875 
04876         /* Each stack pointer address is followed by the size of the
04877            data in use in that stack, in bytes.  This used to be a
04878            conditional around just the two extra args, but that might
04879            be undefined if yyoverflow is a macro.  */
04880         yyoverflow (YY_("memory exhausted"),
04881                     &yyss1, yysize * sizeof (*yyssp),
04882                     &yyvs1, yysize * sizeof (*yyvsp),
04883                     &yystacksize);
04884 
04885         yyss = yyss1;
04886         yyvs = yyvs1;
04887       }
04888 #else /* no yyoverflow */
04889 # ifndef YYSTACK_RELOCATE
04890       goto yyexhaustedlab;
04891 # else
04892       /* Extend the stack our own way.  */
04893       if (YYMAXDEPTH <= yystacksize)
04894         goto yyexhaustedlab;
04895       yystacksize *= 2;
04896       if (YYMAXDEPTH < yystacksize)
04897         yystacksize = YYMAXDEPTH;
04898 
04899       {
04900         yytype_int16 *yyss1 = yyss;
04901         union yyalloc *yyptr =
04902           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
04903         if (! yyptr)
04904           goto yyexhaustedlab;
04905         YYSTACK_RELOCATE (yyss_alloc, yyss);
04906         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
04907 #  undef YYSTACK_RELOCATE
04908         if (yyss1 != yyssa)
04909           YYSTACK_FREE (yyss1);
04910       }
04911 # endif
04912 #endif /* no yyoverflow */
04913 
04914       yyssp = yyss + yysize - 1;
04915       yyvsp = yyvs + yysize - 1;
04916 
04917       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
04918                   (unsigned long int) yystacksize));
04919 
04920       if (yyss + yystacksize - 1 <= yyssp)
04921         YYABORT;
04922     }
04923 
04924   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
04925 
04926   if (yystate == YYFINAL)
04927     YYACCEPT;
04928 
04929   goto yybackup;
04930 
04931 /*-----------.
04932 | yybackup.  |
04933 `-----------*/
04934 yybackup:
04935 
04936   /* Do appropriate processing given the current state.  Read a
04937      lookahead token if we need one and don't already have one.  */
04938 
04939   /* First try to decide what to do without reference to lookahead token.  */
04940   yyn = yypact[yystate];
04941   if (yypact_value_is_default (yyn))
04942     goto yydefault;
04943 
04944   /* Not known => get a lookahead token if don't already have one.  */
04945 
04946   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
04947   if (yychar == YYEMPTY)
04948     {
04949       YYDPRINTF ((stderr, "Reading a token: "));
04950       yychar = YYLEX;
04951     }
04952 
04953   if (yychar <= YYEOF)
04954     {
04955       yychar = yytoken = YYEOF;
04956       YYDPRINTF ((stderr, "Now at end of input.\n"));
04957     }
04958   else
04959     {
04960       yytoken = YYTRANSLATE (yychar);
04961       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
04962     }
04963 
04964   /* If the proper action on seeing token YYTOKEN is to reduce or to
04965      detect an error, take that action.  */
04966   yyn += yytoken;
04967   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
04968     goto yydefault;
04969   yyn = yytable[yyn];
04970   if (yyn <= 0)
04971     {
04972       if (yytable_value_is_error (yyn))
04973         goto yyerrlab;
04974       yyn = -yyn;
04975       goto yyreduce;
04976     }
04977 
04978   /* Count tokens shifted since error; after three, turn off error
04979      status.  */
04980   if (yyerrstatus)
04981     yyerrstatus--;
04982 
04983   /* Shift the lookahead token.  */
04984   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
04985 
04986   /* Discard the shifted token.  */
04987   yychar = YYEMPTY;
04988 
04989   yystate = yyn;
04990   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
04991   *++yyvsp = yylval;
04992   YY_IGNORE_MAYBE_UNINITIALIZED_END
04993 
04994   goto yynewstate;
04995 
04996 
04997 /*-----------------------------------------------------------.
04998 | yydefault -- do the default action for the current state.  |
04999 `-----------------------------------------------------------*/
05000 yydefault:
05001   yyn = yydefact[yystate];
05002   if (yyn == 0)
05003     goto yyerrlab;
05004   goto yyreduce;
05005 
05006 
05007 /*-----------------------------.
05008 | yyreduce -- Do a reduction.  |
05009 `-----------------------------*/
05010 yyreduce:
05011   /* yyn is the number of a rule to reduce with.  */
05012   yylen = yyr2[yyn];
05013 
05014   /* If YYLEN is nonzero, implement the default value of the action:
05015      `$$ = $1'.
05016 
05017      Otherwise, the following line sets YYVAL to garbage.
05018      This behavior is undocumented and Bison
05019      users should not rely upon it.  Assigning to YYVAL
05020      unconditionally makes the parser a bit smaller, and it avoids a
05021      GCC warning that YYVAL may be used uninitialized.  */
05022   yyval = yyvsp[1-yylen];
05023 
05024 
05025   YY_REDUCE_PRINT (yyn);
05026   switch (yyn)
05027     {
05028         case 2:
05029 /* Line 1787 of yacc.c  */
05030 #line 786 "ripper.y"
05031     {
05032                         lex_state = EXPR_BEG;
05033 #if 0
05034                         local_push(compile_for_eval || rb_parse_in_main());
05035 #endif
05036                         local_push(0);
05037 
05038                     }
05039     break;
05040 
05041   case 3:
05042 /* Line 1787 of yacc.c  */
05043 #line 795 "ripper.y"
05044     {
05045 #if 0
05046                         if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
05047                             /* last expression should not be void */
05048                             if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
05049                             else {
05050                                 NODE *node = (yyvsp[(2) - (2)].val);
05051                                 while (node->nd_next) {
05052                                     node = node->nd_next;
05053                                 }
05054                                 void_expr(node->nd_head);
05055                             }
05056                         }
05057                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
05058 #endif
05059                         (yyval.val) = (yyvsp[(2) - (2)].val);
05060                         parser->result = dispatch1(program, (yyval.val));
05061 
05062                         local_pop();
05063                     }
05064     break;
05065 
05066   case 4:
05067 /* Line 1787 of yacc.c  */
05068 #line 818 "ripper.y"
05069     {
05070 #if 0
05071                         void_stmts((yyvsp[(1) - (2)].val));
05072                         fixup_nodes(&deferred_nodes);
05073 #endif
05074 
05075                         (yyval.val) = (yyvsp[(1) - (2)].val);
05076                     }
05077     break;
05078 
05079   case 5:
05080 /* Line 1787 of yacc.c  */
05081 #line 829 "ripper.y"
05082     {
05083 #if 0
05084                         (yyval.val) = NEW_BEGIN(0);
05085 #endif
05086                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05087                                                   dispatch0(void_stmt));
05088 
05089                     }
05090     break;
05091 
05092   case 6:
05093 /* Line 1787 of yacc.c  */
05094 #line 838 "ripper.y"
05095     {
05096 #if 0
05097                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05098 #endif
05099                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05100 
05101                     }
05102     break;
05103 
05104   case 7:
05105 /* Line 1787 of yacc.c  */
05106 #line 846 "ripper.y"
05107     {
05108 #if 0
05109                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05110 #endif
05111                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05112 
05113                     }
05114     break;
05115 
05116   case 8:
05117 /* Line 1787 of yacc.c  */
05118 #line 854 "ripper.y"
05119     {
05120                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05121                     }
05122     break;
05123 
05124   case 10:
05125 /* Line 1787 of yacc.c  */
05126 #line 861 "ripper.y"
05127     {
05128                         if (in_def || in_single) {
05129                             yyerror("BEGIN in method");
05130                         }
05131 #if 0
05132                         /* local_push(0); */
05133 #endif
05134 
05135                     }
05136     break;
05137 
05138   case 11:
05139 /* Line 1787 of yacc.c  */
05140 #line 871 "ripper.y"
05141     {
05142 #if 0
05143                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05144                                                             (yyvsp[(4) - (5)].val));
05145                         /* NEW_PREEXE($4)); */
05146                         /* local_pop(); */
05147                         (yyval.val) = NEW_BEGIN(0);
05148 #endif
05149                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05150 
05151                     }
05152     break;
05153 
05154   case 12:
05155 /* Line 1787 of yacc.c  */
05156 #line 888 "ripper.y"
05157     {
05158 #if 0
05159                         (yyval.val) = (yyvsp[(1) - (4)].val);
05160                         if ((yyvsp[(2) - (4)].val)) {
05161                             (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05162                         }
05163                         else if ((yyvsp[(3) - (4)].val)) {
05164                             rb_warn0("else without rescue is useless");
05165                             (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
05166                         }
05167                         if ((yyvsp[(4) - (4)].val)) {
05168                             if ((yyval.val)) {
05169                                 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
05170                             }
05171                             else {
05172                                 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
05173                             }
05174                         }
05175                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05176 #endif
05177                         (yyval.val) = dispatch4(bodystmt,
05178                                        escape_Qundef((yyvsp[(1) - (4)].val)),
05179                                        escape_Qundef((yyvsp[(2) - (4)].val)),
05180                                        escape_Qundef((yyvsp[(3) - (4)].val)),
05181                                        escape_Qundef((yyvsp[(4) - (4)].val)));
05182 
05183                     }
05184     break;
05185 
05186   case 13:
05187 /* Line 1787 of yacc.c  */
05188 #line 918 "ripper.y"
05189     {
05190 #if 0
05191                         void_stmts((yyvsp[(1) - (2)].val));
05192                         fixup_nodes(&deferred_nodes);
05193 #endif
05194 
05195                         (yyval.val) = (yyvsp[(1) - (2)].val);
05196                     }
05197     break;
05198 
05199   case 14:
05200 /* Line 1787 of yacc.c  */
05201 #line 929 "ripper.y"
05202     {
05203 #if 0
05204                         (yyval.val) = NEW_BEGIN(0);
05205 #endif
05206                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05207                                                   dispatch0(void_stmt));
05208 
05209                     }
05210     break;
05211 
05212   case 15:
05213 /* Line 1787 of yacc.c  */
05214 #line 938 "ripper.y"
05215     {
05216 #if 0
05217                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05218 #endif
05219                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05220 
05221                     }
05222     break;
05223 
05224   case 16:
05225 /* Line 1787 of yacc.c  */
05226 #line 946 "ripper.y"
05227     {
05228 #if 0
05229                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05230 #endif
05231                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05232 
05233                     }
05234     break;
05235 
05236   case 17:
05237 /* Line 1787 of yacc.c  */
05238 #line 954 "ripper.y"
05239     {
05240                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05241                     }
05242     break;
05243 
05244   case 18:
05245 /* Line 1787 of yacc.c  */
05246 #line 959 "ripper.y"
05247     {lex_state = EXPR_FNAME;}
05248     break;
05249 
05250   case 19:
05251 /* Line 1787 of yacc.c  */
05252 #line 960 "ripper.y"
05253     {
05254 #if 0
05255                         (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05256 #endif
05257                         (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05258 
05259                     }
05260     break;
05261 
05262   case 20:
05263 /* Line 1787 of yacc.c  */
05264 #line 968 "ripper.y"
05265     {
05266 #if 0
05267                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05268 #endif
05269                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05270 
05271                     }
05272     break;
05273 
05274   case 21:
05275 /* Line 1787 of yacc.c  */
05276 #line 976 "ripper.y"
05277     {
05278 #if 0
05279                         char buf[2];
05280                         buf[0] = '$';
05281                         buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
05282                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
05283 #endif
05284                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05285 
05286                     }
05287     break;
05288 
05289   case 22:
05290 /* Line 1787 of yacc.c  */
05291 #line 987 "ripper.y"
05292     {
05293 #if 0
05294                         yyerror("can't make alias for the number variables");
05295                         (yyval.val) = NEW_BEGIN(0);
05296 #endif
05297                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05298                         (yyval.val) = dispatch1(alias_error, (yyval.val));
05299 
05300                     }
05301     break;
05302 
05303   case 23:
05304 /* Line 1787 of yacc.c  */
05305 #line 997 "ripper.y"
05306     {
05307 #if 0
05308                         (yyval.val) = (yyvsp[(2) - (2)].val);
05309 #endif
05310                         (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
05311 
05312                     }
05313     break;
05314 
05315   case 24:
05316 /* Line 1787 of yacc.c  */
05317 #line 1005 "ripper.y"
05318     {
05319 #if 0
05320                         (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05321                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05322 #endif
05323                         (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05324 
05325                     }
05326     break;
05327 
05328   case 25:
05329 /* Line 1787 of yacc.c  */
05330 #line 1014 "ripper.y"
05331     {
05332 #if 0
05333                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05334                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05335 #endif
05336                         (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05337 
05338                     }
05339     break;
05340 
05341   case 26:
05342 /* Line 1787 of yacc.c  */
05343 #line 1023 "ripper.y"
05344     {
05345 #if 0
05346                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05347                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05348                         }
05349                         else {
05350                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05351                         }
05352 #endif
05353                         (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05354 
05355                     }
05356     break;
05357 
05358   case 27:
05359 /* Line 1787 of yacc.c  */
05360 #line 1036 "ripper.y"
05361     {
05362 #if 0
05363                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05364                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05365                         }
05366                         else {
05367                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05368                         }
05369 #endif
05370                         (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05371 
05372                     }
05373     break;
05374 
05375   case 28:
05376 /* Line 1787 of yacc.c  */
05377 #line 1049 "ripper.y"
05378     {
05379 #if 0
05380                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
05381                         (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
05382 #endif
05383                         (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05384 
05385                     }
05386     break;
05387 
05388   case 29:
05389 /* Line 1787 of yacc.c  */
05390 #line 1058 "ripper.y"
05391     {
05392                         if (in_def || in_single) {
05393                             rb_warn0("END in method; use at_exit");
05394                         }
05395 #if 0
05396                         (yyval.val) = NEW_POSTEXE(NEW_NODE(
05397                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
05398 #endif
05399                         (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
05400 
05401                     }
05402     break;
05403 
05404   case 31:
05405 /* Line 1787 of yacc.c  */
05406 #line 1071 "ripper.y"
05407     {
05408 #if 0
05409                         value_expr((yyvsp[(3) - (3)].val));
05410                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05411                         (yyval.val) = (yyvsp[(1) - (3)].val);
05412 #endif
05413                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05414 
05415                     }
05416     break;
05417 
05418   case 32:
05419 /* Line 1787 of yacc.c  */
05420 #line 1081 "ripper.y"
05421     {
05422 #if 0
05423                         value_expr((yyvsp[(3) - (3)].val));
05424                         if ((yyvsp[(1) - (3)].val)) {
05425                             ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
05426                             if ((yyvsp[(2) - (3)].val) == tOROP) {
05427                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05428                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
05429                                 if (is_asgn_or_id(vid)) {
05430                                     (yyval.val)->nd_aid = vid;
05431                                 }
05432                             }
05433                             else if ((yyvsp[(2) - (3)].val) == tANDOP) {
05434                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05435                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
05436                             }
05437                             else {
05438                                 (yyval.val) = (yyvsp[(1) - (3)].val);
05439                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
05440                             }
05441                         }
05442                         else {
05443                             (yyval.val) = NEW_BEGIN(0);
05444                         }
05445 #endif
05446                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05447 
05448                     }
05449     break;
05450 
05451   case 33:
05452 /* Line 1787 of yacc.c  */
05453 #line 1110 "ripper.y"
05454     {
05455 #if 0
05456                         NODE *args;
05457 
05458                         value_expr((yyvsp[(6) - (6)].val));
05459                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
05460                         args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
05461                         if ((yyvsp[(5) - (6)].val) == tOROP) {
05462                             (yyvsp[(5) - (6)].val) = 0;
05463                         }
05464                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
05465                             (yyvsp[(5) - (6)].val) = 1;
05466                         }
05467                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
05468                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
05469 #endif
05470                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
05471                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
05472 
05473                     }
05474     break;
05475 
05476   case 34:
05477 /* Line 1787 of yacc.c  */
05478 #line 1131 "ripper.y"
05479     {
05480 #if 0
05481                         value_expr((yyvsp[(5) - (5)].val));
05482                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05483                             (yyvsp[(4) - (5)].val) = 0;
05484                         }
05485                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05486                             (yyvsp[(4) - (5)].val) = 1;
05487                         }
05488                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05489                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05490 #endif
05491                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
05492                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05493 
05494                     }
05495     break;
05496 
05497   case 35:
05498 /* Line 1787 of yacc.c  */
05499 #line 1148 "ripper.y"
05500     {
05501 #if 0
05502                         value_expr((yyvsp[(5) - (5)].val));
05503                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05504                             (yyvsp[(4) - (5)].val) = 0;
05505                         }
05506                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05507                             (yyvsp[(4) - (5)].val) = 1;
05508                         }
05509                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05510                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05511 #endif
05512                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
05513                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05514 
05515                     }
05516     break;
05517 
05518   case 36:
05519 /* Line 1787 of yacc.c  */
05520 #line 1165 "ripper.y"
05521     {
05522 #if 0
05523                         yyerror("constant re-assignment");
05524                         (yyval.val) = 0;
05525 #endif
05526                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05527                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05528                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05529 
05530                     }
05531     break;
05532 
05533   case 37:
05534 /* Line 1787 of yacc.c  */
05535 #line 1176 "ripper.y"
05536     {
05537 #if 0
05538                         value_expr((yyvsp[(5) - (5)].val));
05539                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05540                             (yyvsp[(4) - (5)].val) = 0;
05541                         }
05542                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05543                             (yyvsp[(4) - (5)].val) = 1;
05544                         }
05545                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05546                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05547 #endif
05548                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
05549                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05550 
05551                     }
05552     break;
05553 
05554   case 38:
05555 /* Line 1787 of yacc.c  */
05556 #line 1193 "ripper.y"
05557     {
05558 #if 0
05559                         rb_backref_error((yyvsp[(1) - (3)].val));
05560                         (yyval.val) = NEW_BEGIN(0);
05561 #endif
05562                         (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
05563                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05564 
05565                     }
05566     break;
05567 
05568   case 39:
05569 /* Line 1787 of yacc.c  */
05570 #line 1203 "ripper.y"
05571     {
05572 #if 0
05573                         value_expr((yyvsp[(3) - (3)].val));
05574                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05575 #endif
05576                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05577 
05578                     }
05579     break;
05580 
05581   case 40:
05582 /* Line 1787 of yacc.c  */
05583 #line 1212 "ripper.y"
05584     {
05585 #if 0
05586                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05587                         (yyval.val) = (yyvsp[(1) - (3)].val);
05588 #endif
05589                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05590 
05591                     }
05592     break;
05593 
05594   case 41:
05595 /* Line 1787 of yacc.c  */
05596 #line 1221 "ripper.y"
05597     {
05598 #if 0
05599                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05600                         (yyval.val) = (yyvsp[(1) - (3)].val);
05601 #endif
05602                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05603 
05604                     }
05605     break;
05606 
05607   case 43:
05608 /* Line 1787 of yacc.c  */
05609 #line 1233 "ripper.y"
05610     {
05611 #if 0
05612                         value_expr((yyvsp[(3) - (3)].val));
05613                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05614 #endif
05615                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05616 
05617                     }
05618     break;
05619 
05620   case 44:
05621 /* Line 1787 of yacc.c  */
05622 #line 1242 "ripper.y"
05623     {
05624 #if 0
05625                         value_expr((yyvsp[(3) - (3)].val));
05626                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05627 #endif
05628                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05629 
05630                     }
05631     break;
05632 
05633   case 46:
05634 /* Line 1787 of yacc.c  */
05635 #line 1255 "ripper.y"
05636     {
05637 #if 0
05638                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05639 #endif
05640                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
05641 
05642                     }
05643     break;
05644 
05645   case 47:
05646 /* Line 1787 of yacc.c  */
05647 #line 1263 "ripper.y"
05648     {
05649 #if 0
05650                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05651 #endif
05652                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
05653 
05654                     }
05655     break;
05656 
05657   case 48:
05658 /* Line 1787 of yacc.c  */
05659 #line 1271 "ripper.y"
05660     {
05661 #if 0
05662                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
05663 #endif
05664                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
05665 
05666                     }
05667     break;
05668 
05669   case 49:
05670 /* Line 1787 of yacc.c  */
05671 #line 1279 "ripper.y"
05672     {
05673 #if 0
05674                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
05675 #endif
05676                         (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
05677 
05678                     }
05679     break;
05680 
05681   case 51:
05682 /* Line 1787 of yacc.c  */
05683 #line 1290 "ripper.y"
05684     {
05685 #if 0
05686                         value_expr((yyvsp[(1) - (1)].val));
05687                         (yyval.val) = (yyvsp[(1) - (1)].val);
05688                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
05689 #endif
05690                         (yyval.val) = (yyvsp[(1) - (1)].val);
05691 
05692                     }
05693     break;
05694 
05695   case 55:
05696 /* Line 1787 of yacc.c  */
05697 #line 1307 "ripper.y"
05698     {
05699 #if 0
05700                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05701 #endif
05702                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
05703                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05704 
05705                     }
05706     break;
05707 
05708   case 56:
05709 /* Line 1787 of yacc.c  */
05710 #line 1316 "ripper.y"
05711     {
05712 #if 0
05713                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05714 #endif
05715                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
05716                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05717 
05718                     }
05719     break;
05720 
05721   case 57:
05722 /* Line 1787 of yacc.c  */
05723 #line 1327 "ripper.y"
05724     {
05725                         (yyvsp[(1) - (1)].vars) = dyna_push();
05726 #if 0
05727                         (yyval.num) = ruby_sourceline;
05728 #endif
05729 
05730                     }
05731     break;
05732 
05733   case 58:
05734 /* Line 1787 of yacc.c  */
05735 #line 1337 "ripper.y"
05736     {
05737 #if 0
05738                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
05739                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
05740 #endif
05741                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
05742 
05743                         dyna_pop((yyvsp[(1) - (5)].vars));
05744                     }
05745     break;
05746 
05747   case 59:
05748 /* Line 1787 of yacc.c  */
05749 #line 1349 "ripper.y"
05750     {
05751 #if 0
05752                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05753                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05754 #endif
05755                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05756 
05757                     }
05758     break;
05759 
05760   case 60:
05761 /* Line 1787 of yacc.c  */
05762 #line 1358 "ripper.y"
05763     {
05764 #if 0
05765                         block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
05766                         (yyvsp[(3) - (3)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05767                         (yyval.val) = (yyvsp[(3) - (3)].val);
05768                         fixpos((yyval.val), (yyvsp[(2) - (3)].val));
05769 #endif
05770                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05771                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
05772 
05773                     }
05774     break;
05775 
05776   case 61:
05777 /* Line 1787 of yacc.c  */
05778 #line 1370 "ripper.y"
05779     {
05780 #if 0
05781                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05782                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05783 #endif
05784                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05785 
05786                     }
05787     break;
05788 
05789   case 62:
05790 /* Line 1787 of yacc.c  */
05791 #line 1379 "ripper.y"
05792     {
05793 #if 0
05794                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05795                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05796                         (yyval.val) = (yyvsp[(5) - (5)].val);
05797                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05798 #endif
05799                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05800                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05801 
05802                    }
05803     break;
05804 
05805   case 63:
05806 /* Line 1787 of yacc.c  */
05807 #line 1391 "ripper.y"
05808     {
05809 #if 0
05810                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05811                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05812 #endif
05813                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05814 
05815                     }
05816     break;
05817 
05818   case 64:
05819 /* Line 1787 of yacc.c  */
05820 #line 1400 "ripper.y"
05821     {
05822 #if 0
05823                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05824                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05825                         (yyval.val) = (yyvsp[(5) - (5)].val);
05826                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05827 #endif
05828                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05829                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05830 
05831                    }
05832     break;
05833 
05834   case 65:
05835 /* Line 1787 of yacc.c  */
05836 #line 1412 "ripper.y"
05837     {
05838 #if 0
05839                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
05840                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05841 #endif
05842                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
05843 
05844                     }
05845     break;
05846 
05847   case 66:
05848 /* Line 1787 of yacc.c  */
05849 #line 1421 "ripper.y"
05850     {
05851 #if 0
05852                         (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
05853                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05854 #endif
05855                         (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
05856 
05857                     }
05858     break;
05859 
05860   case 67:
05861 /* Line 1787 of yacc.c  */
05862 #line 1430 "ripper.y"
05863     {
05864 #if 0
05865                         (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
05866 #endif
05867                         (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
05868 
05869                     }
05870     break;
05871 
05872   case 68:
05873 /* Line 1787 of yacc.c  */
05874 #line 1438 "ripper.y"
05875     {
05876 #if 0
05877                         (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
05878 #endif
05879                         (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
05880 
05881                     }
05882     break;
05883 
05884   case 69:
05885 /* Line 1787 of yacc.c  */
05886 #line 1446 "ripper.y"
05887     {
05888 #if 0
05889                         (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
05890 #endif
05891                         (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
05892 
05893                     }
05894     break;
05895 
05896   case 71:
05897 /* Line 1787 of yacc.c  */
05898 #line 1457 "ripper.y"
05899     {
05900 #if 0
05901                         (yyval.val) = (yyvsp[(2) - (3)].val);
05902 #endif
05903                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
05904 
05905                     }
05906     break;
05907 
05908   case 73:
05909 /* Line 1787 of yacc.c  */
05910 #line 1468 "ripper.y"
05911     {
05912 #if 0
05913                         (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
05914 #endif
05915                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
05916 
05917                     }
05918     break;
05919 
05920   case 74:
05921 /* Line 1787 of yacc.c  */
05922 #line 1478 "ripper.y"
05923     {
05924 #if 0
05925                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
05926 #endif
05927                         (yyval.val) = (yyvsp[(1) - (1)].val);
05928 
05929                     }
05930     break;
05931 
05932   case 75:
05933 /* Line 1787 of yacc.c  */
05934 #line 1486 "ripper.y"
05935     {
05936 #if 0
05937                         (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
05938 #endif
05939                         (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05940 
05941                     }
05942     break;
05943 
05944   case 76:
05945 /* Line 1787 of yacc.c  */
05946 #line 1494 "ripper.y"
05947     {
05948 #if 0
05949                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05950 #endif
05951                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05952 
05953                     }
05954     break;
05955 
05956   case 77:
05957 /* Line 1787 of yacc.c  */
05958 #line 1502 "ripper.y"
05959     {
05960 #if 0
05961                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
05962 #endif
05963                         (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05964                         (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
05965 
05966                     }
05967     break;
05968 
05969   case 78:
05970 /* Line 1787 of yacc.c  */
05971 #line 1511 "ripper.y"
05972     {
05973 #if 0
05974                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
05975 #endif
05976                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
05977 
05978                     }
05979     break;
05980 
05981   case 79:
05982 /* Line 1787 of yacc.c  */
05983 #line 1519 "ripper.y"
05984     {
05985 #if 0
05986                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
05987 #endif
05988                         (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
05989                         (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
05990 
05991                     }
05992     break;
05993 
05994   case 80:
05995 /* Line 1787 of yacc.c  */
05996 #line 1528 "ripper.y"
05997     {
05998 #if 0
05999                         (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
06000 #endif
06001                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
06002 
06003                     }
06004     break;
06005 
06006   case 81:
06007 /* Line 1787 of yacc.c  */
06008 #line 1536 "ripper.y"
06009     {
06010 #if 0
06011                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
06012 #endif
06013                         (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
06014                         (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
06015 
06016                     }
06017     break;
06018 
06019   case 82:
06020 /* Line 1787 of yacc.c  */
06021 #line 1545 "ripper.y"
06022     {
06023 #if 0
06024                         (yyval.val) = NEW_MASGN(0, -1);
06025 #endif
06026                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06027 
06028                     }
06029     break;
06030 
06031   case 83:
06032 /* Line 1787 of yacc.c  */
06033 #line 1553 "ripper.y"
06034     {
06035 #if 0
06036                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
06037 #endif
06038                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06039                         (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
06040 
06041                     }
06042     break;
06043 
06044   case 85:
06045 /* Line 1787 of yacc.c  */
06046 #line 1565 "ripper.y"
06047     {
06048 #if 0
06049                         (yyval.val) = (yyvsp[(2) - (3)].val);
06050 #endif
06051                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06052 
06053                     }
06054     break;
06055 
06056   case 86:
06057 /* Line 1787 of yacc.c  */
06058 #line 1575 "ripper.y"
06059     {
06060 #if 0
06061                         (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
06062 #endif
06063                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
06064 
06065                     }
06066     break;
06067 
06068   case 87:
06069 /* Line 1787 of yacc.c  */
06070 #line 1583 "ripper.y"
06071     {
06072 #if 0
06073                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06074 #endif
06075                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06076 
06077                     }
06078     break;
06079 
06080   case 88:
06081 /* Line 1787 of yacc.c  */
06082 #line 1593 "ripper.y"
06083     {
06084 #if 0
06085                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
06086 #endif
06087                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
06088 
06089                     }
06090     break;
06091 
06092   case 89:
06093 /* Line 1787 of yacc.c  */
06094 #line 1601 "ripper.y"
06095     {
06096 #if 0
06097                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06098 #endif
06099                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06100 
06101                     }
06102     break;
06103 
06104   case 90:
06105 /* Line 1787 of yacc.c  */
06106 #line 1611 "ripper.y"
06107     {
06108                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06109                     }
06110     break;
06111 
06112   case 91:
06113 /* Line 1787 of yacc.c  */
06114 #line 1615 "ripper.y"
06115     {
06116                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06117                     }
06118     break;
06119 
06120   case 92:
06121 /* Line 1787 of yacc.c  */
06122 #line 1619 "ripper.y"
06123     {
06124 #if 0
06125                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06126 #endif
06127                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06128 
06129                     }
06130     break;
06131 
06132   case 93:
06133 /* Line 1787 of yacc.c  */
06134 #line 1627 "ripper.y"
06135     {
06136 #if 0
06137                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06138 #endif
06139                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06140 
06141                     }
06142     break;
06143 
06144   case 94:
06145 /* Line 1787 of yacc.c  */
06146 #line 1635 "ripper.y"
06147     {
06148 #if 0
06149                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06150 #endif
06151                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06152 
06153                     }
06154     break;
06155 
06156   case 95:
06157 /* Line 1787 of yacc.c  */
06158 #line 1643 "ripper.y"
06159     {
06160 #if 0
06161                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06162 #endif
06163                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06164 
06165                     }
06166     break;
06167 
06168   case 96:
06169 /* Line 1787 of yacc.c  */
06170 #line 1651 "ripper.y"
06171     {
06172 #if 0
06173                         if (in_def || in_single)
06174                             yyerror("dynamic constant assignment");
06175                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06176 #endif
06177                         if (in_def || in_single)
06178                             yyerror("dynamic constant assignment");
06179                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06180 
06181                     }
06182     break;
06183 
06184   case 97:
06185 /* Line 1787 of yacc.c  */
06186 #line 1663 "ripper.y"
06187     {
06188 #if 0
06189                         if (in_def || in_single)
06190                             yyerror("dynamic constant assignment");
06191                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06192 #endif
06193                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06194 
06195                     }
06196     break;
06197 
06198   case 98:
06199 /* Line 1787 of yacc.c  */
06200 #line 1673 "ripper.y"
06201     {
06202 #if 0
06203                         rb_backref_error((yyvsp[(1) - (1)].val));
06204                         (yyval.val) = NEW_BEGIN(0);
06205 #endif
06206                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
06207                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06208 
06209                     }
06210     break;
06211 
06212   case 99:
06213 /* Line 1787 of yacc.c  */
06214 #line 1685 "ripper.y"
06215     {
06216                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06217 #if 0
06218                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06219 #endif
06220                         (yyval.val) = dispatch1(var_field, (yyval.val));
06221 
06222                     }
06223     break;
06224 
06225   case 100:
06226 /* Line 1787 of yacc.c  */
06227 #line 1694 "ripper.y"
06228     {
06229                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06230 #if 0
06231                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06232 #endif
06233                         (yyval.val) = dispatch1(var_field, (yyval.val));
06234 
06235                     }
06236     break;
06237 
06238   case 101:
06239 /* Line 1787 of yacc.c  */
06240 #line 1703 "ripper.y"
06241     {
06242 #if 0
06243                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06244 #endif
06245                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06246 
06247                     }
06248     break;
06249 
06250   case 102:
06251 /* Line 1787 of yacc.c  */
06252 #line 1711 "ripper.y"
06253     {
06254 #if 0
06255                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06256 #endif
06257                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06258 
06259                     }
06260     break;
06261 
06262   case 103:
06263 /* Line 1787 of yacc.c  */
06264 #line 1719 "ripper.y"
06265     {
06266 #if 0
06267                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06268 #endif
06269                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
06270 
06271                     }
06272     break;
06273 
06274   case 104:
06275 /* Line 1787 of yacc.c  */
06276 #line 1727 "ripper.y"
06277     {
06278 #if 0
06279                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06280 #endif
06281                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06282 
06283                     }
06284     break;
06285 
06286   case 105:
06287 /* Line 1787 of yacc.c  */
06288 #line 1735 "ripper.y"
06289     {
06290 #if 0
06291                         if (in_def || in_single)
06292                             yyerror("dynamic constant assignment");
06293                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06294 #endif
06295                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06296                         if (in_def || in_single) {
06297                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06298                         }
06299 
06300                     }
06301     break;
06302 
06303   case 106:
06304 /* Line 1787 of yacc.c  */
06305 #line 1748 "ripper.y"
06306     {
06307 #if 0
06308                         if (in_def || in_single)
06309                             yyerror("dynamic constant assignment");
06310                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06311 #endif
06312                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06313                         if (in_def || in_single) {
06314                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06315                         }
06316 
06317                     }
06318     break;
06319 
06320   case 107:
06321 /* Line 1787 of yacc.c  */
06322 #line 1761 "ripper.y"
06323     {
06324 #if 0
06325                         rb_backref_error((yyvsp[(1) - (1)].val));
06326                         (yyval.val) = NEW_BEGIN(0);
06327 #endif
06328                         (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
06329 
06330                     }
06331     break;
06332 
06333   case 108:
06334 /* Line 1787 of yacc.c  */
06335 #line 1772 "ripper.y"
06336     {
06337 #if 0
06338                         yyerror("class/module name must be CONSTANT");
06339 #endif
06340                         (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
06341 
06342                     }
06343     break;
06344 
06345   case 110:
06346 /* Line 1787 of yacc.c  */
06347 #line 1783 "ripper.y"
06348     {
06349 #if 0
06350                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
06351 #endif
06352                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
06353 
06354                     }
06355     break;
06356 
06357   case 111:
06358 /* Line 1787 of yacc.c  */
06359 #line 1791 "ripper.y"
06360     {
06361 #if 0
06362                         (yyval.val) = NEW_COLON2(0, (yyval.val));
06363 #endif
06364                         (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
06365 
06366                     }
06367     break;
06368 
06369   case 112:
06370 /* Line 1787 of yacc.c  */
06371 #line 1799 "ripper.y"
06372     {
06373 #if 0
06374                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06375 #endif
06376                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06377 
06378                     }
06379     break;
06380 
06381   case 116:
06382 /* Line 1787 of yacc.c  */
06383 #line 1812 "ripper.y"
06384     {
06385                         lex_state = EXPR_ENDFN;
06386                         (yyval.val) = (yyvsp[(1) - (1)].val);
06387                     }
06388     break;
06389 
06390   case 117:
06391 /* Line 1787 of yacc.c  */
06392 #line 1817 "ripper.y"
06393     {
06394                         lex_state = EXPR_ENDFN;
06395 #if 0
06396                         (yyval.val) = (yyvsp[(1) - (1)].id);
06397 #endif
06398                         (yyval.val) = (yyvsp[(1) - (1)].val);
06399 
06400                     }
06401     break;
06402 
06403   case 120:
06404 /* Line 1787 of yacc.c  */
06405 #line 1832 "ripper.y"
06406     {
06407 #if 0
06408                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
06409 #endif
06410                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
06411 
06412                     }
06413     break;
06414 
06415   case 122:
06416 /* Line 1787 of yacc.c  */
06417 #line 1843 "ripper.y"
06418     {
06419 #if 0
06420                         (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
06421 #endif
06422                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
06423 
06424                     }
06425     break;
06426 
06427   case 123:
06428 /* Line 1787 of yacc.c  */
06429 #line 1850 "ripper.y"
06430     {lex_state = EXPR_FNAME;}
06431     break;
06432 
06433   case 124:
06434 /* Line 1787 of yacc.c  */
06435 #line 1851 "ripper.y"
06436     {
06437 #if 0
06438                         (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
06439 #endif
06440                         rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06441 
06442                     }
06443     break;
06444 
06445   case 125:
06446 /* Line 1787 of yacc.c  */
06447 #line 1860 "ripper.y"
06448     { ifndef_ripper((yyval.val) = '|'); }
06449     break;
06450 
06451   case 126:
06452 /* Line 1787 of yacc.c  */
06453 #line 1861 "ripper.y"
06454     { ifndef_ripper((yyval.val) = '^'); }
06455     break;
06456 
06457   case 127:
06458 /* Line 1787 of yacc.c  */
06459 #line 1862 "ripper.y"
06460     { ifndef_ripper((yyval.val) = '&'); }
06461     break;
06462 
06463   case 128:
06464 /* Line 1787 of yacc.c  */
06465 #line 1863 "ripper.y"
06466     { ifndef_ripper((yyval.val) = tCMP); }
06467     break;
06468 
06469   case 129:
06470 /* Line 1787 of yacc.c  */
06471 #line 1864 "ripper.y"
06472     { ifndef_ripper((yyval.val) = tEQ); }
06473     break;
06474 
06475   case 130:
06476 /* Line 1787 of yacc.c  */
06477 #line 1865 "ripper.y"
06478     { ifndef_ripper((yyval.val) = tEQQ); }
06479     break;
06480 
06481   case 131:
06482 /* Line 1787 of yacc.c  */
06483 #line 1866 "ripper.y"
06484     { ifndef_ripper((yyval.val) = tMATCH); }
06485     break;
06486 
06487   case 132:
06488 /* Line 1787 of yacc.c  */
06489 #line 1867 "ripper.y"
06490     { ifndef_ripper((yyval.val) = tNMATCH); }
06491     break;
06492 
06493   case 133:
06494 /* Line 1787 of yacc.c  */
06495 #line 1868 "ripper.y"
06496     { ifndef_ripper((yyval.val) = '>'); }
06497     break;
06498 
06499   case 134:
06500 /* Line 1787 of yacc.c  */
06501 #line 1869 "ripper.y"
06502     { ifndef_ripper((yyval.val) = tGEQ); }
06503     break;
06504 
06505   case 135:
06506 /* Line 1787 of yacc.c  */
06507 #line 1870 "ripper.y"
06508     { ifndef_ripper((yyval.val) = '<'); }
06509     break;
06510 
06511   case 136:
06512 /* Line 1787 of yacc.c  */
06513 #line 1871 "ripper.y"
06514     { ifndef_ripper((yyval.val) = tLEQ); }
06515     break;
06516 
06517   case 137:
06518 /* Line 1787 of yacc.c  */
06519 #line 1872 "ripper.y"
06520     { ifndef_ripper((yyval.val) = tNEQ); }
06521     break;
06522 
06523   case 138:
06524 /* Line 1787 of yacc.c  */
06525 #line 1873 "ripper.y"
06526     { ifndef_ripper((yyval.val) = tLSHFT); }
06527     break;
06528 
06529   case 139:
06530 /* Line 1787 of yacc.c  */
06531 #line 1874 "ripper.y"
06532     { ifndef_ripper((yyval.val) = tRSHFT); }
06533     break;
06534 
06535   case 140:
06536 /* Line 1787 of yacc.c  */
06537 #line 1875 "ripper.y"
06538     { ifndef_ripper((yyval.val) = '+'); }
06539     break;
06540 
06541   case 141:
06542 /* Line 1787 of yacc.c  */
06543 #line 1876 "ripper.y"
06544     { ifndef_ripper((yyval.val) = '-'); }
06545     break;
06546 
06547   case 142:
06548 /* Line 1787 of yacc.c  */
06549 #line 1877 "ripper.y"
06550     { ifndef_ripper((yyval.val) = '*'); }
06551     break;
06552 
06553   case 143:
06554 /* Line 1787 of yacc.c  */
06555 #line 1878 "ripper.y"
06556     { ifndef_ripper((yyval.val) = '*'); }
06557     break;
06558 
06559   case 144:
06560 /* Line 1787 of yacc.c  */
06561 #line 1879 "ripper.y"
06562     { ifndef_ripper((yyval.val) = '/'); }
06563     break;
06564 
06565   case 145:
06566 /* Line 1787 of yacc.c  */
06567 #line 1880 "ripper.y"
06568     { ifndef_ripper((yyval.val) = '%'); }
06569     break;
06570 
06571   case 146:
06572 /* Line 1787 of yacc.c  */
06573 #line 1881 "ripper.y"
06574     { ifndef_ripper((yyval.val) = tPOW); }
06575     break;
06576 
06577   case 147:
06578 /* Line 1787 of yacc.c  */
06579 #line 1882 "ripper.y"
06580     { ifndef_ripper((yyval.val) = '!'); }
06581     break;
06582 
06583   case 148:
06584 /* Line 1787 of yacc.c  */
06585 #line 1883 "ripper.y"
06586     { ifndef_ripper((yyval.val) = '~'); }
06587     break;
06588 
06589   case 149:
06590 /* Line 1787 of yacc.c  */
06591 #line 1884 "ripper.y"
06592     { ifndef_ripper((yyval.val) = tUPLUS); }
06593     break;
06594 
06595   case 150:
06596 /* Line 1787 of yacc.c  */
06597 #line 1885 "ripper.y"
06598     { ifndef_ripper((yyval.val) = tUMINUS); }
06599     break;
06600 
06601   case 151:
06602 /* Line 1787 of yacc.c  */
06603 #line 1886 "ripper.y"
06604     { ifndef_ripper((yyval.val) = tAREF); }
06605     break;
06606 
06607   case 152:
06608 /* Line 1787 of yacc.c  */
06609 #line 1887 "ripper.y"
06610     { ifndef_ripper((yyval.val) = tASET); }
06611     break;
06612 
06613   case 153:
06614 /* Line 1787 of yacc.c  */
06615 #line 1888 "ripper.y"
06616     { ifndef_ripper((yyval.val) = '`'); }
06617     break;
06618 
06619   case 195:
06620 /* Line 1787 of yacc.c  */
06621 #line 1906 "ripper.y"
06622     {
06623 #if 0
06624                         value_expr((yyvsp[(3) - (3)].val));
06625                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06626 #endif
06627                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06628 
06629                     }
06630     break;
06631 
06632   case 196:
06633 /* Line 1787 of yacc.c  */
06634 #line 1915 "ripper.y"
06635     {
06636 #if 0
06637                         value_expr((yyvsp[(3) - (5)].val));
06638                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06639                         (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06640 #endif
06641                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
06642 
06643                     }
06644     break;
06645 
06646   case 197:
06647 /* Line 1787 of yacc.c  */
06648 #line 1925 "ripper.y"
06649     {
06650 #if 0
06651                         value_expr((yyvsp[(3) - (3)].val));
06652                         if ((yyvsp[(1) - (3)].val)) {
06653                             ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
06654                             if ((yyvsp[(2) - (3)].val) == tOROP) {
06655                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
06656                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
06657                                 if (is_asgn_or_id(vid)) {
06658                                     (yyval.val)->nd_aid = vid;
06659                                 }
06660                             }
06661                             else if ((yyvsp[(2) - (3)].val) == tANDOP) {
06662                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
06663                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
06664                             }
06665                             else {
06666                                 (yyval.val) = (yyvsp[(1) - (3)].val);
06667                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
06668                             }
06669                         }
06670                         else {
06671                             (yyval.val) = NEW_BEGIN(0);
06672                         }
06673 #endif
06674                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06675 
06676                     }
06677     break;
06678 
06679   case 198:
06680 /* Line 1787 of yacc.c  */
06681 #line 1954 "ripper.y"
06682     {
06683 #if 0
06684                         value_expr((yyvsp[(3) - (5)].val));
06685                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06686                         if ((yyvsp[(1) - (5)].val)) {
06687                             ID vid = (yyvsp[(1) - (5)].val)->nd_vid;
06688                             if ((yyvsp[(2) - (5)].val) == tOROP) {
06689                                 (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
06690                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (5)].val));
06691                                 if (is_asgn_or_id(vid)) {
06692                                     (yyval.val)->nd_aid = vid;
06693                                 }
06694                             }
06695                             else if ((yyvsp[(2) - (5)].val) == tANDOP) {
06696                                 (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
06697                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (5)].val));
06698                             }
06699                             else {
06700                                 (yyval.val) = (yyvsp[(1) - (5)].val);
06701                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (5)].val), NEW_LIST((yyvsp[(3) - (5)].val)));
06702                             }
06703                         }
06704                         else {
06705                             (yyval.val) = NEW_BEGIN(0);
06706                         }
06707 #endif
06708                         (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
06709                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
06710 
06711                     }
06712     break;
06713 
06714   case 199:
06715 /* Line 1787 of yacc.c  */
06716 #line 1985 "ripper.y"
06717     {
06718 #if 0
06719                         NODE *args;
06720 
06721                         value_expr((yyvsp[(6) - (6)].val));
06722                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
06723                         if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
06724                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06725                         }
06726                         else {
06727                             args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06728                         }
06729                         if ((yyvsp[(5) - (6)].val) == tOROP) {
06730                             (yyvsp[(5) - (6)].val) = 0;
06731                         }
06732                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
06733                             (yyvsp[(5) - (6)].val) = 1;
06734                         }
06735                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
06736                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
06737 #endif
06738                         (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
06739                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
06740 
06741                     }
06742     break;
06743 
06744   case 200:
06745 /* Line 1787 of yacc.c  */
06746 #line 2011 "ripper.y"
06747     {
06748 #if 0
06749                         value_expr((yyvsp[(5) - (5)].val));
06750                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06751                             (yyvsp[(4) - (5)].val) = 0;
06752                         }
06753                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06754                             (yyvsp[(4) - (5)].val) = 1;
06755                         }
06756                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06757                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06758 #endif
06759                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
06760                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06761 
06762                     }
06763     break;
06764 
06765   case 201:
06766 /* Line 1787 of yacc.c  */
06767 #line 2028 "ripper.y"
06768     {
06769 #if 0
06770                         value_expr((yyvsp[(5) - (5)].val));
06771                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06772                             (yyvsp[(4) - (5)].val) = 0;
06773                         }
06774                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06775                             (yyvsp[(4) - (5)].val) = 1;
06776                         }
06777                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06778                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06779 #endif
06780                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
06781                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06782 
06783                     }
06784     break;
06785 
06786   case 202:
06787 /* Line 1787 of yacc.c  */
06788 #line 2045 "ripper.y"
06789     {
06790 #if 0
06791                         value_expr((yyvsp[(5) - (5)].val));
06792                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06793                             (yyvsp[(4) - (5)].val) = 0;
06794                         }
06795                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06796                             (yyvsp[(4) - (5)].val) = 1;
06797                         }
06798                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06799                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06800 #endif
06801                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
06802                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06803 
06804                     }
06805     break;
06806 
06807   case 203:
06808 /* Line 1787 of yacc.c  */
06809 #line 2062 "ripper.y"
06810     {
06811 #if 0
06812                         yyerror("constant re-assignment");
06813                         (yyval.val) = NEW_BEGIN(0);
06814 #endif
06815                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06816                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06817                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06818 
06819                     }
06820     break;
06821 
06822   case 204:
06823 /* Line 1787 of yacc.c  */
06824 #line 2073 "ripper.y"
06825     {
06826 #if 0
06827                         yyerror("constant re-assignment");
06828                         (yyval.val) = NEW_BEGIN(0);
06829 #endif
06830                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
06831                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06832                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06833 
06834                     }
06835     break;
06836 
06837   case 205:
06838 /* Line 1787 of yacc.c  */
06839 #line 2084 "ripper.y"
06840     {
06841 #if 0
06842                         rb_backref_error((yyvsp[(1) - (3)].val));
06843                         (yyval.val) = NEW_BEGIN(0);
06844 #endif
06845                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
06846                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06847                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06848 
06849                     }
06850     break;
06851 
06852   case 206:
06853 /* Line 1787 of yacc.c  */
06854 #line 2095 "ripper.y"
06855     {
06856 #if 0
06857                         value_expr((yyvsp[(1) - (3)].val));
06858                         value_expr((yyvsp[(3) - (3)].val));
06859                         (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06860                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06861                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06862                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06863                         }
06864 #endif
06865                         (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06866 
06867                     }
06868     break;
06869 
06870   case 207:
06871 /* Line 1787 of yacc.c  */
06872 #line 2109 "ripper.y"
06873     {
06874 #if 0
06875                         value_expr((yyvsp[(1) - (3)].val));
06876                         value_expr((yyvsp[(3) - (3)].val));
06877                         (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06878                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06879                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06880                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06881                         }
06882 #endif
06883                         (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06884 
06885                     }
06886     break;
06887 
06888   case 208:
06889 /* Line 1787 of yacc.c  */
06890 #line 2123 "ripper.y"
06891     {
06892 #if 0
06893                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
06894 #endif
06895                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
06896 
06897                     }
06898     break;
06899 
06900   case 209:
06901 /* Line 1787 of yacc.c  */
06902 #line 2131 "ripper.y"
06903     {
06904 #if 0
06905                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
06906 #endif
06907                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
06908 
06909                     }
06910     break;
06911 
06912   case 210:
06913 /* Line 1787 of yacc.c  */
06914 #line 2139 "ripper.y"
06915     {
06916 #if 0
06917                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
06918 #endif
06919                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
06920 
06921                     }
06922     break;
06923 
06924   case 211:
06925 /* Line 1787 of yacc.c  */
06926 #line 2147 "ripper.y"
06927     {
06928 #if 0
06929                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
06930 #endif
06931                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
06932 
06933                     }
06934     break;
06935 
06936   case 212:
06937 /* Line 1787 of yacc.c  */
06938 #line 2155 "ripper.y"
06939     {
06940 #if 0
06941                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
06942 #endif
06943                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
06944 
06945                     }
06946     break;
06947 
06948   case 213:
06949 /* Line 1787 of yacc.c  */
06950 #line 2163 "ripper.y"
06951     {
06952 #if 0
06953                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
06954 #endif
06955                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
06956 
06957                     }
06958     break;
06959 
06960   case 214:
06961 /* Line 1787 of yacc.c  */
06962 #line 2171 "ripper.y"
06963     {
06964 #if 0
06965                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
06966 #endif
06967                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
06968                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
06969 
06970                     }
06971     break;
06972 
06973   case 215:
06974 /* Line 1787 of yacc.c  */
06975 #line 2180 "ripper.y"
06976     {
06977 #if 0
06978                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
06979 #endif
06980                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
06981                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
06982 
06983                     }
06984     break;
06985 
06986   case 216:
06987 /* Line 1787 of yacc.c  */
06988 #line 2189 "ripper.y"
06989     {
06990 #if 0
06991                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
06992 #endif
06993                         (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
06994 
06995                     }
06996     break;
06997 
06998   case 217:
06999 /* Line 1787 of yacc.c  */
07000 #line 2197 "ripper.y"
07001     {
07002 #if 0
07003                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
07004 #endif
07005                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
07006 
07007                     }
07008     break;
07009 
07010   case 218:
07011 /* Line 1787 of yacc.c  */
07012 #line 2205 "ripper.y"
07013     {
07014 #if 0
07015                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
07016 #endif
07017                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
07018 
07019                     }
07020     break;
07021 
07022   case 219:
07023 /* Line 1787 of yacc.c  */
07024 #line 2213 "ripper.y"
07025     {
07026 #if 0
07027                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
07028 #endif
07029                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
07030 
07031                     }
07032     break;
07033 
07034   case 220:
07035 /* Line 1787 of yacc.c  */
07036 #line 2221 "ripper.y"
07037     {
07038 #if 0
07039                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
07040 #endif
07041                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
07042 
07043                     }
07044     break;
07045 
07046   case 221:
07047 /* Line 1787 of yacc.c  */
07048 #line 2229 "ripper.y"
07049     {
07050 #if 0
07051                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
07052 #endif
07053                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
07054 
07055                     }
07056     break;
07057 
07058   case 222:
07059 /* Line 1787 of yacc.c  */
07060 #line 2237 "ripper.y"
07061     {
07062 #if 0
07063                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
07064 #endif
07065                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
07066 
07067                     }
07068     break;
07069 
07070   case 223:
07071 /* Line 1787 of yacc.c  */
07072 #line 2245 "ripper.y"
07073     {
07074 #if 0
07075                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
07076 #endif
07077                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
07078 
07079                     }
07080     break;
07081 
07082   case 224:
07083 /* Line 1787 of yacc.c  */
07084 #line 2253 "ripper.y"
07085     {
07086 #if 0
07087                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
07088 #endif
07089                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
07090 
07091                     }
07092     break;
07093 
07094   case 225:
07095 /* Line 1787 of yacc.c  */
07096 #line 2261 "ripper.y"
07097     {
07098 #if 0
07099                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
07100 #endif
07101                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
07102 
07103                     }
07104     break;
07105 
07106   case 226:
07107 /* Line 1787 of yacc.c  */
07108 #line 2269 "ripper.y"
07109     {
07110 #if 0
07111                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
07112 #endif
07113                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
07114 
07115                     }
07116     break;
07117 
07118   case 227:
07119 /* Line 1787 of yacc.c  */
07120 #line 2277 "ripper.y"
07121     {
07122 #if 0
07123                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
07124 #endif
07125                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
07126 
07127                     }
07128     break;
07129 
07130   case 228:
07131 /* Line 1787 of yacc.c  */
07132 #line 2285 "ripper.y"
07133     {
07134 #if 0
07135                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
07136 #endif
07137                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
07138 
07139                     }
07140     break;
07141 
07142   case 229:
07143 /* Line 1787 of yacc.c  */
07144 #line 2293 "ripper.y"
07145     {
07146 #if 0
07147                         (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07148                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && TYPE((yyvsp[(1) - (3)].val)->nd_lit) == T_REGEXP) {
07149                             (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
07150                         }
07151 #endif
07152                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
07153 
07154                     }
07155     break;
07156 
07157   case 230:
07158 /* Line 1787 of yacc.c  */
07159 #line 2304 "ripper.y"
07160     {
07161 #if 0
07162                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
07163 #endif
07164                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
07165 
07166                     }
07167     break;
07168 
07169   case 231:
07170 /* Line 1787 of yacc.c  */
07171 #line 2312 "ripper.y"
07172     {
07173 #if 0
07174                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
07175 #endif
07176                         (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
07177 
07178                     }
07179     break;
07180 
07181   case 232:
07182 /* Line 1787 of yacc.c  */
07183 #line 2320 "ripper.y"
07184     {
07185 #if 0
07186                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
07187 #endif
07188                         (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
07189 
07190                     }
07191     break;
07192 
07193   case 233:
07194 /* Line 1787 of yacc.c  */
07195 #line 2328 "ripper.y"
07196     {
07197 #if 0
07198                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (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 234:
07206 /* Line 1787 of yacc.c  */
07207 #line 2336 "ripper.y"
07208     {
07209 #if 0
07210                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
07211 #endif
07212                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
07213 
07214                     }
07215     break;
07216 
07217   case 235:
07218 /* Line 1787 of yacc.c  */
07219 #line 2344 "ripper.y"
07220     {
07221 #if 0
07222                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07223 #endif
07224                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
07225 
07226                     }
07227     break;
07228 
07229   case 236:
07230 /* Line 1787 of yacc.c  */
07231 #line 2352 "ripper.y"
07232     {
07233 #if 0
07234                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07235 #endif
07236                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
07237 
07238                     }
07239     break;
07240 
07241   case 237:
07242 /* Line 1787 of yacc.c  */
07243 #line 2359 "ripper.y"
07244     {in_defined = 1;}
07245     break;
07246 
07247   case 238:
07248 /* Line 1787 of yacc.c  */
07249 #line 2360 "ripper.y"
07250     {
07251 #if 0
07252                         in_defined = 0;
07253                         (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
07254 #endif
07255                         in_defined = 0;
07256                         (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
07257 
07258                     }
07259     break;
07260 
07261   case 239:
07262 /* Line 1787 of yacc.c  */
07263 #line 2370 "ripper.y"
07264     {
07265 #if 0
07266                         value_expr((yyvsp[(1) - (6)].val));
07267                         (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07268                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07269 #endif
07270                         (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07271 
07272                     }
07273     break;
07274 
07275   case 240:
07276 /* Line 1787 of yacc.c  */
07277 #line 2380 "ripper.y"
07278     {
07279                         (yyval.val) = (yyvsp[(1) - (1)].val);
07280                     }
07281     break;
07282 
07283   case 241:
07284 /* Line 1787 of yacc.c  */
07285 #line 2386 "ripper.y"
07286     {
07287 #if 0
07288                         value_expr((yyvsp[(1) - (1)].val));
07289                         (yyval.val) = (yyvsp[(1) - (1)].val);
07290                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
07291 #endif
07292                         (yyval.val) = (yyvsp[(1) - (1)].val);
07293 
07294                     }
07295     break;
07296 
07297   case 243:
07298 /* Line 1787 of yacc.c  */
07299 #line 2399 "ripper.y"
07300     {
07301                         (yyval.val) = (yyvsp[(1) - (2)].val);
07302                     }
07303     break;
07304 
07305   case 244:
07306 /* Line 1787 of yacc.c  */
07307 #line 2403 "ripper.y"
07308     {
07309 #if 0
07310                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07311 #endif
07312                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07313 
07314                     }
07315     break;
07316 
07317   case 245:
07318 /* Line 1787 of yacc.c  */
07319 #line 2411 "ripper.y"
07320     {
07321 #if 0
07322                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07323 #endif
07324                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07325 
07326                     }
07327     break;
07328 
07329   case 246:
07330 /* Line 1787 of yacc.c  */
07331 #line 2421 "ripper.y"
07332     {
07333 #if 0
07334                         (yyval.val) = (yyvsp[(2) - (3)].val);
07335 #endif
07336                         (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
07337 
07338                     }
07339     break;
07340 
07341   case 251:
07342 /* Line 1787 of yacc.c  */
07343 #line 2437 "ripper.y"
07344     {
07345                       (yyval.val) = (yyvsp[(1) - (2)].val);
07346                     }
07347     break;
07348 
07349   case 252:
07350 /* Line 1787 of yacc.c  */
07351 #line 2441 "ripper.y"
07352     {
07353 #if 0
07354                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07355 #endif
07356                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07357 
07358                     }
07359     break;
07360 
07361   case 253:
07362 /* Line 1787 of yacc.c  */
07363 #line 2449 "ripper.y"
07364     {
07365 #if 0
07366                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07367 #endif
07368                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07369 
07370                     }
07371     break;
07372 
07373   case 254:
07374 /* Line 1787 of yacc.c  */
07375 #line 2459 "ripper.y"
07376     {
07377 #if 0
07378                         value_expr((yyvsp[(1) - (1)].val));
07379                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07380 #endif
07381                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07382 
07383                     }
07384     break;
07385 
07386   case 255:
07387 /* Line 1787 of yacc.c  */
07388 #line 2468 "ripper.y"
07389     {
07390 #if 0
07391                         (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07392 #endif
07393                         (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07394 
07395                     }
07396     break;
07397 
07398   case 256:
07399 /* Line 1787 of yacc.c  */
07400 #line 2476 "ripper.y"
07401     {
07402 #if 0
07403                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07404                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
07405 #endif
07406                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07407                         (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
07408 
07409                     }
07410     break;
07411 
07412   case 257:
07413 /* Line 1787 of yacc.c  */
07414 #line 2486 "ripper.y"
07415     {
07416 #if 0
07417                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07418                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
07419 #endif
07420                         (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
07421 
07422                     }
07423     break;
07424 
07425   case 258:
07426 /* Line 1787 of yacc.c  */
07427 #line 2497 "ripper.y"
07428     {
07429                         (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
07430                     }
07431     break;
07432 
07433   case 259:
07434 /* Line 1787 of yacc.c  */
07435 #line 2503 "ripper.y"
07436     {
07437                         (yyval.val) = cmdarg_stack;
07438                         CMDARG_PUSH(1);
07439                     }
07440     break;
07441 
07442   case 260:
07443 /* Line 1787 of yacc.c  */
07444 #line 2508 "ripper.y"
07445     {
07446                         /* CMDARG_POP() */
07447                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07448                         (yyval.val) = (yyvsp[(2) - (2)].val);
07449                     }
07450     break;
07451 
07452   case 261:
07453 /* Line 1787 of yacc.c  */
07454 #line 2516 "ripper.y"
07455     {
07456 #if 0
07457                         (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
07458 #endif
07459                         (yyval.val) = (yyvsp[(2) - (2)].val);
07460 
07461                     }
07462     break;
07463 
07464   case 262:
07465 /* Line 1787 of yacc.c  */
07466 #line 2526 "ripper.y"
07467     {
07468                         (yyval.val) = (yyvsp[(2) - (2)].val);
07469                     }
07470     break;
07471 
07472   case 263:
07473 /* Line 1787 of yacc.c  */
07474 #line 2530 "ripper.y"
07475     {
07476                         (yyval.val) = 0;
07477                     }
07478     break;
07479 
07480   case 264:
07481 /* Line 1787 of yacc.c  */
07482 #line 2536 "ripper.y"
07483     {
07484 #if 0
07485                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07486 #endif
07487                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07488 
07489                     }
07490     break;
07491 
07492   case 265:
07493 /* Line 1787 of yacc.c  */
07494 #line 2544 "ripper.y"
07495     {
07496 #if 0
07497                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07498 #endif
07499                         (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
07500 
07501                     }
07502     break;
07503 
07504   case 266:
07505 /* Line 1787 of yacc.c  */
07506 #line 2552 "ripper.y"
07507     {
07508 #if 0
07509                         NODE *n1;
07510                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07511                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07512                         }
07513                         else {
07514                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07515                         }
07516 #endif
07517                         (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07518 
07519                     }
07520     break;
07521 
07522   case 267:
07523 /* Line 1787 of yacc.c  */
07524 #line 2566 "ripper.y"
07525     {
07526 #if 0
07527                         NODE *n1;
07528                         if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07529                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07530                         }
07531                         else {
07532                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07533                         }
07534 #endif
07535                         (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07536 
07537                     }
07538     break;
07539 
07540   case 268:
07541 /* Line 1787 of yacc.c  */
07542 #line 2582 "ripper.y"
07543     {
07544 #if 0
07545                         NODE *n1;
07546                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07547                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07548                         }
07549                         else {
07550                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07551                         }
07552 #endif
07553                         (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
07554 
07555                     }
07556     break;
07557 
07558   case 269:
07559 /* Line 1787 of yacc.c  */
07560 #line 2596 "ripper.y"
07561     {
07562 #if 0
07563                         NODE *n1;
07564                         if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
07565                             (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07566                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07567                         }
07568                         else {
07569                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07570                         }
07571 #endif
07572                         (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
07573 
07574                     }
07575     break;
07576 
07577   case 270:
07578 /* Line 1787 of yacc.c  */
07579 #line 2611 "ripper.y"
07580     {
07581 #if 0
07582                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07583 #endif
07584                         (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
07585 
07586                     }
07587     break;
07588 
07589   case 279:
07590 /* Line 1787 of yacc.c  */
07591 #line 2629 "ripper.y"
07592     {
07593 #if 0
07594                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
07595 #endif
07596                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
07597 
07598                     }
07599     break;
07600 
07601   case 280:
07602 /* Line 1787 of yacc.c  */
07603 #line 2637 "ripper.y"
07604     {
07605 #if 0
07606                         (yyval.num) = ruby_sourceline;
07607 #endif
07608 
07609                     }
07610     break;
07611 
07612   case 281:
07613 /* Line 1787 of yacc.c  */
07614 #line 2645 "ripper.y"
07615     {
07616 #if 0
07617                         if ((yyvsp[(3) - (4)].val) == NULL) {
07618                             (yyval.val) = NEW_NIL();
07619                         }
07620                         else {
07621                             if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
07622                                 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
07623                                 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
07624                             (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
07625                         }
07626                         nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
07627 #endif
07628                         (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
07629 
07630                     }
07631     break;
07632 
07633   case 282:
07634 /* Line 1787 of yacc.c  */
07635 #line 2661 "ripper.y"
07636     {lex_state = EXPR_ENDARG;}
07637     break;
07638 
07639   case 283:
07640 /* Line 1787 of yacc.c  */
07641 #line 2662 "ripper.y"
07642     {
07643                         rb_warning0("(...) interpreted as grouped expression");
07644 #if 0
07645                         (yyval.val) = (yyvsp[(2) - (4)].val);
07646 #endif
07647                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
07648 
07649                     }
07650     break;
07651 
07652   case 284:
07653 /* Line 1787 of yacc.c  */
07654 #line 2671 "ripper.y"
07655     {
07656 #if 0
07657                         (yyval.val) = (yyvsp[(2) - (3)].val);
07658 #endif
07659                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
07660 
07661                     }
07662     break;
07663 
07664   case 285:
07665 /* Line 1787 of yacc.c  */
07666 #line 2679 "ripper.y"
07667     {
07668 #if 0
07669                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07670 #endif
07671                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07672 
07673                     }
07674     break;
07675 
07676   case 286:
07677 /* Line 1787 of yacc.c  */
07678 #line 2687 "ripper.y"
07679     {
07680 #if 0
07681                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
07682 #endif
07683                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
07684 
07685                     }
07686     break;
07687 
07688   case 287:
07689 /* Line 1787 of yacc.c  */
07690 #line 2695 "ripper.y"
07691     {
07692 #if 0
07693                         if ((yyvsp[(2) - (3)].val) == 0) {
07694                             (yyval.val) = NEW_ZARRAY(); /* zero length array*/
07695                         }
07696                         else {
07697                             (yyval.val) = (yyvsp[(2) - (3)].val);
07698                         }
07699 #endif
07700                         (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
07701 
07702                     }
07703     break;
07704 
07705   case 288:
07706 /* Line 1787 of yacc.c  */
07707 #line 2708 "ripper.y"
07708     {
07709 #if 0
07710                         (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
07711 #endif
07712                         (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
07713 
07714                     }
07715     break;
07716 
07717   case 289:
07718 /* Line 1787 of yacc.c  */
07719 #line 2716 "ripper.y"
07720     {
07721 #if 0
07722                         (yyval.val) = NEW_RETURN(0);
07723 #endif
07724                         (yyval.val) = dispatch0(return0);
07725 
07726                     }
07727     break;
07728 
07729   case 290:
07730 /* Line 1787 of yacc.c  */
07731 #line 2724 "ripper.y"
07732     {
07733 #if 0
07734                         (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
07735 #endif
07736                         (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
07737 
07738                     }
07739     break;
07740 
07741   case 291:
07742 /* Line 1787 of yacc.c  */
07743 #line 2732 "ripper.y"
07744     {
07745 #if 0
07746                         (yyval.val) = NEW_YIELD(0, Qfalse);
07747 #endif
07748                         (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
07749 
07750                     }
07751     break;
07752 
07753   case 292:
07754 /* Line 1787 of yacc.c  */
07755 #line 2740 "ripper.y"
07756     {
07757 #if 0
07758                         (yyval.val) = NEW_YIELD(0, Qfalse);
07759 #endif
07760                         (yyval.val) = dispatch0(yield0);
07761 
07762                     }
07763     break;
07764 
07765   case 293:
07766 /* Line 1787 of yacc.c  */
07767 #line 2747 "ripper.y"
07768     {in_defined = 1;}
07769     break;
07770 
07771   case 294:
07772 /* Line 1787 of yacc.c  */
07773 #line 2748 "ripper.y"
07774     {
07775 #if 0
07776                         in_defined = 0;
07777                         (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
07778 #endif
07779                         in_defined = 0;
07780                         (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
07781 
07782                     }
07783     break;
07784 
07785   case 295:
07786 /* Line 1787 of yacc.c  */
07787 #line 2758 "ripper.y"
07788     {
07789 #if 0
07790                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
07791 #endif
07792                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
07793 
07794                     }
07795     break;
07796 
07797   case 296:
07798 /* Line 1787 of yacc.c  */
07799 #line 2766 "ripper.y"
07800     {
07801 #if 0
07802                         (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
07803 #endif
07804                         (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
07805 
07806                     }
07807     break;
07808 
07809   case 297:
07810 /* Line 1787 of yacc.c  */
07811 #line 2774 "ripper.y"
07812     {
07813 #if 0
07814                         (yyvsp[(2) - (2)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].val), 0);
07815                         (yyval.val) = (yyvsp[(2) - (2)].val);
07816                         fixpos((yyvsp[(2) - (2)].val)->nd_iter, (yyvsp[(2) - (2)].val));
07817 #endif
07818                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
07819                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
07820 
07821                     }
07822     break;
07823 
07824   case 299:
07825 /* Line 1787 of yacc.c  */
07826 #line 2786 "ripper.y"
07827     {
07828 #if 0
07829                         block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
07830                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
07831                         (yyval.val) = (yyvsp[(2) - (2)].val);
07832                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
07833 #endif
07834                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07835 
07836                     }
07837     break;
07838 
07839   case 300:
07840 /* Line 1787 of yacc.c  */
07841 #line 2797 "ripper.y"
07842     {
07843                         (yyval.val) = (yyvsp[(2) - (2)].val);
07844                     }
07845     break;
07846 
07847   case 301:
07848 /* Line 1787 of yacc.c  */
07849 #line 2804 "ripper.y"
07850     {
07851 #if 0
07852                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07853                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07854 #endif
07855                         (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07856 
07857                     }
07858     break;
07859 
07860   case 302:
07861 /* Line 1787 of yacc.c  */
07862 #line 2816 "ripper.y"
07863     {
07864 #if 0
07865                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07866                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07867 #endif
07868                         (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07869 
07870                     }
07871     break;
07872 
07873   case 303:
07874 /* Line 1787 of yacc.c  */
07875 #line 2824 "ripper.y"
07876     {COND_PUSH(1);}
07877     break;
07878 
07879   case 304:
07880 /* Line 1787 of yacc.c  */
07881 #line 2824 "ripper.y"
07882     {COND_POP();}
07883     break;
07884 
07885   case 305:
07886 /* Line 1787 of yacc.c  */
07887 #line 2827 "ripper.y"
07888     {
07889 #if 0
07890                         (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07891                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07892 #endif
07893                         (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07894 
07895                     }
07896     break;
07897 
07898   case 306:
07899 /* Line 1787 of yacc.c  */
07900 #line 2835 "ripper.y"
07901     {COND_PUSH(1);}
07902     break;
07903 
07904   case 307:
07905 /* Line 1787 of yacc.c  */
07906 #line 2835 "ripper.y"
07907     {COND_POP();}
07908     break;
07909 
07910   case 308:
07911 /* Line 1787 of yacc.c  */
07912 #line 2838 "ripper.y"
07913     {
07914 #if 0
07915                         (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07916                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07917 #endif
07918                         (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07919 
07920                     }
07921     break;
07922 
07923   case 309:
07924 /* Line 1787 of yacc.c  */
07925 #line 2849 "ripper.y"
07926     {
07927 #if 0
07928                         (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
07929                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
07930 #endif
07931                         (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
07932 
07933                     }
07934     break;
07935 
07936   case 310:
07937 /* Line 1787 of yacc.c  */
07938 #line 2858 "ripper.y"
07939     {
07940 #if 0
07941                         (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
07942 #endif
07943                         (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
07944 
07945                     }
07946     break;
07947 
07948   case 311:
07949 /* Line 1787 of yacc.c  */
07950 #line 2866 "ripper.y"
07951     {COND_PUSH(1);}
07952     break;
07953 
07954   case 312:
07955 /* Line 1787 of yacc.c  */
07956 #line 2868 "ripper.y"
07957     {COND_POP();}
07958     break;
07959 
07960   case 313:
07961 /* Line 1787 of yacc.c  */
07962 #line 2871 "ripper.y"
07963     {
07964 #if 0
07965                         /*
07966                          *  for a, b, c in e
07967                          *  #=>
07968                          *  e.each{|*x| a, b, c = x
07969                          *
07970                          *  for a in e
07971                          *  #=>
07972                          *  e.each{|x| a, = x}
07973                          */
07974                         ID id = internal_id();
07975                         ID *tbl = ALLOC_N(ID, 2);
07976                         NODE *m = NEW_ARGS_AUX(0, 0);
07977                         NODE *args, *scope;
07978 
07979                         if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
07980                             /* if args.length == 1 && args[0].kind_of?(Array)
07981                              *   args = args[0]
07982                              * end
07983                              */
07984                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
07985                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
07986                             m->nd_next = block_append(
07987                                 NEW_IF(
07988                                     NEW_NODE(NODE_AND,
07989                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
07990                                                       rb_intern("=="), one),
07991                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
07992                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
07993                                              0),
07994                                     NEW_DASGN_CURR(id,
07995                                                    NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
07996                                     0),
07997                                 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
07998 
07999                             args = new_args(m, 0, id, 0, 0);
08000                         }
08001                         else {
08002                             if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
08003                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
08004                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
08005                                 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
08006                                 m->nd_plen = 1;
08007                                 m->nd_next = (yyvsp[(2) - (9)].val);
08008                                 args = new_args(m, 0, 0, 0, 0);
08009                             }
08010                             else {
08011                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
08012                                 args = new_args(m, 0, id, 0, 0);
08013                             }
08014                         }
08015                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
08016                         tbl[0] = 1; tbl[1] = id;
08017                         (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
08018                         fixpos((yyval.val), (yyvsp[(2) - (9)].val));
08019 #endif
08020                         (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
08021 
08022                     }
08023     break;
08024 
08025   case 314:
08026 /* Line 1787 of yacc.c  */
08027 #line 2932 "ripper.y"
08028     {
08029                         if (in_def || in_single)
08030                             yyerror("class definition in method body");
08031                         local_push(0);
08032 #if 0
08033                         (yyval.num) = ruby_sourceline;
08034 #endif
08035 
08036                     }
08037     break;
08038 
08039   case 315:
08040 /* Line 1787 of yacc.c  */
08041 #line 2943 "ripper.y"
08042     {
08043 #if 0
08044                         (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
08045                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
08046 #endif
08047                         (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
08048 
08049                         local_pop();
08050                     }
08051     break;
08052 
08053   case 316:
08054 /* Line 1787 of yacc.c  */
08055 #line 2953 "ripper.y"
08056     {
08057                         (yyval.num) = in_def;
08058                         in_def = 0;
08059                     }
08060     break;
08061 
08062   case 317:
08063 /* Line 1787 of yacc.c  */
08064 #line 2958 "ripper.y"
08065     {
08066                         (yyval.num) = in_single;
08067                         in_single = 0;
08068                         local_push(0);
08069                     }
08070     break;
08071 
08072   case 318:
08073 /* Line 1787 of yacc.c  */
08074 #line 2965 "ripper.y"
08075     {
08076 #if 0
08077                         (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08078                         fixpos((yyval.val), (yyvsp[(3) - (8)].val));
08079 #endif
08080                         (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08081 
08082                         local_pop();
08083                         in_def = (yyvsp[(4) - (8)].num);
08084                         in_single = (yyvsp[(6) - (8)].num);
08085                     }
08086     break;
08087 
08088   case 319:
08089 /* Line 1787 of yacc.c  */
08090 #line 2977 "ripper.y"
08091     {
08092                         if (in_def || in_single)
08093                             yyerror("module definition in method body");
08094                         local_push(0);
08095 #if 0
08096                         (yyval.num) = ruby_sourceline;
08097 #endif
08098 
08099                     }
08100     break;
08101 
08102   case 320:
08103 /* Line 1787 of yacc.c  */
08104 #line 2988 "ripper.y"
08105     {
08106 #if 0
08107                         (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08108                         nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
08109 #endif
08110                         (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08111 
08112                         local_pop();
08113                     }
08114     break;
08115 
08116   case 321:
08117 /* Line 1787 of yacc.c  */
08118 #line 2998 "ripper.y"
08119     {
08120                         (yyval.id) = cur_mid;
08121                         cur_mid = (yyvsp[(2) - (2)].val);
08122                         in_def++;
08123                         local_push(0);
08124                     }
08125     break;
08126 
08127   case 322:
08128 /* Line 1787 of yacc.c  */
08129 #line 3007 "ripper.y"
08130     {
08131 #if 0
08132                         NODE *body = remove_begin((yyvsp[(5) - (6)].val));
08133                         reduce_nodes(&body);
08134                         (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
08135                         nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
08136 #endif
08137                         (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08138 
08139                         local_pop();
08140                         in_def--;
08141                         cur_mid = (yyvsp[(3) - (6)].id);
08142                     }
08143     break;
08144 
08145   case 323:
08146 /* Line 1787 of yacc.c  */
08147 #line 3020 "ripper.y"
08148     {lex_state = EXPR_FNAME;}
08149     break;
08150 
08151   case 324:
08152 /* Line 1787 of yacc.c  */
08153 #line 3021 "ripper.y"
08154     {
08155                         in_single++;
08156                         lex_state = EXPR_ENDFN; /* force for args */
08157                         local_push(0);
08158                     }
08159     break;
08160 
08161   case 325:
08162 /* Line 1787 of yacc.c  */
08163 #line 3029 "ripper.y"
08164     {
08165 #if 0
08166                         NODE *body = remove_begin((yyvsp[(8) - (9)].val));
08167                         reduce_nodes(&body);
08168                         (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
08169                         nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
08170 #endif
08171                         (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
08172 
08173                         local_pop();
08174                         in_single--;
08175                     }
08176     break;
08177 
08178   case 326:
08179 /* Line 1787 of yacc.c  */
08180 #line 3042 "ripper.y"
08181     {
08182 #if 0
08183                         (yyval.val) = NEW_BREAK(0);
08184 #endif
08185                         (yyval.val) = dispatch1(break, arg_new());
08186 
08187                     }
08188     break;
08189 
08190   case 327:
08191 /* Line 1787 of yacc.c  */
08192 #line 3050 "ripper.y"
08193     {
08194 #if 0
08195                         (yyval.val) = NEW_NEXT(0);
08196 #endif
08197                         (yyval.val) = dispatch1(next, arg_new());
08198 
08199                     }
08200     break;
08201 
08202   case 328:
08203 /* Line 1787 of yacc.c  */
08204 #line 3058 "ripper.y"
08205     {
08206 #if 0
08207                         (yyval.val) = NEW_REDO();
08208 #endif
08209                         (yyval.val) = dispatch0(redo);
08210 
08211                     }
08212     break;
08213 
08214   case 329:
08215 /* Line 1787 of yacc.c  */
08216 #line 3066 "ripper.y"
08217     {
08218 #if 0
08219                         (yyval.val) = NEW_RETRY();
08220 #endif
08221                         (yyval.val) = dispatch0(retry);
08222 
08223                     }
08224     break;
08225 
08226   case 330:
08227 /* Line 1787 of yacc.c  */
08228 #line 3076 "ripper.y"
08229     {
08230 #if 0
08231                         value_expr((yyvsp[(1) - (1)].val));
08232                         (yyval.val) = (yyvsp[(1) - (1)].val);
08233                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
08234 #endif
08235                         (yyval.val) = (yyvsp[(1) - (1)].val);
08236 
08237                     }
08238     break;
08239 
08240   case 331:
08241 /* Line 1787 of yacc.c  */
08242 #line 3088 "ripper.y"
08243     {
08244                         token_info_push("begin");
08245                     }
08246     break;
08247 
08248   case 332:
08249 /* Line 1787 of yacc.c  */
08250 #line 3094 "ripper.y"
08251     {
08252                         token_info_push("if");
08253                     }
08254     break;
08255 
08256   case 333:
08257 /* Line 1787 of yacc.c  */
08258 #line 3100 "ripper.y"
08259     {
08260                         token_info_push("unless");
08261                     }
08262     break;
08263 
08264   case 334:
08265 /* Line 1787 of yacc.c  */
08266 #line 3106 "ripper.y"
08267     {
08268                         token_info_push("while");
08269                     }
08270     break;
08271 
08272   case 335:
08273 /* Line 1787 of yacc.c  */
08274 #line 3112 "ripper.y"
08275     {
08276                         token_info_push("until");
08277                     }
08278     break;
08279 
08280   case 336:
08281 /* Line 1787 of yacc.c  */
08282 #line 3118 "ripper.y"
08283     {
08284                         token_info_push("case");
08285                     }
08286     break;
08287 
08288   case 337:
08289 /* Line 1787 of yacc.c  */
08290 #line 3124 "ripper.y"
08291     {
08292                         token_info_push("for");
08293                     }
08294     break;
08295 
08296   case 338:
08297 /* Line 1787 of yacc.c  */
08298 #line 3130 "ripper.y"
08299     {
08300                         token_info_push("class");
08301                     }
08302     break;
08303 
08304   case 339:
08305 /* Line 1787 of yacc.c  */
08306 #line 3136 "ripper.y"
08307     {
08308                         token_info_push("module");
08309                     }
08310     break;
08311 
08312   case 340:
08313 /* Line 1787 of yacc.c  */
08314 #line 3142 "ripper.y"
08315     {
08316                         token_info_push("def");
08317 #if 0
08318                         (yyval.num) = ruby_sourceline;
08319 #endif
08320 
08321                     }
08322     break;
08323 
08324   case 341:
08325 /* Line 1787 of yacc.c  */
08326 #line 3152 "ripper.y"
08327     {
08328                         token_info_pop("end");
08329                     }
08330     break;
08331 
08332   case 342:
08333 /* Line 1787 of yacc.c  */
08334 #line 3160 "ripper.y"
08335     { (yyval.val) = Qnil; }
08336     break;
08337 
08338   case 344:
08339 /* Line 1787 of yacc.c  */
08340 #line 3166 "ripper.y"
08341     { (yyval.val) = (yyvsp[(2) - (2)].val); }
08342     break;
08343 
08344   case 345:
08345 /* Line 1787 of yacc.c  */
08346 #line 3173 "ripper.y"
08347     { (yyval.val) = Qnil; }
08348     break;
08349 
08350   case 348:
08351 /* Line 1787 of yacc.c  */
08352 #line 3182 "ripper.y"
08353     {
08354 #if 0
08355                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08356                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08357 #endif
08358                         (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08359 
08360                     }
08361     break;
08362 
08363   case 350:
08364 /* Line 1787 of yacc.c  */
08365 #line 3194 "ripper.y"
08366     {
08367 #if 0
08368                         (yyval.val) = (yyvsp[(2) - (2)].val);
08369 #endif
08370                         (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
08371 
08372                     }
08373     break;
08374 
08375   case 353:
08376 /* Line 1787 of yacc.c  */
08377 #line 3208 "ripper.y"
08378     {
08379                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
08380 #if 0
08381 #endif
08382                         (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
08383 
08384                     }
08385     break;
08386 
08387   case 354:
08388 /* Line 1787 of yacc.c  */
08389 #line 3216 "ripper.y"
08390     {
08391 #if 0
08392                         (yyval.val) = (yyvsp[(2) - (3)].val);
08393 #endif
08394                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
08395 
08396                     }
08397     break;
08398 
08399   case 355:
08400 /* Line 1787 of yacc.c  */
08401 #line 3226 "ripper.y"
08402     {
08403 #if 0
08404                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
08405 #endif
08406                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
08407 
08408                     }
08409     break;
08410 
08411   case 356:
08412 /* Line 1787 of yacc.c  */
08413 #line 3234 "ripper.y"
08414     {
08415 #if 0
08416                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08417 #endif
08418                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08419 
08420                     }
08421     break;
08422 
08423   case 357:
08424 /* Line 1787 of yacc.c  */
08425 #line 3244 "ripper.y"
08426     {
08427 #if 0
08428                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
08429 #endif
08430                         (yyval.val) = (yyvsp[(1) - (1)].val);
08431 
08432                     }
08433     break;
08434 
08435   case 358:
08436 /* Line 1787 of yacc.c  */
08437 #line 3252 "ripper.y"
08438     {
08439                         (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
08440 #if 0
08441                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
08442 #endif
08443                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
08444 
08445                     }
08446     break;
08447 
08448   case 359:
08449 /* Line 1787 of yacc.c  */
08450 #line 3261 "ripper.y"
08451     {
08452                         (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
08453 #if 0
08454                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
08455 #endif
08456                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
08457 
08458                     }
08459     break;
08460 
08461   case 360:
08462 /* Line 1787 of yacc.c  */
08463 #line 3270 "ripper.y"
08464     {
08465 #if 0
08466                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
08467 #endif
08468                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
08469 
08470                     }
08471     break;
08472 
08473   case 361:
08474 /* Line 1787 of yacc.c  */
08475 #line 3278 "ripper.y"
08476     {
08477 #if 0
08478                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
08479 #endif
08480                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
08481 
08482                     }
08483     break;
08484 
08485   case 362:
08486 /* Line 1787 of yacc.c  */
08487 #line 3286 "ripper.y"
08488     {
08489                         (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
08490 #if 0
08491                         (yyval.val) = NEW_MASGN(0, (yyval.val));
08492 #endif
08493                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
08494 
08495                     }
08496     break;
08497 
08498   case 363:
08499 /* Line 1787 of yacc.c  */
08500 #line 3295 "ripper.y"
08501     {
08502                         (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
08503 #if 0
08504                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
08505 #endif
08506                       #if 0
08507                       TODO: Check me
08508                       #endif
08509                         (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
08510 
08511                     }
08512     break;
08513 
08514   case 364:
08515 /* Line 1787 of yacc.c  */
08516 #line 3307 "ripper.y"
08517     {
08518 #if 0
08519                         (yyval.val) = NEW_MASGN(0, -1);
08520 #endif
08521                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08522 
08523                     }
08524     break;
08525 
08526   case 365:
08527 /* Line 1787 of yacc.c  */
08528 #line 3315 "ripper.y"
08529     {
08530 #if 0
08531                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
08532 #endif
08533                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08534 
08535                     }
08536     break;
08537 
08538   case 366:
08539 /* Line 1787 of yacc.c  */
08540 #line 3325 "ripper.y"
08541     {
08542 #if 0
08543                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
08544 #endif
08545                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
08546 
08547                     }
08548     break;
08549 
08550   case 367:
08551 /* Line 1787 of yacc.c  */
08552 #line 3333 "ripper.y"
08553     {
08554 #if 0
08555                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
08556 #endif
08557                         (yyval.val) = params_new((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), escape_Qundef((yyvsp[(8) - (8)].val)));
08558 
08559                     }
08560     break;
08561 
08562   case 368:
08563 /* Line 1787 of yacc.c  */
08564 #line 3341 "ripper.y"
08565     {
08566 #if 0
08567                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
08568 #endif
08569                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08570 
08571                     }
08572     break;
08573 
08574   case 369:
08575 /* Line 1787 of yacc.c  */
08576 #line 3349 "ripper.y"
08577     {
08578 #if 0
08579                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08580 #endif
08581                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08582 
08583                     }
08584     break;
08585 
08586   case 370:
08587 /* Line 1787 of yacc.c  */
08588 #line 3357 "ripper.y"
08589     {
08590 #if 0
08591                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
08592 #endif
08593                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08594 
08595                     }
08596     break;
08597 
08598   case 371:
08599 /* Line 1787 of yacc.c  */
08600 #line 3365 "ripper.y"
08601     {
08602 #if 0
08603                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 1, 0, 0);
08604 #endif
08605                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil, Qnil);
08606                         dispatch1(excessed_comma, (yyval.val));
08607 
08608                     }
08609     break;
08610 
08611   case 372:
08612 /* Line 1787 of yacc.c  */
08613 #line 3374 "ripper.y"
08614     {
08615 #if 0
08616                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08617 #endif
08618                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08619 
08620                     }
08621     break;
08622 
08623   case 373:
08624 /* Line 1787 of yacc.c  */
08625 #line 3382 "ripper.y"
08626     {
08627 #if 0
08628                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
08629 #endif
08630                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil,Qnil, Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
08631 
08632                     }
08633     break;
08634 
08635   case 374:
08636 /* Line 1787 of yacc.c  */
08637 #line 3390 "ripper.y"
08638     {
08639 #if 0
08640                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
08641 #endif
08642                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08643 
08644                     }
08645     break;
08646 
08647   case 375:
08648 /* Line 1787 of yacc.c  */
08649 #line 3398 "ripper.y"
08650     {
08651 #if 0
08652                         (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08653 #endif
08654                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08655 
08656                     }
08657     break;
08658 
08659   case 376:
08660 /* Line 1787 of yacc.c  */
08661 #line 3406 "ripper.y"
08662     {
08663 #if 0
08664                         (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
08665 #endif
08666                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
08667 
08668                     }
08669     break;
08670 
08671   case 377:
08672 /* Line 1787 of yacc.c  */
08673 #line 3414 "ripper.y"
08674     {
08675 #if 0
08676                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08677 #endif
08678                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
08679 
08680                     }
08681     break;
08682 
08683   case 378:
08684 /* Line 1787 of yacc.c  */
08685 #line 3422 "ripper.y"
08686     {
08687 #if 0
08688                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
08689 #endif
08690                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
08691 
08692                     }
08693     break;
08694 
08695   case 379:
08696 /* Line 1787 of yacc.c  */
08697 #line 3430 "ripper.y"
08698     {
08699 #if 0
08700                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08701 #endif
08702                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
08703 
08704                     }
08705     break;
08706 
08707   case 380:
08708 /* Line 1787 of yacc.c  */
08709 #line 3438 "ripper.y"
08710     {
08711 #if 0
08712                         (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
08713 #endif
08714                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
08715 
08716                     }
08717     break;
08718 
08719   case 382:
08720 /* Line 1787 of yacc.c  */
08721 #line 3449 "ripper.y"
08722     {
08723                         command_start = TRUE;
08724                     }
08725     break;
08726 
08727   case 383:
08728 /* Line 1787 of yacc.c  */
08729 #line 3455 "ripper.y"
08730     {
08731 #if 0
08732                         (yyval.val) = 0;
08733 #endif
08734                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
08735                                           escape_Qundef((yyvsp[(2) - (3)].val)));
08736 
08737                     }
08738     break;
08739 
08740   case 384:
08741 /* Line 1787 of yacc.c  */
08742 #line 3464 "ripper.y"
08743     {
08744 #if 0
08745                         (yyval.val) = 0;
08746 #endif
08747                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
08748                                           Qnil);
08749 
08750                     }
08751     break;
08752 
08753   case 385:
08754 /* Line 1787 of yacc.c  */
08755 #line 3473 "ripper.y"
08756     {
08757 #if 0
08758                         (yyval.val) = (yyvsp[(2) - (4)].val);
08759 #endif
08760                         (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
08761 
08762                     }
08763     break;
08764 
08765   case 387:
08766 /* Line 1787 of yacc.c  */
08767 #line 3485 "ripper.y"
08768     {
08769 #if 0
08770                         (yyval.val) = 0;
08771 #endif
08772                         (yyval.val) = (yyvsp[(2) - (2)].val);
08773 
08774                     }
08775     break;
08776 
08777   case 388:
08778 /* Line 1787 of yacc.c  */
08779 #line 3497 "ripper.y"
08780     {
08781                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
08782                     }
08783     break;
08784 
08785   case 389:
08786 /* Line 1787 of yacc.c  */
08787 #line 3504 "ripper.y"
08788     {
08789                         rb_ary_push((yyval.val), (yyvsp[(3) - (3)].val));
08790                     }
08791     break;
08792 
08793   case 390:
08794 /* Line 1787 of yacc.c  */
08795 #line 3511 "ripper.y"
08796     {
08797                         new_bv(get_id((yyvsp[(1) - (1)].val)));
08798 #if 0
08799 #endif
08800                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
08801 
08802                     }
08803     break;
08804 
08805   case 391:
08806 /* Line 1787 of yacc.c  */
08807 #line 3519 "ripper.y"
08808     {
08809                         (yyval.val) = 0;
08810                     }
08811     break;
08812 
08813   case 392:
08814 /* Line 1787 of yacc.c  */
08815 #line 3524 "ripper.y"
08816     {
08817                         (yyval.vars) = dyna_push();
08818                     }
08819     break;
08820 
08821   case 393:
08822 /* Line 1787 of yacc.c  */
08823 #line 3527 "ripper.y"
08824     {
08825                         (yyval.num) = lpar_beg;
08826                         lpar_beg = ++paren_nest;
08827                     }
08828     break;
08829 
08830   case 394:
08831 /* Line 1787 of yacc.c  */
08832 #line 3533 "ripper.y"
08833     {
08834                         lpar_beg = (yyvsp[(2) - (4)].num);
08835 #if 0
08836                         (yyval.val) = (yyvsp[(3) - (4)].val);
08837                         (yyval.val)->nd_body = NEW_SCOPE((yyvsp[(3) - (4)].val)->nd_head, (yyvsp[(4) - (4)].val));
08838 #endif
08839                         (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08840 
08841                         dyna_pop((yyvsp[(1) - (4)].vars));
08842                     }
08843     break;
08844 
08845   case 395:
08846 /* Line 1787 of yacc.c  */
08847 #line 3546 "ripper.y"
08848     {
08849 #if 0
08850                         (yyval.val) = NEW_LAMBDA((yyvsp[(2) - (4)].val));
08851 #endif
08852                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
08853 
08854                     }
08855     break;
08856 
08857   case 396:
08858 /* Line 1787 of yacc.c  */
08859 #line 3554 "ripper.y"
08860     {
08861 #if 0
08862                         (yyval.val) = NEW_LAMBDA((yyvsp[(1) - (1)].val));
08863 #endif
08864                         (yyval.val) = (yyvsp[(1) - (1)].val);
08865 
08866                     }
08867     break;
08868 
08869   case 397:
08870 /* Line 1787 of yacc.c  */
08871 #line 3564 "ripper.y"
08872     {
08873                         (yyval.val) = (yyvsp[(2) - (3)].val);
08874                     }
08875     break;
08876 
08877   case 398:
08878 /* Line 1787 of yacc.c  */
08879 #line 3568 "ripper.y"
08880     {
08881                         (yyval.val) = (yyvsp[(2) - (3)].val);
08882                     }
08883     break;
08884 
08885   case 399:
08886 /* Line 1787 of yacc.c  */
08887 #line 3574 "ripper.y"
08888     {
08889                         (yyvsp[(1) - (1)].vars) = dyna_push();
08890 #if 0
08891                         (yyval.num) = ruby_sourceline;
08892 #endif
08893                     }
08894     break;
08895 
08896   case 400:
08897 /* Line 1787 of yacc.c  */
08898 #line 3583 "ripper.y"
08899     {
08900 #if 0
08901                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
08902                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
08903 #endif
08904                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
08905 
08906                         dyna_pop((yyvsp[(1) - (5)].vars));
08907                     }
08908     break;
08909 
08910   case 401:
08911 /* Line 1787 of yacc.c  */
08912 #line 3595 "ripper.y"
08913     {
08914 #if 0
08915                         if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
08916                             compile_error(PARSER_ARG "block given to yield");
08917                         }
08918                         else {
08919                             block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
08920                         }
08921                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
08922                         (yyval.val) = (yyvsp[(2) - (2)].val);
08923                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
08924 #endif
08925                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08926 
08927                     }
08928     break;
08929 
08930   case 402:
08931 /* Line 1787 of yacc.c  */
08932 #line 3611 "ripper.y"
08933     {
08934 #if 0
08935                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08936 #endif
08937                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
08938                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08939 
08940                     }
08941     break;
08942 
08943   case 403:
08944 /* Line 1787 of yacc.c  */
08945 #line 3620 "ripper.y"
08946     {
08947 #if 0
08948                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08949 #endif
08950                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
08951                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08952 
08953                     }
08954     break;
08955 
08956   case 404:
08957 /* Line 1787 of yacc.c  */
08958 #line 3631 "ripper.y"
08959     {
08960 #if 0
08961                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08962                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
08963 #endif
08964                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
08965 
08966                     }
08967     break;
08968 
08969   case 405:
08970 /* Line 1787 of yacc.c  */
08971 #line 3640 "ripper.y"
08972     {
08973 #if 0
08974                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08975                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
08976 #endif
08977                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
08978                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08979 
08980                     }
08981     break;
08982 
08983   case 406:
08984 /* Line 1787 of yacc.c  */
08985 #line 3650 "ripper.y"
08986     {
08987 #if 0
08988                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08989                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
08990 #endif
08991                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
08992                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08993 
08994                     }
08995     break;
08996 
08997   case 407:
08998 /* Line 1787 of yacc.c  */
08999 #line 3660 "ripper.y"
09000     {
09001 #if 0
09002                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
09003 #endif
09004                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
09005 
09006                     }
09007     break;
09008 
09009   case 408:
09010 /* Line 1787 of yacc.c  */
09011 #line 3668 "ripper.y"
09012     {
09013 #if 0
09014                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
09015                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
09016 #endif
09017                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_id2sym('.'),
09018                                        ripper_intern("call"));
09019                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
09020 
09021                     }
09022     break;
09023 
09024   case 409:
09025 /* Line 1787 of yacc.c  */
09026 #line 3679 "ripper.y"
09027     {
09028 #if 0
09029                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
09030                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
09031 #endif
09032                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"),
09033                                        ripper_intern("call"));
09034                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
09035 
09036                     }
09037     break;
09038 
09039   case 410:
09040 /* Line 1787 of yacc.c  */
09041 #line 3690 "ripper.y"
09042     {
09043 #if 0
09044                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
09045 #endif
09046                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
09047 
09048                     }
09049     break;
09050 
09051   case 411:
09052 /* Line 1787 of yacc.c  */
09053 #line 3698 "ripper.y"
09054     {
09055 #if 0
09056                         (yyval.val) = NEW_ZSUPER();
09057 #endif
09058                         (yyval.val) = dispatch0(zsuper);
09059 
09060                     }
09061     break;
09062 
09063   case 412:
09064 /* Line 1787 of yacc.c  */
09065 #line 3706 "ripper.y"
09066     {
09067 #if 0
09068                         if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
09069                             (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
09070                         else
09071                             (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
09072                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09073 #endif
09074                         (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
09075 
09076                     }
09077     break;
09078 
09079   case 413:
09080 /* Line 1787 of yacc.c  */
09081 #line 3720 "ripper.y"
09082     {
09083                         (yyvsp[(1) - (1)].vars) = dyna_push();
09084 #if 0
09085                         (yyval.num) = ruby_sourceline;
09086 #endif
09087 
09088                     }
09089     break;
09090 
09091   case 414:
09092 /* Line 1787 of yacc.c  */
09093 #line 3729 "ripper.y"
09094     {
09095 #if 0
09096                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09097                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09098 #endif
09099                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09100 
09101                         dyna_pop((yyvsp[(1) - (5)].vars));
09102                     }
09103     break;
09104 
09105   case 415:
09106 /* Line 1787 of yacc.c  */
09107 #line 3739 "ripper.y"
09108     {
09109                         (yyvsp[(1) - (1)].vars) = dyna_push();
09110 #if 0
09111                         (yyval.num) = ruby_sourceline;
09112 #endif
09113 
09114                     }
09115     break;
09116 
09117   case 416:
09118 /* Line 1787 of yacc.c  */
09119 #line 3748 "ripper.y"
09120     {
09121 #if 0
09122                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09123                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09124 #endif
09125                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09126 
09127                         dyna_pop((yyvsp[(1) - (5)].vars));
09128                     }
09129     break;
09130 
09131   case 417:
09132 /* Line 1787 of yacc.c  */
09133 #line 3762 "ripper.y"
09134     {
09135 #if 0
09136                         (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09137 #endif
09138                         (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
09139 
09140                     }
09141     break;
09142 
09143   case 420:
09144 /* Line 1787 of yacc.c  */
09145 #line 3778 "ripper.y"
09146     {
09147 #if 0
09148                         if ((yyvsp[(3) - (6)].val)) {
09149                             (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
09150                             (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
09151                         }
09152                         (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09153                         fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
09154 #endif
09155                         (yyval.val) = dispatch4(rescue,
09156                                        escape_Qundef((yyvsp[(2) - (6)].val)),
09157                                        escape_Qundef((yyvsp[(3) - (6)].val)),
09158                                        escape_Qundef((yyvsp[(5) - (6)].val)),
09159                                        escape_Qundef((yyvsp[(6) - (6)].val)));
09160 
09161                     }
09162     break;
09163 
09164   case 422:
09165 /* Line 1787 of yacc.c  */
09166 #line 3798 "ripper.y"
09167     {
09168 #if 0
09169                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
09170 #endif
09171                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09172 
09173                     }
09174     break;
09175 
09176   case 423:
09177 /* Line 1787 of yacc.c  */
09178 #line 3806 "ripper.y"
09179     {
09180 #if 0
09181                         if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
09182 #endif
09183                         (yyval.val) = (yyvsp[(1) - (1)].val);
09184 
09185                     }
09186     break;
09187 
09188   case 425:
09189 /* Line 1787 of yacc.c  */
09190 #line 3817 "ripper.y"
09191     {
09192                         (yyval.val) = (yyvsp[(2) - (2)].val);
09193                     }
09194     break;
09195 
09196   case 427:
09197 /* Line 1787 of yacc.c  */
09198 #line 3824 "ripper.y"
09199     {
09200 #if 0
09201                         (yyval.val) = (yyvsp[(2) - (2)].val);
09202 #endif
09203                         (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
09204 
09205                     }
09206     break;
09207 
09208   case 430:
09209 /* Line 1787 of yacc.c  */
09210 #line 3836 "ripper.y"
09211     {
09212 #if 0
09213                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
09214 #endif
09215                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
09216 
09217                     }
09218     break;
09219 
09220   case 432:
09221 /* Line 1787 of yacc.c  */
09222 #line 3847 "ripper.y"
09223     {
09224 #if 0
09225                         NODE *node = (yyvsp[(1) - (1)].val);
09226                         if (!node) {
09227                             node = NEW_STR(STR_NEW0());
09228                         }
09229                         else {
09230                             node = evstr2dstr(node);
09231                         }
09232                         (yyval.val) = node;
09233 #endif
09234                         (yyval.val) = (yyvsp[(1) - (1)].val);
09235 
09236                     }
09237     break;
09238 
09239   case 435:
09240 /* Line 1787 of yacc.c  */
09241 #line 3866 "ripper.y"
09242     {
09243 #if 0
09244                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09245 #endif
09246                         (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09247 
09248                     }
09249     break;
09250 
09251   case 436:
09252 /* Line 1787 of yacc.c  */
09253 #line 3876 "ripper.y"
09254     {
09255 #if 0
09256                         (yyval.val) = (yyvsp[(2) - (3)].val);
09257 #endif
09258                         (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
09259 
09260                     }
09261     break;
09262 
09263   case 437:
09264 /* Line 1787 of yacc.c  */
09265 #line 3886 "ripper.y"
09266     {
09267 #if 0
09268                         NODE *node = (yyvsp[(2) - (3)].val);
09269                         if (!node) {
09270                             node = NEW_XSTR(STR_NEW0());
09271                         }
09272                         else {
09273                             switch (nd_type(node)) {
09274                               case NODE_STR:
09275                                 nd_set_type(node, NODE_XSTR);
09276                                 break;
09277                               case NODE_DSTR:
09278                                 nd_set_type(node, NODE_DXSTR);
09279                                 break;
09280                               default:
09281                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09282                                 break;
09283                             }
09284                         }
09285                         (yyval.val) = node;
09286 #endif
09287                         (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
09288 
09289                     }
09290     break;
09291 
09292   case 438:
09293 /* Line 1787 of yacc.c  */
09294 #line 3913 "ripper.y"
09295     {
09296 #if 0
09297                         int options = (yyvsp[(3) - (3)].val);
09298                         NODE *node = (yyvsp[(2) - (3)].val);
09299                         NODE *list, *prev;
09300                         if (!node) {
09301                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09302                         }
09303                         else switch (nd_type(node)) {
09304                           case NODE_STR:
09305                             {
09306                                 VALUE src = node->nd_lit;
09307                                 nd_set_type(node, NODE_LIT);
09308                                 node->nd_lit = reg_compile(src, options);
09309                             }
09310                             break;
09311                           default:
09312                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09313                           case NODE_DSTR:
09314                             if (options & RE_OPTION_ONCE) {
09315                                 nd_set_type(node, NODE_DREGX_ONCE);
09316                             }
09317                             else {
09318                                 nd_set_type(node, NODE_DREGX);
09319                             }
09320                             node->nd_cflag = options & RE_OPTION_MASK;
09321                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09322                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09323                                 if (nd_type(list->nd_head) == NODE_STR) {
09324                                     VALUE tail = list->nd_head->nd_lit;
09325                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09326                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09327                                         if (!literal_concat0(parser, lit, tail)) {
09328                                             node = 0;
09329                                             break;
09330                                         }
09331                                         rb_str_resize(tail, 0);
09332                                         prev->nd_next = list->nd_next;
09333                                         rb_gc_force_recycle((VALUE)list->nd_head);
09334                                         rb_gc_force_recycle((VALUE)list);
09335                                         list = prev;
09336                                     }
09337                                     else {
09338                                         prev = list;
09339                                     }
09340                                 }
09341                                 else {
09342                                     prev = 0;
09343                                 }
09344                             }
09345                             if (!node->nd_next) {
09346                                 VALUE src = node->nd_lit;
09347                                 nd_set_type(node, NODE_LIT);
09348                                 node->nd_lit = reg_compile(src, options);
09349                             }
09350                             break;
09351                         }
09352                         (yyval.val) = node;
09353 #endif
09354                         (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
09355 
09356                     }
09357     break;
09358 
09359   case 439:
09360 /* Line 1787 of yacc.c  */
09361 #line 3978 "ripper.y"
09362     {
09363 #if 0
09364                         (yyval.val) = NEW_ZARRAY();
09365 #endif
09366                         (yyval.val) = dispatch0(words_new);
09367                         (yyval.val) = dispatch1(array, (yyval.val));
09368 
09369                     }
09370     break;
09371 
09372   case 440:
09373 /* Line 1787 of yacc.c  */
09374 #line 3987 "ripper.y"
09375     {
09376 #if 0
09377                         (yyval.val) = (yyvsp[(2) - (3)].val);
09378 #endif
09379                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09380 
09381                     }
09382     break;
09383 
09384   case 441:
09385 /* Line 1787 of yacc.c  */
09386 #line 3997 "ripper.y"
09387     {
09388 #if 0
09389                         (yyval.val) = 0;
09390 #endif
09391                         (yyval.val) = dispatch0(words_new);
09392 
09393                     }
09394     break;
09395 
09396   case 442:
09397 /* Line 1787 of yacc.c  */
09398 #line 4005 "ripper.y"
09399     {
09400 #if 0
09401                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
09402 #endif
09403                         (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09404 
09405                     }
09406     break;
09407 
09408   case 443:
09409 /* Line 1787 of yacc.c  */
09410 #line 4017 "ripper.y"
09411     {
09412                         (yyval.val) = dispatch0(word_new);
09413                         (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
09414                     }
09415     break;
09416 
09417   case 444:
09418 /* Line 1787 of yacc.c  */
09419 #line 4023 "ripper.y"
09420     {
09421 #if 0
09422                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09423 #endif
09424                         (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09425 
09426                     }
09427     break;
09428 
09429   case 445:
09430 /* Line 1787 of yacc.c  */
09431 #line 4033 "ripper.y"
09432     {
09433 #if 0
09434                         (yyval.val) = NEW_ZARRAY();
09435 #endif
09436                         (yyval.val) = dispatch0(qwords_new);
09437                         (yyval.val) = dispatch1(array, (yyval.val));
09438 
09439                     }
09440     break;
09441 
09442   case 446:
09443 /* Line 1787 of yacc.c  */
09444 #line 4042 "ripper.y"
09445     {
09446 #if 0
09447                         (yyval.val) = (yyvsp[(2) - (3)].val);
09448 #endif
09449                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09450 
09451                     }
09452     break;
09453 
09454   case 447:
09455 /* Line 1787 of yacc.c  */
09456 #line 4052 "ripper.y"
09457     {
09458 #if 0
09459                         (yyval.val) = 0;
09460 #endif
09461                         (yyval.val) = dispatch0(qwords_new);
09462 
09463                     }
09464     break;
09465 
09466   case 448:
09467 /* Line 1787 of yacc.c  */
09468 #line 4060 "ripper.y"
09469     {
09470 #if 0
09471                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09472 #endif
09473                         (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09474 
09475                     }
09476     break;
09477 
09478   case 449:
09479 /* Line 1787 of yacc.c  */
09480 #line 4070 "ripper.y"
09481     {
09482 #if 0
09483                         (yyval.val) = 0;
09484 #endif
09485                         (yyval.val) = dispatch0(string_content);
09486 
09487                     }
09488     break;
09489 
09490   case 450:
09491 /* Line 1787 of yacc.c  */
09492 #line 4078 "ripper.y"
09493     {
09494 #if 0
09495                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09496 #endif
09497                         (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09498 
09499                     }
09500     break;
09501 
09502   case 451:
09503 /* Line 1787 of yacc.c  */
09504 #line 4088 "ripper.y"
09505     {
09506 #if 0
09507                         (yyval.val) = 0;
09508 #endif
09509                         (yyval.val) = dispatch0(xstring_new);
09510 
09511                     }
09512     break;
09513 
09514   case 452:
09515 /* Line 1787 of yacc.c  */
09516 #line 4096 "ripper.y"
09517     {
09518 #if 0
09519                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09520 #endif
09521                         (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09522 
09523                     }
09524     break;
09525 
09526   case 453:
09527 /* Line 1787 of yacc.c  */
09528 #line 4106 "ripper.y"
09529     {
09530 #if 0
09531                         (yyval.val) = 0;
09532 #endif
09533                         (yyval.val) = dispatch0(regexp_new);
09534 
09535                     }
09536     break;
09537 
09538   case 454:
09539 /* Line 1787 of yacc.c  */
09540 #line 4114 "ripper.y"
09541     {
09542 #if 0
09543                         NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
09544                         if (!head) {
09545                             (yyval.val) = tail;
09546                         }
09547                         else if (!tail) {
09548                             (yyval.val) = head;
09549                         }
09550                         else {
09551                             switch (nd_type(head)) {
09552                               case NODE_STR:
09553                                 nd_set_type(head, NODE_DSTR);
09554                                 break;
09555                               case NODE_DSTR:
09556                                 break;
09557                               default:
09558                                 head = list_append(NEW_DSTR(Qnil), head);
09559                                 break;
09560                             }
09561                             (yyval.val) = list_append(head, tail);
09562                         }
09563 #endif
09564                         (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09565 
09566                     }
09567     break;
09568 
09569   case 456:
09570 /* Line 1787 of yacc.c  */
09571 #line 4144 "ripper.y"
09572     {
09573                         (yyval.node) = lex_strterm;
09574                         lex_strterm = 0;
09575                         lex_state = EXPR_BEG;
09576                     }
09577     break;
09578 
09579   case 457:
09580 /* Line 1787 of yacc.c  */
09581 #line 4150 "ripper.y"
09582     {
09583 #if 0
09584                         lex_strterm = (yyvsp[(2) - (3)].node);
09585                         (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
09586 #endif
09587                         lex_strterm = (yyvsp[(2) - (3)].node);
09588                         (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
09589 
09590                     }
09591     break;
09592 
09593   case 458:
09594 /* Line 1787 of yacc.c  */
09595 #line 4160 "ripper.y"
09596     {
09597                         (yyvsp[(1) - (1)].val) = cond_stack;
09598                         (yyval.val) = cmdarg_stack;
09599                         cond_stack = 0;
09600                         cmdarg_stack = 0;
09601                     }
09602     break;
09603 
09604   case 459:
09605 /* Line 1787 of yacc.c  */
09606 #line 4166 "ripper.y"
09607     {
09608                         (yyval.node) = lex_strterm;
09609                         lex_strterm = 0;
09610                         lex_state = EXPR_BEG;
09611                     }
09612     break;
09613 
09614   case 460:
09615 /* Line 1787 of yacc.c  */
09616 #line 4172 "ripper.y"
09617     {
09618                         cond_stack = (yyvsp[(1) - (5)].val);
09619                         cmdarg_stack = (yyvsp[(2) - (5)].val);
09620                         lex_strterm = (yyvsp[(3) - (5)].node);
09621 #if 0
09622                         if ((yyvsp[(4) - (5)].val)) (yyvsp[(4) - (5)].val)->flags &= ~NODE_FL_NEWLINE;
09623                         (yyval.val) = new_evstr((yyvsp[(4) - (5)].val));
09624 #endif
09625                         (yyval.val) = dispatch1(string_embexpr, (yyvsp[(4) - (5)].val));
09626 
09627                     }
09628     break;
09629 
09630   case 461:
09631 /* Line 1787 of yacc.c  */
09632 #line 4186 "ripper.y"
09633     {
09634 #if 0
09635                         (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
09636 #endif
09637                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09638 
09639                     }
09640     break;
09641 
09642   case 462:
09643 /* Line 1787 of yacc.c  */
09644 #line 4194 "ripper.y"
09645     {
09646 #if 0
09647                         (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
09648 #endif
09649                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09650 
09651                     }
09652     break;
09653 
09654   case 463:
09655 /* Line 1787 of yacc.c  */
09656 #line 4202 "ripper.y"
09657     {
09658 #if 0
09659                         (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
09660 #endif
09661                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09662 
09663                     }
09664     break;
09665 
09666   case 465:
09667 /* Line 1787 of yacc.c  */
09668 #line 4213 "ripper.y"
09669     {
09670                         lex_state = EXPR_END;
09671 #if 0
09672                         (yyval.val) = (yyvsp[(2) - (2)].val);
09673 #endif
09674                         (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
09675 
09676                     }
09677     break;
09678 
09679   case 470:
09680 /* Line 1787 of yacc.c  */
09681 #line 4230 "ripper.y"
09682     {
09683                         lex_state = EXPR_END;
09684 #if 0
09685                         if (!((yyval.val) = (yyvsp[(2) - (3)].val))) {
09686                             (yyval.val) = NEW_LIT(ID2SYM(rb_intern("")));
09687                         }
09688                         else {
09689                             VALUE lit;
09690 
09691                             switch (nd_type((yyval.val))) {
09692                               case NODE_DSTR:
09693                                 nd_set_type((yyval.val), NODE_DSYM);
09694                                 break;
09695                               case NODE_STR:
09696                                 lit = (yyval.val)->nd_lit;
09697                                 (yyval.val)->nd_lit = ID2SYM(rb_intern_str(lit));
09698                                 nd_set_type((yyval.val), NODE_LIT);
09699                                 break;
09700                               default:
09701                                 (yyval.val) = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST((yyval.val)));
09702                                 break;
09703                             }
09704                         }
09705 #endif
09706                         (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
09707 
09708                     }
09709     break;
09710 
09711   case 473:
09712 /* Line 1787 of yacc.c  */
09713 #line 4262 "ripper.y"
09714     {
09715 #if 0
09716                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09717 #endif
09718                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09719 
09720                     }
09721     break;
09722 
09723   case 474:
09724 /* Line 1787 of yacc.c  */
09725 #line 4270 "ripper.y"
09726     {
09727 #if 0
09728                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09729 #endif
09730                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09731 
09732                     }
09733     break;
09734 
09735   case 480:
09736 /* Line 1787 of yacc.c  */
09737 #line 4286 "ripper.y"
09738     {ifndef_ripper((yyval.val) = keyword_nil);}
09739     break;
09740 
09741   case 481:
09742 /* Line 1787 of yacc.c  */
09743 #line 4287 "ripper.y"
09744     {ifndef_ripper((yyval.val) = keyword_self);}
09745     break;
09746 
09747   case 482:
09748 /* Line 1787 of yacc.c  */
09749 #line 4288 "ripper.y"
09750     {ifndef_ripper((yyval.val) = keyword_true);}
09751     break;
09752 
09753   case 483:
09754 /* Line 1787 of yacc.c  */
09755 #line 4289 "ripper.y"
09756     {ifndef_ripper((yyval.val) = keyword_false);}
09757     break;
09758 
09759   case 484:
09760 /* Line 1787 of yacc.c  */
09761 #line 4290 "ripper.y"
09762     {ifndef_ripper((yyval.val) = keyword__FILE__);}
09763     break;
09764 
09765   case 485:
09766 /* Line 1787 of yacc.c  */
09767 #line 4291 "ripper.y"
09768     {ifndef_ripper((yyval.val) = keyword__LINE__);}
09769     break;
09770 
09771   case 486:
09772 /* Line 1787 of yacc.c  */
09773 #line 4292 "ripper.y"
09774     {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
09775     break;
09776 
09777   case 487:
09778 /* Line 1787 of yacc.c  */
09779 #line 4296 "ripper.y"
09780     {
09781 #if 0
09782                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
09783 #endif
09784                         if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
09785                             (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09786                         }
09787                         else {
09788                             (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
09789                         }
09790 
09791                     }
09792     break;
09793 
09794   case 488:
09795 /* Line 1787 of yacc.c  */
09796 #line 4309 "ripper.y"
09797     {
09798 #if 0
09799                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
09800 #endif
09801                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09802 
09803                     }
09804     break;
09805 
09806   case 489:
09807 /* Line 1787 of yacc.c  */
09808 #line 4319 "ripper.y"
09809     {
09810                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
09811 #if 0
09812 #endif
09813                         (yyval.val) = dispatch1(var_field, (yyval.val));
09814 
09815                     }
09816     break;
09817 
09818   case 490:
09819 /* Line 1787 of yacc.c  */
09820 #line 4327 "ripper.y"
09821     {
09822                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
09823 #if 0
09824 #endif
09825                         (yyval.val) = dispatch1(var_field, (yyval.val));
09826 
09827                     }
09828     break;
09829 
09830   case 493:
09831 /* Line 1787 of yacc.c  */
09832 #line 4341 "ripper.y"
09833     {
09834 #if 0
09835                         (yyval.val) = 0;
09836 #endif
09837                         (yyval.val) = Qnil;
09838 
09839                     }
09840     break;
09841 
09842   case 494:
09843 /* Line 1787 of yacc.c  */
09844 #line 4349 "ripper.y"
09845     {
09846                         lex_state = EXPR_BEG;
09847                     }
09848     break;
09849 
09850   case 495:
09851 /* Line 1787 of yacc.c  */
09852 #line 4353 "ripper.y"
09853     {
09854                         (yyval.val) = (yyvsp[(3) - (4)].val);
09855                     }
09856     break;
09857 
09858   case 496:
09859 /* Line 1787 of yacc.c  */
09860 #line 4357 "ripper.y"
09861     {
09862 #if 0
09863                         yyerrok;
09864                         (yyval.val) = 0;
09865 #endif
09866                         yyerrok;
09867                         (yyval.val) = Qnil;
09868 
09869                     }
09870     break;
09871 
09872   case 497:
09873 /* Line 1787 of yacc.c  */
09874 #line 4369 "ripper.y"
09875     {
09876 #if 0
09877                         (yyval.val) = (yyvsp[(2) - (3)].val);
09878 #endif
09879                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
09880 
09881                         lex_state = EXPR_BEG;
09882                         command_start = TRUE;
09883                     }
09884     break;
09885 
09886   case 498:
09887 /* Line 1787 of yacc.c  */
09888 #line 4379 "ripper.y"
09889     {
09890                         (yyval.val) = (yyvsp[(1) - (2)].val);
09891                         lex_state = EXPR_BEG;
09892                         command_start = TRUE;
09893                     }
09894     break;
09895 
09896   case 499:
09897 /* Line 1787 of yacc.c  */
09898 #line 4387 "ripper.y"
09899     {
09900 #if 0
09901                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
09902 #endif
09903                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
09904 
09905                     }
09906     break;
09907 
09908   case 500:
09909 /* Line 1787 of yacc.c  */
09910 #line 4395 "ripper.y"
09911     {
09912 #if 0
09913                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
09914 #endif
09915                         (yyval.val) = params_new((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), escape_Qundef((yyvsp[(8) - (8)].val)));
09916 
09917                     }
09918     break;
09919 
09920   case 501:
09921 /* Line 1787 of yacc.c  */
09922 #line 4403 "ripper.y"
09923     {
09924 #if 0
09925                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
09926 #endif
09927                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
09928 
09929                     }
09930     break;
09931 
09932   case 502:
09933 /* Line 1787 of yacc.c  */
09934 #line 4411 "ripper.y"
09935     {
09936 #if 0
09937                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09938 #endif
09939                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
09940 
09941                     }
09942     break;
09943 
09944   case 503:
09945 /* Line 1787 of yacc.c  */
09946 #line 4419 "ripper.y"
09947     {
09948 #if 0
09949                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
09950 #endif
09951                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
09952 
09953                     }
09954     break;
09955 
09956   case 504:
09957 /* Line 1787 of yacc.c  */
09958 #line 4427 "ripper.y"
09959     {
09960 #if 0
09961                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09962 #endif
09963                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
09964 
09965                     }
09966     break;
09967 
09968   case 505:
09969 /* Line 1787 of yacc.c  */
09970 #line 4435 "ripper.y"
09971     {
09972 #if 0
09973                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
09974 #endif
09975                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
09976 
09977                     }
09978     break;
09979 
09980   case 506:
09981 /* Line 1787 of yacc.c  */
09982 #line 4443 "ripper.y"
09983     {
09984 #if 0
09985                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
09986 #endif
09987                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
09988 
09989                     }
09990     break;
09991 
09992   case 507:
09993 /* Line 1787 of yacc.c  */
09994 #line 4451 "ripper.y"
09995     {
09996 #if 0
09997                         (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09998 #endif
09999                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10000 
10001                     }
10002     break;
10003 
10004   case 508:
10005 /* Line 1787 of yacc.c  */
10006 #line 4459 "ripper.y"
10007     {
10008 #if 0
10009                         (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
10010 #endif
10011                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10012 
10013                     }
10014     break;
10015 
10016   case 509:
10017 /* Line 1787 of yacc.c  */
10018 #line 4467 "ripper.y"
10019     {
10020 #if 0
10021                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10022 #endif
10023                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10024 
10025                     }
10026     break;
10027 
10028   case 510:
10029 /* Line 1787 of yacc.c  */
10030 #line 4475 "ripper.y"
10031     {
10032 #if 0
10033                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
10034 #endif
10035                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10036 
10037                     }
10038     break;
10039 
10040   case 511:
10041 /* Line 1787 of yacc.c  */
10042 #line 4483 "ripper.y"
10043     {
10044 #if 0
10045                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10046 #endif
10047                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10048 
10049                     }
10050     break;
10051 
10052   case 512:
10053 /* Line 1787 of yacc.c  */
10054 #line 4491 "ripper.y"
10055     {
10056 #if 0
10057                         (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
10058 #endif
10059                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
10060 
10061                     }
10062     break;
10063 
10064   case 513:
10065 /* Line 1787 of yacc.c  */
10066 #line 4499 "ripper.y"
10067     {
10068 #if 0
10069                         (yyval.val) = new_args(0, 0, 0, 0, 0);
10070 #endif
10071                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
10072 
10073                     }
10074     break;
10075 
10076   case 514:
10077 /* Line 1787 of yacc.c  */
10078 #line 4509 "ripper.y"
10079     {
10080 #if 0
10081                         yyerror("formal argument cannot be a constant");
10082                         (yyval.val) = 0;
10083 #endif
10084                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10085 
10086                     }
10087     break;
10088 
10089   case 515:
10090 /* Line 1787 of yacc.c  */
10091 #line 4518 "ripper.y"
10092     {
10093 #if 0
10094                         yyerror("formal argument cannot be an instance variable");
10095                         (yyval.val) = 0;
10096 #endif
10097                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10098 
10099                     }
10100     break;
10101 
10102   case 516:
10103 /* Line 1787 of yacc.c  */
10104 #line 4527 "ripper.y"
10105     {
10106 #if 0
10107                         yyerror("formal argument cannot be a global variable");
10108                         (yyval.val) = 0;
10109 #endif
10110                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10111 
10112                     }
10113     break;
10114 
10115   case 517:
10116 /* Line 1787 of yacc.c  */
10117 #line 4536 "ripper.y"
10118     {
10119 #if 0
10120                         yyerror("formal argument cannot be a class variable");
10121                         (yyval.val) = 0;
10122 #endif
10123                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10124 
10125                     }
10126     break;
10127 
10128   case 519:
10129 /* Line 1787 of yacc.c  */
10130 #line 4548 "ripper.y"
10131     {
10132                         formal_argument(get_id((yyvsp[(1) - (1)].val)));
10133                         (yyval.val) = (yyvsp[(1) - (1)].val);
10134                     }
10135     break;
10136 
10137   case 520:
10138 /* Line 1787 of yacc.c  */
10139 #line 4555 "ripper.y"
10140     {
10141                         arg_var(get_id((yyvsp[(1) - (1)].val)));
10142 #if 0
10143                         (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10144 #endif
10145                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10146 
10147                     }
10148     break;
10149 
10150   case 521:
10151 /* Line 1787 of yacc.c  */
10152 #line 4564 "ripper.y"
10153     {
10154                         ID tid = internal_id();
10155                         arg_var(tid);
10156 #if 0
10157                         if (dyna_in_block()) {
10158                             (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10159                         }
10160                         else {
10161                             (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10162                         }
10163                         (yyval.val) = NEW_ARGS_AUX(tid, 1);
10164                         (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10165 #endif
10166                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10167 
10168                     }
10169     break;
10170 
10171   case 522:
10172 /* Line 1787 of yacc.c  */
10173 #line 4585 "ripper.y"
10174     {
10175                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10176                     }
10177     break;
10178 
10179   case 523:
10180 /* Line 1787 of yacc.c  */
10181 #line 4590 "ripper.y"
10182     {
10183 #if 0
10184                         (yyval.val) = (yyvsp[(1) - (3)].val);
10185                         (yyval.val)->nd_plen++;
10186                         (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10187                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10188 #endif
10189                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10190 
10191                     }
10192     break;
10193 
10194   case 524:
10195 /* Line 1787 of yacc.c  */
10196 #line 4603 "ripper.y"
10197     {
10198                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10199                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10200 #if 0
10201                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10202 #endif
10203                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10204 
10205                     }
10206     break;
10207 
10208   case 525:
10209 /* Line 1787 of yacc.c  */
10210 #line 4615 "ripper.y"
10211     {
10212                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10213                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10214 #if 0
10215                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10216 #endif
10217                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10218 
10219                     }
10220     break;
10221 
10222   case 526:
10223 /* Line 1787 of yacc.c  */
10224 #line 4627 "ripper.y"
10225     {
10226 #if 0
10227                         (yyval.val) = (yyvsp[(1) - (1)].val);
10228 #endif
10229                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10230 
10231                     }
10232     break;
10233 
10234   case 527:
10235 /* Line 1787 of yacc.c  */
10236 #line 4635 "ripper.y"
10237     {
10238 #if 0
10239                         NODE *opts = (yyvsp[(1) - (3)].val);
10240 
10241                         while (opts->nd_next) {
10242                             opts = opts->nd_next;
10243                         }
10244                         opts->nd_next = (yyvsp[(3) - (3)].val);
10245                         (yyval.val) = (yyvsp[(1) - (3)].val);
10246 #endif
10247                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10248 
10249                     }
10250     break;
10251 
10252   case 528:
10253 /* Line 1787 of yacc.c  */
10254 #line 4651 "ripper.y"
10255     {
10256 #if 0
10257                         (yyval.val) = (yyvsp[(1) - (1)].val);
10258 #endif
10259                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10260 
10261                     }
10262     break;
10263 
10264   case 529:
10265 /* Line 1787 of yacc.c  */
10266 #line 4659 "ripper.y"
10267     {
10268 #if 0
10269                         NODE *opts = (yyvsp[(1) - (3)].val);
10270 
10271                         while (opts->nd_next) {
10272                             opts = opts->nd_next;
10273                         }
10274                         opts->nd_next = (yyvsp[(3) - (3)].val);
10275                         (yyval.val) = (yyvsp[(1) - (3)].val);
10276 #endif
10277                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10278 
10279                     }
10280     break;
10281 
10282   case 532:
10283 /* Line 1787 of yacc.c  */
10284 #line 4679 "ripper.y"
10285     {
10286 #if 0
10287                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10288                             yyerror("rest argument must be local variable");
10289 #endif
10290                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10291 #if 0
10292                         (yyval.val) = (yyvsp[(2) - (2)].val);
10293 #endif
10294                         (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10295 
10296                     }
10297     break;
10298 
10299   case 533:
10300 /* Line 1787 of yacc.c  */
10301 #line 4692 "ripper.y"
10302     {
10303 #if 0
10304                         (yyval.val) = internal_id();
10305                         arg_var((yyval.val));
10306 #endif
10307                         (yyval.val) = dispatch1(rest_param, Qnil);
10308 
10309                     }
10310     break;
10311 
10312   case 536:
10313 /* Line 1787 of yacc.c  */
10314 #line 4707 "ripper.y"
10315     {
10316 #if 0
10317                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10318                             yyerror("block argument must be local variable");
10319                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10320                             yyerror("duplicated block argument name");
10321 #endif
10322                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10323 #if 0
10324                         (yyval.val) = (yyvsp[(2) - (2)].val);
10325 #endif
10326                         (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10327 
10328                     }
10329     break;
10330 
10331   case 537:
10332 /* Line 1787 of yacc.c  */
10333 #line 4724 "ripper.y"
10334     {
10335                         (yyval.val) = (yyvsp[(2) - (2)].val);
10336                     }
10337     break;
10338 
10339   case 538:
10340 /* Line 1787 of yacc.c  */
10341 #line 4728 "ripper.y"
10342     {
10343 #if 0
10344                         (yyval.val) = 0;
10345 #endif
10346                         (yyval.val) = Qundef;
10347 
10348                     }
10349     break;
10350 
10351   case 539:
10352 /* Line 1787 of yacc.c  */
10353 #line 4738 "ripper.y"
10354     {
10355 #if 0
10356                         value_expr((yyvsp[(1) - (1)].val));
10357                         (yyval.val) = (yyvsp[(1) - (1)].val);
10358                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
10359 #endif
10360                         (yyval.val) = (yyvsp[(1) - (1)].val);
10361 
10362                     }
10363     break;
10364 
10365   case 540:
10366 /* Line 1787 of yacc.c  */
10367 #line 4747 "ripper.y"
10368     {lex_state = EXPR_BEG;}
10369     break;
10370 
10371   case 541:
10372 /* Line 1787 of yacc.c  */
10373 #line 4748 "ripper.y"
10374     {
10375 #if 0
10376                         if ((yyvsp[(3) - (4)].val) == 0) {
10377                             yyerror("can't define singleton method for ().");
10378                         }
10379                         else {
10380                             switch (nd_type((yyvsp[(3) - (4)].val))) {
10381                               case NODE_STR:
10382                               case NODE_DSTR:
10383                               case NODE_XSTR:
10384                               case NODE_DXSTR:
10385                               case NODE_DREGX:
10386                               case NODE_LIT:
10387                               case NODE_ARRAY:
10388                               case NODE_ZARRAY:
10389                                 yyerror("can't define singleton method for literals");
10390                               default:
10391                                 value_expr((yyvsp[(3) - (4)].val));
10392                                 break;
10393                             }
10394                         }
10395                         (yyval.val) = (yyvsp[(3) - (4)].val);
10396 #endif
10397                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10398 
10399                     }
10400     break;
10401 
10402   case 543:
10403 /* Line 1787 of yacc.c  */
10404 #line 4778 "ripper.y"
10405     {
10406 #if 0
10407                         (yyval.val) = (yyvsp[(1) - (2)].val);
10408 #endif
10409                         (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10410 
10411                     }
10412     break;
10413 
10414   case 544:
10415 /* Line 1787 of yacc.c  */
10416 #line 4790 "ripper.y"
10417     {
10418                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10419                     }
10420     break;
10421 
10422   case 545:
10423 /* Line 1787 of yacc.c  */
10424 #line 4795 "ripper.y"
10425     {
10426 #if 0
10427                         (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10428 #endif
10429                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10430 
10431                     }
10432     break;
10433 
10434   case 546:
10435 /* Line 1787 of yacc.c  */
10436 #line 4805 "ripper.y"
10437     {
10438 #if 0
10439                         (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10440 #endif
10441                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10442 
10443                     }
10444     break;
10445 
10446   case 547:
10447 /* Line 1787 of yacc.c  */
10448 #line 4813 "ripper.y"
10449     {
10450 #if 0
10451                         (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10452 #endif
10453                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10454 
10455                     }
10456     break;
10457 
10458   case 558:
10459 /* Line 1787 of yacc.c  */
10460 #line 4841 "ripper.y"
10461     { (yyval.val) = (yyvsp[(1) - (1)].val); }
10462     break;
10463 
10464   case 559:
10465 /* Line 1787 of yacc.c  */
10466 #line 4846 "ripper.y"
10467     { (yyval.val) = (yyvsp[(1) - (1)].val); }
10468     break;
10469 
10470   case 569:
10471 /* Line 1787 of yacc.c  */
10472 #line 4869 "ripper.y"
10473     {yyerrok;}
10474     break;
10475 
10476   case 572:
10477 /* Line 1787 of yacc.c  */
10478 #line 4874 "ripper.y"
10479     {yyerrok;}
10480     break;
10481 
10482   case 573:
10483 /* Line 1787 of yacc.c  */
10484 #line 4878 "ripper.y"
10485     {
10486 #if 0
10487                         (yyval.val) = 0;
10488 #endif
10489                         (yyval.val) = Qundef;
10490 
10491                     }
10492     break;
10493 
10494 
10495 /* Line 1787 of yacc.c  */
10496 #line 10493 "parse.c"
10497       default: break;
10498     }
10499   /* User semantic actions sometimes alter yychar, and that requires
10500      that yytoken be updated with the new translation.  We take the
10501      approach of translating immediately before every use of yytoken.
10502      One alternative is translating here after every semantic action,
10503      but that translation would be missed if the semantic action invokes
10504      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10505      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
10506      incorrect destructor might then be invoked immediately.  In the
10507      case of YYERROR or YYBACKUP, subsequent parser actions might lead
10508      to an incorrect destructor call or verbose syntax error message
10509      before the lookahead is translated.  */
10510   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10511 
10512   YYPOPSTACK (yylen);
10513   yylen = 0;
10514   YY_STACK_PRINT (yyss, yyssp);
10515 
10516   *++yyvsp = yyval;
10517 
10518   /* Now `shift' the result of the reduction.  Determine what state
10519      that goes to, based on the state we popped back to and the rule
10520      number reduced by.  */
10521 
10522   yyn = yyr1[yyn];
10523 
10524   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10525   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10526     yystate = yytable[yystate];
10527   else
10528     yystate = yydefgoto[yyn - YYNTOKENS];
10529 
10530   goto yynewstate;
10531 
10532 
10533 /*------------------------------------.
10534 | yyerrlab -- here on detecting error |
10535 `------------------------------------*/
10536 yyerrlab:
10537   /* Make sure we have latest lookahead translation.  See comments at
10538      user semantic actions for why this is necessary.  */
10539   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10540 
10541   /* If not already recovering from an error, report this error.  */
10542   if (!yyerrstatus)
10543     {
10544       ++yynerrs;
10545 #if ! YYERROR_VERBOSE
10546       parser_yyerror (parser, YY_("syntax error"));
10547 #else
10548 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10549                                         yyssp, yytoken)
10550       {
10551         char const *yymsgp = YY_("syntax error");
10552         int yysyntax_error_status;
10553         yysyntax_error_status = YYSYNTAX_ERROR;
10554         if (yysyntax_error_status == 0)
10555           yymsgp = yymsg;
10556         else if (yysyntax_error_status == 1)
10557           {
10558             if (yymsg != yymsgbuf)
10559               YYSTACK_FREE (yymsg);
10560             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
10561             if (!yymsg)
10562               {
10563                 yymsg = yymsgbuf;
10564                 yymsg_alloc = sizeof yymsgbuf;
10565                 yysyntax_error_status = 2;
10566               }
10567             else
10568               {
10569                 yysyntax_error_status = YYSYNTAX_ERROR;
10570                 yymsgp = yymsg;
10571               }
10572           }
10573         parser_yyerror (parser, yymsgp);
10574         if (yysyntax_error_status == 2)
10575           goto yyexhaustedlab;
10576       }
10577 # undef YYSYNTAX_ERROR
10578 #endif
10579     }
10580 
10581 
10582 
10583   if (yyerrstatus == 3)
10584     {
10585       /* If just tried and failed to reuse lookahead token after an
10586          error, discard it.  */
10587 
10588       if (yychar <= YYEOF)
10589         {
10590           /* Return failure if at end of input.  */
10591           if (yychar == YYEOF)
10592             YYABORT;
10593         }
10594       else
10595         {
10596           yydestruct ("Error: discarding",
10597                       yytoken, &yylval, parser);
10598           yychar = YYEMPTY;
10599         }
10600     }
10601 
10602   /* Else will try to reuse lookahead token after shifting the error
10603      token.  */
10604   goto yyerrlab1;
10605 
10606 
10607 /*---------------------------------------------------.
10608 | yyerrorlab -- error raised explicitly by YYERROR.  |
10609 `---------------------------------------------------*/
10610 yyerrorlab:
10611 
10612   /* Pacify compilers like GCC when the user code never invokes
10613      YYERROR and the label yyerrorlab therefore never appears in user
10614      code.  */
10615   if (/*CONSTCOND*/ 0)
10616      goto yyerrorlab;
10617 
10618   /* Do not reclaim the symbols of the rule which action triggered
10619      this YYERROR.  */
10620   YYPOPSTACK (yylen);
10621   yylen = 0;
10622   YY_STACK_PRINT (yyss, yyssp);
10623   yystate = *yyssp;
10624   goto yyerrlab1;
10625 
10626 
10627 /*-------------------------------------------------------------.
10628 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
10629 `-------------------------------------------------------------*/
10630 yyerrlab1:
10631   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
10632 
10633   for (;;)
10634     {
10635       yyn = yypact[yystate];
10636       if (!yypact_value_is_default (yyn))
10637         {
10638           yyn += YYTERROR;
10639           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10640             {
10641               yyn = yytable[yyn];
10642               if (0 < yyn)
10643                 break;
10644             }
10645         }
10646 
10647       /* Pop the current state because it cannot handle the error token.  */
10648       if (yyssp == yyss)
10649         YYABORT;
10650 
10651 
10652       yydestruct ("Error: popping",
10653                   yystos[yystate], yyvsp, parser);
10654       YYPOPSTACK (1);
10655       yystate = *yyssp;
10656       YY_STACK_PRINT (yyss, yyssp);
10657     }
10658 
10659   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
10660   *++yyvsp = yylval;
10661   YY_IGNORE_MAYBE_UNINITIALIZED_END
10662 
10663 
10664   /* Shift the error token.  */
10665   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10666 
10667   yystate = yyn;
10668   goto yynewstate;
10669 
10670 
10671 /*-------------------------------------.
10672 | yyacceptlab -- YYACCEPT comes here.  |
10673 `-------------------------------------*/
10674 yyacceptlab:
10675   yyresult = 0;
10676   goto yyreturn;
10677 
10678 /*-----------------------------------.
10679 | yyabortlab -- YYABORT comes here.  |
10680 `-----------------------------------*/
10681 yyabortlab:
10682   yyresult = 1;
10683   goto yyreturn;
10684 
10685 #if !defined yyoverflow || YYERROR_VERBOSE
10686 /*-------------------------------------------------.
10687 | yyexhaustedlab -- memory exhaustion comes here.  |
10688 `-------------------------------------------------*/
10689 yyexhaustedlab:
10690   parser_yyerror (parser, YY_("memory exhausted"));
10691   yyresult = 2;
10692   /* Fall through.  */
10693 #endif
10694 
10695 yyreturn:
10696   if (yychar != YYEMPTY)
10697     {
10698       /* Make sure we have latest lookahead translation.  See comments at
10699          user semantic actions for why this is necessary.  */
10700       yytoken = YYTRANSLATE (yychar);
10701       yydestruct ("Cleanup: discarding lookahead",
10702                   yytoken, &yylval, parser);
10703     }
10704   /* Do not reclaim the symbols of the rule which action triggered
10705      this YYABORT or YYACCEPT.  */
10706   YYPOPSTACK (yylen);
10707   YY_STACK_PRINT (yyss, yyssp);
10708   while (yyssp != yyss)
10709     {
10710       yydestruct ("Cleanup: popping",
10711                   yystos[*yyssp], yyvsp, parser);
10712       YYPOPSTACK (1);
10713     }
10714 #ifndef yyoverflow
10715   if (yyss != yyssa)
10716     YYSTACK_FREE (yyss);
10717 #endif
10718 #if YYERROR_VERBOSE
10719   if (yymsg != yymsgbuf)
10720     YYSTACK_FREE (yymsg);
10721 #endif
10722   /* Make sure YYID is used.  */
10723   return YYID (yyresult);
10724 }
10725 
10726 
10727 /* Line 2050 of yacc.c  */
10728 #line 4886 "ripper.y"
10729 
10730 # undef parser
10731 # undef yylex
10732 # undef yylval
10733 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
10734 
10735 static int parser_regx_options(struct parser_params*);
10736 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
10737 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
10738 static int parser_parse_string(struct parser_params*,NODE*);
10739 static int parser_here_document(struct parser_params*,NODE*);
10740 
10741 
10742 # define nextc()                   parser_nextc(parser)
10743 # define pushback(c)               parser_pushback(parser, (c))
10744 # define newtok()                  parser_newtok(parser)
10745 # define tokspace(n)               parser_tokspace(parser, (n))
10746 # define tokadd(c)                 parser_tokadd(parser, (c))
10747 # define tok_hex(numlen)           parser_tok_hex(parser, (numlen))
10748 # define read_escape(flags,e)      parser_read_escape(parser, (flags), (e))
10749 # define tokadd_escape(e)          parser_tokadd_escape(parser, (e))
10750 # define regx_options()            parser_regx_options(parser)
10751 # define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser,(f),(t),(p),(n),(e))
10752 # define parse_string(n)           parser_parse_string(parser,(n))
10753 # define tokaddmbc(c, enc)         parser_tokaddmbc(parser, (c), (enc))
10754 # define here_document(n)          parser_here_document(parser,(n))
10755 # define heredoc_identifier()      parser_heredoc_identifier(parser)
10756 # define heredoc_restore(n)        parser_heredoc_restore(parser,(n))
10757 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,(e),(l),(i))
10758 
10759 #ifndef RIPPER
10760 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
10761 # define set_yylval_num(x) (yylval.num = (x))
10762 # define set_yylval_id(x)  (yylval.id = (x))
10763 # define set_yylval_name(x)  (yylval.id = (x))
10764 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
10765 # define set_yylval_node(x) (yylval.node = (x))
10766 # define yylval_id() (yylval.id)
10767 #else
10768 static inline VALUE
10769 ripper_yylval_id(ID x)
10770 {
10771     return (VALUE)NEW_LASGN(x, ID2SYM(x));
10772 }
10773 # define set_yylval_str(x) (void)(x)
10774 # define set_yylval_num(x) (void)(x)
10775 # define set_yylval_id(x)  (void)(x)
10776 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
10777 # define set_yylval_literal(x) (void)(x)
10778 # define set_yylval_node(x) (void)(x)
10779 # define yylval_id() yylval.id
10780 #endif
10781 
10782 #ifndef RIPPER
10783 #define ripper_flush(p) (void)(p)
10784 #else
10785 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
10786 
10787 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
10788 
10789 static int
10790 ripper_has_scan_event(struct parser_params *parser)
10791 {
10792 
10793     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
10794     return lex_p > parser->tokp;
10795 }
10796 
10797 static VALUE
10798 ripper_scan_event_val(struct parser_params *parser, int t)
10799 {
10800     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
10801     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
10802     ripper_flush(parser);
10803     return rval;
10804 }
10805 
10806 static void
10807 ripper_dispatch_scan_event(struct parser_params *parser, int t)
10808 {
10809     if (!ripper_has_scan_event(parser)) return;
10810     yylval_rval = ripper_scan_event_val(parser, t);
10811 }
10812 
10813 static void
10814 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
10815 {
10816     if (!ripper_has_scan_event(parser)) return;
10817     (void)ripper_scan_event_val(parser, t);
10818 }
10819 
10820 static void
10821 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
10822 {
10823     int saved_line = ruby_sourceline;
10824     const char *saved_tokp = parser->tokp;
10825 
10826     ruby_sourceline = parser->delayed_line;
10827     parser->tokp = lex_pbeg + parser->delayed_col;
10828     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
10829     parser->delayed = Qnil;
10830     ruby_sourceline = saved_line;
10831     parser->tokp = saved_tokp;
10832 }
10833 #endif /* RIPPER */
10834 
10835 #include "ruby/regex.h"
10836 #include "ruby/util.h"
10837 
10838 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
10839    since ours (we hope) works properly with all combinations of
10840    machines, compilers, `char' and `unsigned char' argument types.
10841    (Per Bothner suggested the basic approach.)  */
10842 #undef SIGN_EXTEND_CHAR
10843 #if __STDC__
10844 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
10845 #else  /* not __STDC__ */
10846 /* As in Harbison and Steele.  */
10847 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
10848 #endif
10849 
10850 #define parser_encoding_name()  (parser->enc->name)
10851 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,parser->enc)
10852 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
10853 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
10854 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
10855 
10856 #define parser_isascii() ISASCII(*(lex_p-1))
10857 
10858 #ifndef RIPPER
10859 static int
10860 token_info_get_column(struct parser_params *parser, const char *token)
10861 {
10862     int column = 1;
10863     const char *p, *pend = lex_p - strlen(token);
10864     for (p = lex_pbeg; p < pend; p++) {
10865         if (*p == '\t') {
10866             column = (((column - 1) / 8) + 1) * 8;
10867         }
10868         column++;
10869     }
10870     return column;
10871 }
10872 
10873 static int
10874 token_info_has_nonspaces(struct parser_params *parser, const char *token)
10875 {
10876     const char *p, *pend = lex_p - strlen(token);
10877     for (p = lex_pbeg; p < pend; p++) {
10878         if (*p != ' ' && *p != '\t') {
10879             return 1;
10880         }
10881     }
10882     return 0;
10883 }
10884 
10885 #undef token_info_push
10886 static void
10887 token_info_push(struct parser_params *parser, const char *token)
10888 {
10889     token_info *ptinfo;
10890 
10891     if (!parser->parser_token_info_enabled) return;
10892     ptinfo = ALLOC(token_info);
10893     ptinfo->token = token;
10894     ptinfo->linenum = ruby_sourceline;
10895     ptinfo->column = token_info_get_column(parser, token);
10896     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
10897     ptinfo->next = parser->parser_token_info;
10898 
10899     parser->parser_token_info = ptinfo;
10900 }
10901 
10902 #undef token_info_pop
10903 static void
10904 token_info_pop(struct parser_params *parser, const char *token)
10905 {
10906     int linenum;
10907     token_info *ptinfo = parser->parser_token_info;
10908 
10909     if (!ptinfo) return;
10910     parser->parser_token_info = ptinfo->next;
10911     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
10912         goto finish;
10913     }
10914     linenum = ruby_sourceline;
10915     if (linenum == ptinfo->linenum) { /* SKIP */
10916         goto finish;
10917     }
10918     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
10919         goto finish;
10920     }
10921     if (parser->parser_token_info_enabled) {
10922         rb_compile_warn(ruby_sourcefile, linenum,
10923                         "mismatched indentations at '%s' with '%s' at %d",
10924                         token, ptinfo->token, ptinfo->linenum);
10925     }
10926 
10927   finish:
10928     xfree(ptinfo);
10929 }
10930 #endif  /* RIPPER */
10931 
10932 static int
10933 parser_yyerror(struct parser_params *parser, const char *msg)
10934 {
10935 #ifndef RIPPER
10936     const int max_line_margin = 30;
10937     const char *p, *pe;
10938     char *buf;
10939     long len;
10940     int i;
10941 
10942     compile_error(PARSER_ARG "%s", msg);
10943     p = lex_p;
10944     while (lex_pbeg <= p) {
10945         if (*p == '\n') break;
10946         p--;
10947     }
10948     p++;
10949 
10950     pe = lex_p;
10951     while (pe < lex_pend) {
10952         if (*pe == '\n') break;
10953         pe++;
10954     }
10955 
10956     len = pe - p;
10957     if (len > 4) {
10958         char *p2;
10959         const char *pre = "", *post = "";
10960 
10961         if (len > max_line_margin * 2 + 10) {
10962             if (lex_p - p > max_line_margin) {
10963                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
10964                 pre = "...";
10965             }
10966             if (pe - lex_p > max_line_margin) {
10967                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
10968                 post = "...";
10969             }
10970             len = pe - p;
10971         }
10972         buf = ALLOCA_N(char, len+2);
10973         MEMCPY(buf, p, char, len);
10974         buf[len] = '\0';
10975         rb_compile_error_append("%s%s%s", pre, buf, post);
10976 
10977         i = (int)(lex_p - p);
10978         p2 = buf; pe = buf + len;
10979 
10980         while (p2 < pe) {
10981             if (*p2 != '\t') *p2 = ' ';
10982             p2++;
10983         }
10984         buf[i] = '^';
10985         buf[i+1] = '\0';
10986         rb_compile_error_append("%s%s", pre, buf);
10987     }
10988 #else
10989     dispatch1(parse_error, STR_NEW2(msg));
10990 #endif /* !RIPPER */
10991     return 0;
10992 }
10993 
10994 static void parser_prepare(struct parser_params *parser);
10995 
10996 #ifndef RIPPER
10997 static VALUE
10998 debug_lines(const char *f)
10999 {
11000     ID script_lines;
11001     CONST_ID(script_lines, "SCRIPT_LINES__");
11002     if (rb_const_defined_at(rb_cObject, script_lines)) {
11003         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11004         if (TYPE(hash) == T_HASH) {
11005             VALUE fname = rb_external_str_new_with_enc(f, strlen(f), rb_filesystem_encoding());
11006             VALUE lines = rb_ary_new();
11007             rb_hash_aset(hash, fname, lines);
11008             return lines;
11009         }
11010     }
11011     return 0;
11012 }
11013 
11014 static VALUE
11015 coverage(const char *f, int n)
11016 {
11017     VALUE coverages = rb_get_coverages();
11018     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11019         VALUE fname = rb_external_str_new_with_enc(f, strlen(f), rb_filesystem_encoding());
11020         VALUE lines = rb_ary_new2(n);
11021         int i;
11022         RBASIC(lines)->klass = 0;
11023         for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11024         RARRAY(lines)->as.heap.len = n;
11025         rb_hash_aset(coverages, fname, lines);
11026         return lines;
11027     }
11028     return 0;
11029 }
11030 
11031 static int
11032 e_option_supplied(struct parser_params *parser)
11033 {
11034     return strcmp(ruby_sourcefile, "-e") == 0;
11035 }
11036 
11037 static VALUE
11038 yycompile0(VALUE arg, int tracing)
11039 {
11040     int n;
11041     NODE *tree;
11042     struct parser_params *parser = (struct parser_params *)arg;
11043 
11044     if (!compile_for_eval && rb_safe_level() == 0) {
11045         ruby_debug_lines = debug_lines(ruby_sourcefile);
11046         if (ruby_debug_lines && ruby_sourceline > 0) {
11047             VALUE str = STR_NEW0();
11048             n = ruby_sourceline;
11049             do {
11050                 rb_ary_push(ruby_debug_lines, str);
11051             } while (--n);
11052         }
11053 
11054         if (!e_option_supplied(parser)) {
11055             ruby_coverage = coverage(ruby_sourcefile, ruby_sourceline);
11056         }
11057     }
11058 
11059     parser_prepare(parser);
11060     deferred_nodes = 0;
11061 #ifndef RIPPER
11062     parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
11063 #endif
11064     n = yyparse((void*)parser);
11065     ruby_debug_lines = 0;
11066     ruby_coverage = 0;
11067     compile_for_eval = 0;
11068 
11069     lex_strterm = 0;
11070     lex_p = lex_pbeg = lex_pend = 0;
11071     lex_lastline = lex_nextline = 0;
11072     if (parser->nerr) {
11073         return 0;
11074     }
11075     tree = ruby_eval_tree;
11076     if (!tree) {
11077         tree = NEW_NIL();
11078     }
11079     else if (ruby_eval_tree_begin) {
11080         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11081     }
11082     return (VALUE)tree;
11083 }
11084 
11085 static NODE*
11086 yycompile(struct parser_params *parser, const char *f, int line)
11087 {
11088     ruby_sourcefile = ruby_strdup(f);
11089     ruby_sourceline = line - 1;
11090     return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
11091 }
11092 #endif /* !RIPPER */
11093 
11094 static rb_encoding *
11095 must_be_ascii_compatible(VALUE s)
11096 {
11097     rb_encoding *enc = rb_enc_get(s);
11098     if (!rb_enc_asciicompat(enc)) {
11099         rb_raise(rb_eArgError, "invalid source encoding");
11100     }
11101     return enc;
11102 }
11103 
11104 static VALUE
11105 lex_get_str(struct parser_params *parser, VALUE s)
11106 {
11107     char *beg, *end, *pend;
11108     rb_encoding *enc = must_be_ascii_compatible(s);
11109 
11110     beg = RSTRING_PTR(s);
11111     if (lex_gets_ptr) {
11112         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11113         beg += lex_gets_ptr;
11114     }
11115     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11116     end = beg;
11117     while (end < pend) {
11118         if (*end++ == '\n') break;
11119     }
11120     lex_gets_ptr = end - RSTRING_PTR(s);
11121     return rb_enc_str_new(beg, end - beg, enc);
11122 }
11123 
11124 static VALUE
11125 lex_getline(struct parser_params *parser)
11126 {
11127     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11128     if (NIL_P(line)) return line;
11129     must_be_ascii_compatible(line);
11130 #ifndef RIPPER
11131     if (ruby_debug_lines) {
11132         rb_enc_associate(line, parser->enc);
11133         rb_ary_push(ruby_debug_lines, line);
11134     }
11135     if (ruby_coverage) {
11136         rb_ary_push(ruby_coverage, Qnil);
11137     }
11138 #endif
11139     return line;
11140 }
11141 
11142 #ifdef RIPPER
11143 static rb_data_type_t parser_data_type;
11144 #else
11145 static const rb_data_type_t parser_data_type;
11146 
11147 static NODE*
11148 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11149 {
11150     struct parser_params *parser;
11151     NODE *node;
11152     volatile VALUE tmp;
11153 
11154     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11155     lex_gets = lex_get_str;
11156     lex_gets_ptr = 0;
11157     lex_input = s;
11158     lex_pbeg = lex_p = lex_pend = 0;
11159     compile_for_eval = rb_parse_in_eval();
11160 
11161     node = yycompile(parser, f, line);
11162     tmp = vparser; /* prohibit tail call optimization */
11163 
11164     return node;
11165 }
11166 
11167 NODE*
11168 rb_compile_string(const char *f, VALUE s, int line)
11169 {
11170     must_be_ascii_compatible(s);
11171     return parser_compile_string(rb_parser_new(), f, s, line);
11172 }
11173 
11174 NODE*
11175 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11176 {
11177     must_be_ascii_compatible(s);
11178     return parser_compile_string(vparser, f, s, line);
11179 }
11180 
11181 NODE*
11182 rb_compile_cstr(const char *f, const char *s, int len, int line)
11183 {
11184     VALUE str = rb_str_new(s, len);
11185     return parser_compile_string(rb_parser_new(), f, str, line);
11186 }
11187 
11188 NODE*
11189 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11190 {
11191     VALUE str = rb_str_new(s, len);
11192     return parser_compile_string(vparser, f, str, line);
11193 }
11194 
11195 static VALUE
11196 lex_io_gets(struct parser_params *parser, VALUE io)
11197 {
11198     return rb_io_gets(io);
11199 }
11200 
11201 NODE*
11202 rb_compile_file(const char *f, VALUE file, int start)
11203 {
11204     VALUE volatile vparser = rb_parser_new();
11205 
11206     return rb_parser_compile_file(vparser, f, file, start);
11207 }
11208 
11209 NODE*
11210 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11211 {
11212     struct parser_params *parser;
11213     volatile VALUE tmp;
11214     NODE *node;
11215 
11216     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11217     lex_gets = lex_io_gets;
11218     lex_input = file;
11219     lex_pbeg = lex_p = lex_pend = 0;
11220     compile_for_eval = rb_parse_in_eval();
11221 
11222     node = yycompile(parser, f, start);
11223     tmp = vparser; /* prohibit tail call optimization */
11224 
11225     return node;
11226 }
11227 #endif  /* !RIPPER */
11228 
11229 #define STR_FUNC_ESCAPE 0x01
11230 #define STR_FUNC_EXPAND 0x02
11231 #define STR_FUNC_REGEXP 0x04
11232 #define STR_FUNC_QWORDS 0x08
11233 #define STR_FUNC_SYMBOL 0x10
11234 #define STR_FUNC_INDENT 0x20
11235 
11236 enum string_type {
11237     str_squote = (0),
11238     str_dquote = (STR_FUNC_EXPAND),
11239     str_xquote = (STR_FUNC_EXPAND),
11240     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
11241     str_sword  = (STR_FUNC_QWORDS),
11242     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
11243     str_ssym   = (STR_FUNC_SYMBOL),
11244     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
11245 };
11246 
11247 static VALUE
11248 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11249 {
11250     VALUE str;
11251 
11252     str = rb_enc_str_new(p, n, enc);
11253     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11254         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
11255         }
11256         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11257             rb_enc_associate(str, rb_ascii8bit_encoding());
11258         }
11259     }
11260 
11261     return str;
11262 }
11263 
11264 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11265 #define lex_eol_p() (lex_p >= lex_pend)
11266 #define peek(c) peek_n((c), 0)
11267 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11268 
11269 static inline int
11270 parser_nextc(struct parser_params *parser)
11271 {
11272     int c;
11273 
11274     if (lex_p == lex_pend) {
11275         VALUE v = lex_nextline;
11276         lex_nextline = 0;
11277         if (!v) {
11278             if (parser->eofp)
11279                 return -1;
11280 
11281             if (!lex_input || NIL_P(v = lex_getline(parser))) {
11282                 parser->eofp = Qtrue;
11283                 lex_goto_eol(parser);
11284                 return -1;
11285             }
11286         }
11287         {
11288 #ifdef RIPPER
11289             if (parser->tokp < lex_pend) {
11290                 if (NIL_P(parser->delayed)) {
11291                     parser->delayed = rb_str_buf_new(1024);
11292                     rb_enc_associate(parser->delayed, parser->enc);
11293                     rb_str_buf_cat(parser->delayed,
11294                                    parser->tokp, lex_pend - parser->tokp);
11295                     parser->delayed_line = ruby_sourceline;
11296                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11297                 }
11298                 else {
11299                     rb_str_buf_cat(parser->delayed,
11300                                    parser->tokp, lex_pend - parser->tokp);
11301                 }
11302             }
11303 #endif
11304             if (heredoc_end > 0) {
11305                 ruby_sourceline = heredoc_end;
11306                 heredoc_end = 0;
11307             }
11308             ruby_sourceline++;
11309             parser->line_count++;
11310             lex_pbeg = lex_p = RSTRING_PTR(v);
11311             lex_pend = lex_p + RSTRING_LEN(v);
11312             ripper_flush(parser);
11313             lex_lastline = v;
11314         }
11315     }
11316     c = (unsigned char)*lex_p++;
11317     if (c == '\r' && peek('\n')) {
11318         lex_p++;
11319         c = '\n';
11320     }
11321 
11322     return c;
11323 }
11324 
11325 static void
11326 parser_pushback(struct parser_params *parser, int c)
11327 {
11328     if (c == -1) return;
11329     lex_p--;
11330     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11331         lex_p--;
11332     }
11333 }
11334 
11335 #define was_bol() (lex_p == lex_pbeg + 1)
11336 
11337 #define tokfix() (tokenbuf[tokidx]='\0')
11338 #define tok() tokenbuf
11339 #define toklen() tokidx
11340 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11341 
11342 static char*
11343 parser_newtok(struct parser_params *parser)
11344 {
11345     tokidx = 0;
11346     if (!tokenbuf) {
11347         toksiz = 60;
11348         tokenbuf = ALLOC_N(char, 60);
11349     }
11350     if (toksiz > 4096) {
11351         toksiz = 60;
11352         REALLOC_N(tokenbuf, char, 60);
11353     }
11354     return tokenbuf;
11355 }
11356 
11357 static char *
11358 parser_tokspace(struct parser_params *parser, int n)
11359 {
11360     tokidx += n;
11361 
11362     if (tokidx >= toksiz) {
11363         do {toksiz *= 2;} while (toksiz < tokidx);
11364         REALLOC_N(tokenbuf, char, toksiz);
11365     }
11366     return &tokenbuf[tokidx-n];
11367 }
11368 
11369 static void
11370 parser_tokadd(struct parser_params *parser, int c)
11371 {
11372     tokenbuf[tokidx++] = (char)c;
11373     if (tokidx >= toksiz) {
11374         toksiz *= 2;
11375         REALLOC_N(tokenbuf, char, toksiz);
11376     }
11377 }
11378 
11379 static int
11380 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11381 {
11382     int c;
11383 
11384     c = scan_hex(lex_p, 2, numlen);
11385     if (!*numlen) {
11386         yyerror("invalid hex escape");
11387         return 0;
11388     }
11389     lex_p += *numlen;
11390     return c;
11391 }
11392 
11393 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11394 
11395 static int
11396 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
11397                    int string_literal, int symbol_literal, int regexp_literal)
11398 {
11399     /*
11400      * If string_literal is true, then we allow multiple codepoints
11401      * in \u{}, and add the codepoints to the current token.
11402      * Otherwise we're parsing a character literal and return a single
11403      * codepoint without adding it
11404      */
11405 
11406     int codepoint;
11407     size_t numlen;
11408 
11409     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11410 
11411     if (peek('{')) {  /* handle \u{...} form */
11412         do {
11413             if (regexp_literal) { tokadd(*lex_p); }
11414             nextc();
11415             codepoint = scan_hex(lex_p, 6, &numlen);
11416             if (numlen == 0)  {
11417                 yyerror("invalid Unicode escape");
11418                 return 0;
11419             }
11420             if (codepoint > 0x10ffff) {
11421                 yyerror("invalid Unicode codepoint (too large)");
11422                 return 0;
11423             }
11424             lex_p += numlen;
11425             if (regexp_literal) {
11426                 tokcopy((int)numlen);
11427             }
11428             else if (codepoint >= 0x80) {
11429                 *encp = UTF8_ENC();
11430                 if (string_literal) tokaddmbc(codepoint, *encp);
11431             }
11432             else if (string_literal) {
11433                 tokadd(codepoint);
11434             }
11435         } while (string_literal && (peek(' ') || peek('\t')));
11436 
11437         if (!peek('}')) {
11438             yyerror("unterminated Unicode escape");
11439             return 0;
11440         }
11441 
11442         if (regexp_literal) { tokadd('}'); }
11443         nextc();
11444     }
11445     else {                      /* handle \uxxxx form */
11446         codepoint = scan_hex(lex_p, 4, &numlen);
11447         if (numlen < 4) {
11448             yyerror("invalid Unicode escape");
11449             return 0;
11450         }
11451         lex_p += 4;
11452         if (regexp_literal) {
11453             tokcopy(4);
11454         }
11455         else if (codepoint >= 0x80) {
11456             *encp = UTF8_ENC();
11457             if (string_literal) tokaddmbc(codepoint, *encp);
11458         }
11459         else if (string_literal) {
11460             tokadd(codepoint);
11461         }
11462     }
11463 
11464     return codepoint;
11465 }
11466 
11467 #define ESCAPE_CONTROL 1
11468 #define ESCAPE_META    2
11469 
11470 static int
11471 parser_read_escape(struct parser_params *parser, int flags,
11472                    rb_encoding **encp)
11473 {
11474     int c;
11475     size_t numlen;
11476 
11477     switch (c = nextc()) {
11478       case '\\':        /* Backslash */
11479         return c;
11480 
11481       case 'n': /* newline */
11482         return '\n';
11483 
11484       case 't': /* horizontal tab */
11485         return '\t';
11486 
11487       case 'r': /* carriage-return */
11488         return '\r';
11489 
11490       case 'f': /* form-feed */
11491         return '\f';
11492 
11493       case 'v': /* vertical tab */
11494         return '\13';
11495 
11496       case 'a': /* alarm(bell) */
11497         return '\007';
11498 
11499       case 'e': /* escape */
11500         return 033;
11501 
11502       case '0': case '1': case '2': case '3': /* octal constant */
11503       case '4': case '5': case '6': case '7':
11504         pushback(c);
11505         c = scan_oct(lex_p, 3, &numlen);
11506         lex_p += numlen;
11507         return c;
11508 
11509       case 'x': /* hex constant */
11510         c = tok_hex(&numlen);
11511         if (numlen == 0) return 0;
11512         return c;
11513 
11514       case 'b': /* backspace */
11515         return '\010';
11516 
11517       case 's': /* space */
11518         return ' ';
11519 
11520       case 'M':
11521         if (flags & ESCAPE_META) goto eof;
11522         if ((c = nextc()) != '-') {
11523             pushback(c);
11524             goto eof;
11525         }
11526         if ((c = nextc()) == '\\') {
11527             if (peek('u')) goto eof;
11528             return read_escape(flags|ESCAPE_META, encp) | 0x80;
11529         }
11530         else if (c == -1 || !ISASCII(c)) goto eof;
11531         else {
11532             return ((c & 0xff) | 0x80);
11533         }
11534 
11535       case 'C':
11536         if ((c = nextc()) != '-') {
11537             pushback(c);
11538             goto eof;
11539         }
11540       case 'c':
11541         if (flags & ESCAPE_CONTROL) goto eof;
11542         if ((c = nextc())== '\\') {
11543             if (peek('u')) goto eof;
11544             c = read_escape(flags|ESCAPE_CONTROL, encp);
11545         }
11546         else if (c == '?')
11547             return 0177;
11548         else if (c == -1 || !ISASCII(c)) goto eof;
11549         return c & 0x9f;
11550 
11551       eof:
11552       case -1:
11553         yyerror("Invalid escape character syntax");
11554         return '\0';
11555 
11556       default:
11557         return c;
11558     }
11559 }
11560 
11561 static void
11562 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
11563 {
11564     int len = rb_enc_codelen(c, enc);
11565     rb_enc_mbcput(c, tokspace(len), enc);
11566 }
11567 
11568 static int
11569 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
11570 {
11571     int c;
11572     int flags = 0;
11573     size_t numlen;
11574 
11575   first:
11576     switch (c = nextc()) {
11577       case '\n':
11578         return 0;               /* just ignore */
11579 
11580       case '0': case '1': case '2': case '3': /* octal constant */
11581       case '4': case '5': case '6': case '7':
11582         {
11583             ruby_scan_oct(--lex_p, 3, &numlen);
11584             if (numlen == 0) goto eof;
11585             lex_p += numlen;
11586             tokcopy((int)numlen + 1);
11587         }
11588         return 0;
11589 
11590       case 'x': /* hex constant */
11591         {
11592             tok_hex(&numlen);
11593             if (numlen == 0) return -1;
11594             tokcopy((int)numlen + 2);
11595         }
11596         return 0;
11597 
11598       case 'M':
11599         if (flags & ESCAPE_META) goto eof;
11600         if ((c = nextc()) != '-') {
11601             pushback(c);
11602             goto eof;
11603         }
11604         tokcopy(3);
11605         flags |= ESCAPE_META;
11606         goto escaped;
11607 
11608       case 'C':
11609         if (flags & ESCAPE_CONTROL) goto eof;
11610         if ((c = nextc()) != '-') {
11611             pushback(c);
11612             goto eof;
11613         }
11614         tokcopy(3);
11615         goto escaped;
11616 
11617       case 'c':
11618         if (flags & ESCAPE_CONTROL) goto eof;
11619         tokcopy(2);
11620         flags |= ESCAPE_CONTROL;
11621       escaped:
11622         if ((c = nextc()) == '\\') {
11623             goto first;
11624         }
11625         else if (c == -1) goto eof;
11626         tokadd(c);
11627         return 0;
11628 
11629       eof:
11630       case -1:
11631         yyerror("Invalid escape character syntax");
11632         return -1;
11633 
11634       default:
11635         tokadd('\\');
11636         tokadd(c);
11637     }
11638     return 0;
11639 }
11640 
11641 static int
11642 parser_regx_options(struct parser_params *parser)
11643 {
11644     int kcode = 0;
11645     int kopt = 0;
11646     int options = 0;
11647     int c, opt, kc;
11648 
11649     newtok();
11650     while (c = nextc(), ISALPHA(c)) {
11651         if (c == 'o') {
11652             options |= RE_OPTION_ONCE;
11653         }
11654         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
11655             if (kc >= 0) {
11656                 if (kc != rb_ascii8bit_encindex()) kcode = c;
11657                 kopt = opt;
11658             }
11659             else {
11660                 options |= opt;
11661             }
11662         }
11663         else {
11664             tokadd(c);
11665         }
11666     }
11667     options |= kopt;
11668     pushback(c);
11669     if (toklen()) {
11670         tokfix();
11671         compile_error(PARSER_ARG "unknown regexp option%s - %s",
11672                       toklen() > 1 ? "s" : "", tok());
11673     }
11674     return options | RE_OPTION_ENCODING(kcode);
11675 }
11676 
11677 static void
11678 dispose_string(VALUE str)
11679 {
11680     /* TODO: should use another API? */
11681     if (RBASIC(str)->flags & RSTRING_NOEMBED)
11682         xfree(RSTRING_PTR(str));
11683     rb_gc_force_recycle(str);
11684 }
11685 
11686 static int
11687 parser_tokadd_mbchar(struct parser_params *parser, int c)
11688 {
11689     int len = parser_precise_mbclen();
11690     if (!MBCLEN_CHARFOUND_P(len)) {
11691         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
11692         return -1;
11693     }
11694     tokadd(c);
11695     lex_p += --len;
11696     if (len > 0) tokcopy(len);
11697     return c;
11698 }
11699 
11700 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
11701 
11702 static int
11703 parser_tokadd_string(struct parser_params *parser,
11704                      int func, int term, int paren, long *nest,
11705                      rb_encoding **encp)
11706 {
11707     int c;
11708     int has_nonascii = 0;
11709     rb_encoding *enc = *encp;
11710     char *errbuf = 0;
11711     static const char mixed_msg[] = "%s mixed within %s source";
11712 
11713 #define mixed_error(enc1, enc2) if (!errbuf) {  \
11714         size_t len = sizeof(mixed_msg) - 4;     \
11715         len += strlen(rb_enc_name(enc1));       \
11716         len += strlen(rb_enc_name(enc2));       \
11717         errbuf = ALLOCA_N(char, len);           \
11718         snprintf(errbuf, len, mixed_msg,        \
11719                  rb_enc_name(enc1),             \
11720                  rb_enc_name(enc2));            \
11721         yyerror(errbuf);                        \
11722     }
11723 #define mixed_escape(beg, enc1, enc2) do {      \
11724         const char *pos = lex_p;                \
11725         lex_p = (beg);                          \
11726         mixed_error((enc1), (enc2));            \
11727         lex_p = pos;                            \
11728     } while (0)
11729 
11730     while ((c = nextc()) != -1) {
11731         if (paren && c == paren) {
11732             ++*nest;
11733         }
11734         else if (c == term) {
11735             if (!nest || !*nest) {
11736                 pushback(c);
11737                 break;
11738             }
11739             --*nest;
11740         }
11741         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
11742             int c2 = *lex_p;
11743             if (c2 == '$' || c2 == '@' || c2 == '{') {
11744                 pushback(c);
11745                 break;
11746             }
11747         }
11748         else if (c == '\\') {
11749             const char *beg = lex_p - 1;
11750             c = nextc();
11751             switch (c) {
11752               case '\n':
11753                 if (func & STR_FUNC_QWORDS) break;
11754                 if (func & STR_FUNC_EXPAND) continue;
11755                 tokadd('\\');
11756                 break;
11757 
11758               case '\\':
11759                 if (func & STR_FUNC_ESCAPE) tokadd(c);
11760                 break;
11761 
11762               case 'u':
11763                 if ((func & STR_FUNC_EXPAND) == 0) {
11764                     tokadd('\\');
11765                     break;
11766                 }
11767                 parser_tokadd_utf8(parser, &enc, 1,
11768                                    func & STR_FUNC_SYMBOL,
11769                                    func & STR_FUNC_REGEXP);
11770                 if (has_nonascii && enc != *encp) {
11771                     mixed_escape(beg, enc, *encp);
11772                 }
11773                 continue;
11774 
11775               default:
11776                 if (c == -1) return -1;
11777                 if (!ISASCII(c)) {
11778                     if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
11779                     goto non_ascii;
11780                 }
11781                 if (func & STR_FUNC_REGEXP) {
11782                     pushback(c);
11783                     if ((c = tokadd_escape(&enc)) < 0)
11784                         return -1;
11785                     if (has_nonascii && enc != *encp) {
11786                         mixed_escape(beg, enc, *encp);
11787                     }
11788                     continue;
11789                 }
11790                 else if (func & STR_FUNC_EXPAND) {
11791                     pushback(c);
11792                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
11793                     c = read_escape(0, &enc);
11794                 }
11795                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
11796                     /* ignore backslashed spaces in %w */
11797                 }
11798                 else if (c != term && !(paren && c == paren)) {
11799                     tokadd('\\');
11800                     pushback(c);
11801                     continue;
11802                 }
11803             }
11804         }
11805         else if (!parser_isascii()) {
11806           non_ascii:
11807             has_nonascii = 1;
11808             if (enc != *encp) {
11809                 mixed_error(enc, *encp);
11810                 continue;
11811             }
11812             if (tokadd_mbchar(c) == -1) return -1;
11813             continue;
11814         }
11815         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
11816             pushback(c);
11817             break;
11818         }
11819         if (c & 0x80) {
11820             has_nonascii = 1;
11821             if (enc != *encp) {
11822                 mixed_error(enc, *encp);
11823                 continue;
11824             }
11825         }
11826         tokadd(c);
11827     }
11828     *encp = enc;
11829     return c;
11830 }
11831 
11832 #define NEW_STRTERM(func, term, paren) \
11833         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
11834 
11835 #ifdef RIPPER
11836 static void
11837 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
11838 {
11839     if (!NIL_P(parser->delayed)) {
11840         ptrdiff_t len = lex_p - parser->tokp;
11841         if (len > 0) {
11842             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
11843         }
11844         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
11845         parser->tokp = lex_p;
11846     }
11847 }
11848 
11849 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
11850 #else
11851 #define flush_string_content(enc) ((void)(enc))
11852 #endif
11853 
11854 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
11855 /* this can be shared with ripper, since it's independent from struct
11856  * parser_params. */
11857 #ifndef RIPPER
11858 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
11859 #define SPECIAL_PUNCT(idx) ( \
11860         BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
11861         BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
11862         BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
11863         BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
11864         BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
11865         BIT('0', idx))
11866 const unsigned int ruby_global_name_punct_bits[] = {
11867     SPECIAL_PUNCT(0),
11868     SPECIAL_PUNCT(1),
11869     SPECIAL_PUNCT(2),
11870 };
11871 #undef BIT
11872 #undef SPECIAL_PUNCT
11873 #endif
11874 
11875 static inline int
11876 is_global_name_punct(const char c)
11877 {
11878     if (c <= 0x20 || 0x7e < c) return 0;
11879     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
11880 }
11881 
11882 static int
11883 parser_peek_variable_name(struct parser_params *parser)
11884 {
11885     int c;
11886     const char *p = lex_p;
11887 
11888     if (p + 1 >= lex_pend) return 0;
11889     c = *p++;
11890     switch (c) {
11891       case '$':
11892         if ((c = *p) == '-') {
11893             if (++p >= lex_pend) return 0;
11894             c = *p;
11895         }
11896         else if (is_global_name_punct(c) || ISDIGIT(c)) {
11897             return tSTRING_DVAR;
11898         }
11899         break;
11900       case '@':
11901         if ((c = *p) == '@') {
11902             if (++p >= lex_pend) return 0;
11903             c = *p;
11904         }
11905         break;
11906       case '{':
11907         lex_p = p;
11908         command_start = TRUE;
11909         return tSTRING_DBEG;
11910       default:
11911         return 0;
11912     }
11913     if (!ISASCII(c) || c == '_' || ISALPHA(c))
11914         return tSTRING_DVAR;
11915     return 0;
11916 }
11917 
11918 static int
11919 parser_parse_string(struct parser_params *parser, NODE *quote)
11920 {
11921     int func = (int)quote->nd_func;
11922     int term = nd_term(quote);
11923     int paren = nd_paren(quote);
11924     int c, space = 0;
11925     rb_encoding *enc = parser->enc;
11926 
11927     if (func == -1) return tSTRING_END;
11928     c = nextc();
11929     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
11930         do {c = nextc();} while (ISSPACE(c));
11931         space = 1;
11932     }
11933     if (c == term && !quote->nd_nest) {
11934         if (func & STR_FUNC_QWORDS) {
11935             quote->nd_func = -1;
11936             return ' ';
11937         }
11938         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
11939         set_yylval_num(regx_options());
11940         return tREGEXP_END;
11941     }
11942     if (space) {
11943         pushback(c);
11944         return ' ';
11945     }
11946     newtok();
11947     if ((func & STR_FUNC_EXPAND) && c == '#') {
11948         int t = parser_peek_variable_name(parser);
11949         if (t) return t;
11950         tokadd('#');
11951         c = nextc();
11952     }
11953     pushback(c);
11954     if (tokadd_string(func, term, paren, &quote->nd_nest,
11955                       &enc) == -1) {
11956         ruby_sourceline = nd_line(quote);
11957         if (func & STR_FUNC_REGEXP) {
11958             if (parser->eofp)
11959                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
11960             return tREGEXP_END;
11961         }
11962         else {
11963             if (parser->eofp)
11964                 compile_error(PARSER_ARG "unterminated string meets end of file");
11965             return tSTRING_END;
11966         }
11967     }
11968 
11969     tokfix();
11970     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
11971     flush_string_content(enc);
11972 
11973     return tSTRING_CONTENT;
11974 }
11975 
11976 static int
11977 parser_heredoc_identifier(struct parser_params *parser)
11978 {
11979     int c = nextc(), term, func = 0;
11980     long len;
11981 
11982     if (c == '-') {
11983         c = nextc();
11984         func = STR_FUNC_INDENT;
11985     }
11986     switch (c) {
11987       case '\'':
11988         func |= str_squote; goto quoted;
11989       case '"':
11990         func |= str_dquote; goto quoted;
11991       case '`':
11992         func |= str_xquote;
11993       quoted:
11994         newtok();
11995         tokadd(func);
11996         term = c;
11997         while ((c = nextc()) != -1 && c != term) {
11998             if (tokadd_mbchar(c) == -1) return 0;
11999         }
12000         if (c == -1) {
12001             compile_error(PARSER_ARG "unterminated here document identifier");
12002             return 0;
12003         }
12004         break;
12005 
12006       default:
12007         if (!parser_is_identchar()) {
12008             pushback(c);
12009             if (func & STR_FUNC_INDENT) {
12010                 pushback('-');
12011             }
12012             return 0;
12013         }
12014         newtok();
12015         term = '"';
12016         tokadd(func |= str_dquote);
12017         do {
12018             if (tokadd_mbchar(c) == -1) return 0;
12019         } while ((c = nextc()) != -1 && parser_is_identchar());
12020         pushback(c);
12021         break;
12022     }
12023 
12024     tokfix();
12025 #ifdef RIPPER
12026     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12027 #endif
12028     len = lex_p - lex_pbeg;
12029     lex_goto_eol(parser);
12030     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12031                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12032                                   len,                          /* nd_nth */
12033                                   lex_lastline);                /* nd_orig */
12034     nd_set_line(lex_strterm, ruby_sourceline);
12035     ripper_flush(parser);
12036     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12037 }
12038 
12039 static void
12040 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12041 {
12042     VALUE line;
12043 
12044     line = here->nd_orig;
12045     lex_lastline = line;
12046     lex_pbeg = RSTRING_PTR(line);
12047     lex_pend = lex_pbeg + RSTRING_LEN(line);
12048     lex_p = lex_pbeg + here->nd_nth;
12049     heredoc_end = ruby_sourceline;
12050     ruby_sourceline = nd_line(here);
12051     dispose_string(here->nd_lit);
12052     rb_gc_force_recycle((VALUE)here);
12053     ripper_flush(parser);
12054 }
12055 
12056 static int
12057 parser_whole_match_p(struct parser_params *parser,
12058     const char *eos, long len, int indent)
12059 {
12060     const char *p = lex_pbeg;
12061     long n;
12062 
12063     if (indent) {
12064         while (*p && ISSPACE(*p)) p++;
12065     }
12066     n = lex_pend - (p + len);
12067     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12068     return strncmp(eos, p, len) == 0;
12069 }
12070 
12071 #ifdef RIPPER
12072 static void
12073 ripper_dispatch_heredoc_end(struct parser_params *parser)
12074 {
12075     if (!NIL_P(parser->delayed))
12076         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12077     lex_goto_eol(parser);
12078     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12079 }
12080 
12081 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12082 #else
12083 #define dispatch_heredoc_end() ((void)0)
12084 #endif
12085 
12086 static int
12087 parser_here_document(struct parser_params *parser, NODE *here)
12088 {
12089     int c, func, indent = 0;
12090     const char *eos, *p, *pend;
12091     long len;
12092     VALUE str = 0;
12093     rb_encoding *enc = parser->enc;
12094 
12095     eos = RSTRING_PTR(here->nd_lit);
12096     len = RSTRING_LEN(here->nd_lit) - 1;
12097     indent = (func = *eos++) & STR_FUNC_INDENT;
12098 
12099     if ((c = nextc()) == -1) {
12100       error:
12101         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12102 #ifdef RIPPER
12103         if (NIL_P(parser->delayed)) {
12104             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12105         }
12106         else {
12107             if (str ||
12108                 ((len = lex_p - parser->tokp) > 0 &&
12109                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12110                 rb_str_append(parser->delayed, str);
12111             }
12112             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12113         }
12114         lex_goto_eol(parser);
12115 #endif
12116       restore:
12117         heredoc_restore(lex_strterm);
12118         lex_strterm = 0;
12119         return 0;
12120     }
12121     if (was_bol() && whole_match_p(eos, len, indent)) {
12122         dispatch_heredoc_end();
12123         heredoc_restore(lex_strterm);
12124         return tSTRING_END;
12125     }
12126 
12127     if (!(func & STR_FUNC_EXPAND)) {
12128         do {
12129             p = RSTRING_PTR(lex_lastline);
12130             pend = lex_pend;
12131             if (pend > p) {
12132                 switch (pend[-1]) {
12133                   case '\n':
12134                     if (--pend == p || pend[-1] != '\r') {
12135                         pend++;
12136                         break;
12137                     }
12138                   case '\r':
12139                     --pend;
12140                 }
12141             }
12142             if (str)
12143                 rb_str_cat(str, p, pend - p);
12144             else
12145                 str = STR_NEW(p, pend - p);
12146             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12147             lex_goto_eol(parser);
12148             if (nextc() == -1) {
12149                 if (str) dispose_string(str);
12150                 goto error;
12151             }
12152         } while (!whole_match_p(eos, len, indent));
12153     }
12154     else {
12155         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12156         newtok();
12157         if (c == '#') {
12158             int t = parser_peek_variable_name(parser);
12159             if (t) return t;
12160             tokadd('#');
12161             c = nextc();
12162         }
12163         do {
12164             pushback(c);
12165             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12166                 if (parser->eofp) goto error;
12167                 goto restore;
12168             }
12169             if (c != '\n') {
12170                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12171                 flush_string_content(enc);
12172                 return tSTRING_CONTENT;
12173             }
12174             tokadd(nextc());
12175             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12176             if ((c = nextc()) == -1) goto error;
12177         } while (!whole_match_p(eos, len, indent));
12178         str = STR_NEW3(tok(), toklen(), enc, func);
12179     }
12180     dispatch_heredoc_end();
12181     heredoc_restore(lex_strterm);
12182     lex_strterm = NEW_STRTERM(-1, 0, 0);
12183     set_yylval_str(str);
12184     return tSTRING_CONTENT;
12185 }
12186 
12187 #include "lex.c"
12188 
12189 static void
12190 arg_ambiguous_gen(struct parser_params *parser)
12191 {
12192 #ifndef RIPPER
12193     rb_warning0("ambiguous first argument; put parentheses or even spaces");
12194 #else
12195     dispatch0(arg_ambiguous);
12196 #endif
12197 }
12198 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12199 
12200 static ID
12201 formal_argument_gen(struct parser_params *parser, ID lhs)
12202 {
12203 #ifndef RIPPER
12204     if (!is_local_id(lhs))
12205         yyerror("formal argument must be local variable");
12206 #endif
12207     shadowing_lvar(lhs);
12208     return lhs;
12209 }
12210 
12211 static int
12212 lvar_defined_gen(struct parser_params *parser, ID id)
12213 {
12214     return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12215 }
12216 
12217 /* emacsen -*- hack */
12218 static long
12219 parser_encode_length(struct parser_params *parser, const char *name, long len)
12220 {
12221     long nlen;
12222 
12223     if (len > 5 && name[nlen = len - 5] == '-') {
12224         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12225             return nlen;
12226     }
12227     if (len > 4 && name[nlen = len - 4] == '-') {
12228         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12229             return nlen;
12230         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12231             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12232             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12233             return nlen;
12234     }
12235     return len;
12236 }
12237 
12238 static void
12239 parser_set_encode(struct parser_params *parser, const char *name)
12240 {
12241     int idx = rb_enc_find_index(name);
12242     rb_encoding *enc;
12243     VALUE excargs[3];
12244 
12245     if (idx < 0) {
12246         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12247       error:
12248         excargs[0] = rb_eArgError;
12249         excargs[2] = rb_make_backtrace();
12250         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12251         rb_exc_raise(rb_make_exception(3, excargs));
12252     }
12253     enc = rb_enc_from_index(idx);
12254     if (!rb_enc_asciicompat(enc)) {
12255         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12256         goto error;
12257     }
12258     parser->enc = enc;
12259 #ifndef RIPPER
12260     if (ruby_debug_lines) {
12261         long i, n = RARRAY_LEN(ruby_debug_lines);
12262         const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12263         for (i = 0; i < n; ++i) {
12264             rb_enc_associate_index(*p, idx);
12265         }
12266     }
12267 #endif
12268 }
12269 
12270 static int
12271 comment_at_top(struct parser_params *parser)
12272 {
12273     const char *p = lex_pbeg, *pend = lex_p - 1;
12274     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12275     while (p < pend) {
12276         if (!ISSPACE(*p)) return 0;
12277         p++;
12278     }
12279     return 1;
12280 }
12281 
12282 #ifndef RIPPER
12283 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12284 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12285 
12286 static void
12287 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12288 {
12289     if (!comment_at_top(parser)) {
12290         return;
12291     }
12292     parser_set_encode(parser, val);
12293 }
12294 
12295 static void
12296 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
12297 {
12298     int *p = &parser->parser_token_info_enabled;
12299 
12300     switch (*val) {
12301       case 't': case 'T':
12302         if (strcasecmp(val, "true") == 0) {
12303             *p = TRUE;
12304             return;
12305         }
12306         break;
12307       case 'f': case 'F':
12308         if (strcasecmp(val, "false") == 0) {
12309             *p = FALSE;
12310             return;
12311         }
12312         break;
12313     }
12314     rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
12315 }
12316 
12317 struct magic_comment {
12318     const char *name;
12319     rb_magic_comment_setter_t func;
12320     rb_magic_comment_length_t length;
12321 };
12322 
12323 static const struct magic_comment magic_comments[] = {
12324     {"coding", magic_comment_encoding, parser_encode_length},
12325     {"encoding", magic_comment_encoding, parser_encode_length},
12326     {"warn_indent", parser_set_token_info},
12327 };
12328 #endif
12329 
12330 static const char *
12331 magic_comment_marker(const char *str, long len)
12332 {
12333     long i = 2;
12334 
12335     while (i < len) {
12336         switch (str[i]) {
12337           case '-':
12338             if (str[i-1] == '*' && str[i-2] == '-') {
12339                 return str + i + 1;
12340             }
12341             i += 2;
12342             break;
12343           case '*':
12344             if (i + 1 >= len) return 0;
12345             if (str[i+1] != '-') {
12346                 i += 4;
12347             }
12348             else if (str[i-1] != '-') {
12349                 i += 2;
12350             }
12351             else {
12352                 return str + i + 2;
12353             }
12354             break;
12355           default:
12356             i += 3;
12357             break;
12358         }
12359     }
12360     return 0;
12361 }
12362 
12363 static int
12364 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12365 {
12366     VALUE name = 0, val = 0;
12367     const char *beg, *end, *vbeg, *vend;
12368 #define str_copy(_s, _p, _n) ((_s) \
12369         ? (void)(rb_str_resize((_s), (_n)), \
12370            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12371         : (void)((_s) = STR_NEW((_p), (_n))))
12372 
12373     if (len <= 7) return FALSE;
12374     if (!(beg = magic_comment_marker(str, len))) return FALSE;
12375     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12376     str = beg;
12377     len = end - beg - 3;
12378 
12379     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12380     while (len > 0) {
12381 #ifndef RIPPER
12382         const struct magic_comment *p = magic_comments;
12383 #endif
12384         char *s;
12385         int i;
12386         long n = 0;
12387 
12388         for (; len > 0 && *str; str++, --len) {
12389             switch (*str) {
12390               case '\'': case '"': case ':': case ';':
12391                 continue;
12392             }
12393             if (!ISSPACE(*str)) break;
12394         }
12395         for (beg = str; len > 0; str++, --len) {
12396             switch (*str) {
12397               case '\'': case '"': case ':': case ';':
12398                 break;
12399               default:
12400                 if (ISSPACE(*str)) break;
12401                 continue;
12402             }
12403             break;
12404         }
12405         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12406         if (!len) break;
12407         if (*str != ':') continue;
12408 
12409         do str++; while (--len > 0 && ISSPACE(*str));
12410         if (!len) break;
12411         if (*str == '"') {
12412             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12413                 if (*str == '\\') {
12414                     --len;
12415                     ++str;
12416                 }
12417             }
12418             vend = str;
12419             if (len) {
12420                 --len;
12421                 ++str;
12422             }
12423         }
12424         else {
12425             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12426             vend = str;
12427         }
12428         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12429 
12430         n = end - beg;
12431         str_copy(name, beg, n);
12432         s = RSTRING_PTR(name);
12433         for (i = 0; i < n; ++i) {
12434             if (s[i] == '-') s[i] = '_';
12435         }
12436 #ifndef RIPPER
12437         do {
12438             if (STRNCASECMP(p->name, s, n) == 0) {
12439                 n = vend - vbeg;
12440                 if (p->length) {
12441                     n = (*p->length)(parser, vbeg, n);
12442                 }
12443                 str_copy(val, vbeg, n);
12444                 (*p->func)(parser, s, RSTRING_PTR(val));
12445                 break;
12446             }
12447         } while (++p < magic_comments + numberof(magic_comments));
12448 #else
12449         str_copy(val, vbeg, vend - vbeg);
12450         dispatch2(magic_comment, name, val);
12451 #endif
12452     }
12453 
12454     return TRUE;
12455 }
12456 
12457 static void
12458 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12459 {
12460     int sep = 0;
12461     const char *beg = str;
12462     VALUE s;
12463 
12464     for (;;) {
12465         if (send - str <= 6) return;
12466         switch (str[6]) {
12467           case 'C': case 'c': str += 6; continue;
12468           case 'O': case 'o': str += 5; continue;
12469           case 'D': case 'd': str += 4; continue;
12470           case 'I': case 'i': str += 3; continue;
12471           case 'N': case 'n': str += 2; continue;
12472           case 'G': case 'g': str += 1; continue;
12473           case '=': case ':':
12474             sep = 1;
12475             str += 6;
12476             break;
12477           default:
12478             str += 6;
12479             if (ISSPACE(*str)) break;
12480             continue;
12481         }
12482         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12483     }
12484     for (;;) {
12485         do {
12486             if (++str >= send) return;
12487         } while (ISSPACE(*str));
12488         if (sep) break;
12489         if (*str != '=' && *str != ':') return;
12490         sep = 1;
12491         str++;
12492     }
12493     beg = str;
12494     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12495     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12496     parser_set_encode(parser, RSTRING_PTR(s));
12497     rb_str_resize(s, 0);
12498 }
12499 
12500 static void
12501 parser_prepare(struct parser_params *parser)
12502 {
12503     int c = nextc();
12504     switch (c) {
12505       case '#':
12506         if (peek('!')) parser->has_shebang = 1;
12507         break;
12508       case 0xef:                /* UTF-8 BOM marker */
12509         if (lex_pend - lex_p >= 2 &&
12510             (unsigned char)lex_p[0] == 0xbb &&
12511             (unsigned char)lex_p[1] == 0xbf) {
12512             parser->enc = rb_utf8_encoding();
12513             lex_p += 2;
12514             lex_pbeg = lex_p;
12515             return;
12516         }
12517         break;
12518       case EOF:
12519         return;
12520     }
12521     pushback(c);
12522     parser->enc = rb_enc_get(lex_lastline);
12523 }
12524 
12525 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
12526 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
12527 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
12528 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12529 #define IS_LABEL_POSSIBLE() ((lex_state == EXPR_BEG && !cmd_state) || IS_ARG())
12530 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
12531 
12532 #ifndef RIPPER
12533 #define ambiguous_operator(op, syn) ( \
12534     rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12535     rb_warning0("even though it seems like "syn""))
12536 #else
12537 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12538 #endif
12539 #define warn_balanced(op, syn) ((void) \
12540     (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
12541      last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
12542      last_state != EXPR_ENDARG && \
12543      space_seen && !ISSPACE(c) && \
12544      (ambiguous_operator(op, syn), 0)))
12545 
12546 static int
12547 parser_yylex(struct parser_params *parser)
12548 {
12549     register int c;
12550     int space_seen = 0;
12551     int cmd_state;
12552     enum lex_state_e last_state;
12553     rb_encoding *enc;
12554     int mb;
12555 #ifdef RIPPER
12556     int fallthru = FALSE;
12557 #endif
12558 
12559     if (lex_strterm) {
12560         int token;
12561         if (nd_type(lex_strterm) == NODE_HEREDOC) {
12562             token = here_document(lex_strterm);
12563             if (token == tSTRING_END) {
12564                 lex_strterm = 0;
12565                 lex_state = EXPR_END;
12566             }
12567         }
12568         else {
12569             token = parse_string(lex_strterm);
12570             if (token == tSTRING_END || token == tREGEXP_END) {
12571                 rb_gc_force_recycle((VALUE)lex_strterm);
12572                 lex_strterm = 0;
12573                 lex_state = EXPR_END;
12574             }
12575         }
12576         return token;
12577     }
12578     cmd_state = command_start;
12579     command_start = FALSE;
12580   retry:
12581     last_state = lex_state;
12582     switch (c = nextc()) {
12583       case '\0':                /* NUL */
12584       case '\004':              /* ^D */
12585       case '\032':              /* ^Z */
12586       case -1:                  /* end of script. */
12587         return 0;
12588 
12589         /* white spaces */
12590       case ' ': case '\t': case '\f': case '\r':
12591       case '\13': /* '\v' */
12592         space_seen = 1;
12593 #ifdef RIPPER
12594         while ((c = nextc())) {
12595             switch (c) {
12596               case ' ': case '\t': case '\f': case '\r':
12597               case '\13': /* '\v' */
12598                 break;
12599               default:
12600                 goto outofloop;
12601             }
12602         }
12603       outofloop:
12604         pushback(c);
12605         ripper_dispatch_scan_event(parser, tSP);
12606 #endif
12607         goto retry;
12608 
12609       case '#':         /* it's a comment */
12610         /* no magic_comment in shebang line */
12611         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
12612             if (comment_at_top(parser)) {
12613                 set_file_encoding(parser, lex_p, lex_pend);
12614             }
12615         }
12616         lex_p = lex_pend;
12617 #ifdef RIPPER
12618         ripper_dispatch_scan_event(parser, tCOMMENT);
12619         fallthru = TRUE;
12620 #endif
12621         /* fall through */
12622       case '\n':
12623         switch (lex_state) {
12624           case EXPR_BEG:
12625           case EXPR_FNAME:
12626           case EXPR_DOT:
12627           case EXPR_CLASS:
12628           case EXPR_VALUE:
12629 #ifdef RIPPER
12630             if (!fallthru) {
12631                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
12632             }
12633             fallthru = FALSE;
12634 #endif
12635             goto retry;
12636           default:
12637             break;
12638         }
12639         while ((c = nextc())) {
12640             switch (c) {
12641               case ' ': case '\t': case '\f': case '\r':
12642               case '\13': /* '\v' */
12643                 space_seen = 1;
12644                 break;
12645               case '.': {
12646                   if ((c = nextc()) != '.') {
12647                       pushback(c);
12648                       pushback('.');
12649                       goto retry;
12650                   }
12651               }
12652               default:
12653                 --ruby_sourceline;
12654                 lex_nextline = lex_lastline;
12655               case -1:          /* EOF no decrement*/
12656                 lex_goto_eol(parser);
12657 #ifdef RIPPER
12658                 if (c != -1) {
12659                     parser->tokp = lex_p;
12660                 }
12661 #endif
12662                 goto normal_newline;
12663             }
12664         }
12665       normal_newline:
12666         command_start = TRUE;
12667         lex_state = EXPR_BEG;
12668         return '\n';
12669 
12670       case '*':
12671         if ((c = nextc()) == '*') {
12672             if ((c = nextc()) == '=') {
12673                 set_yylval_id(tPOW);
12674                 lex_state = EXPR_BEG;
12675                 return tOP_ASGN;
12676             }
12677             pushback(c);
12678             c = tPOW;
12679         }
12680         else {
12681             if (c == '=') {
12682                 set_yylval_id('*');
12683                 lex_state = EXPR_BEG;
12684                 return tOP_ASGN;
12685             }
12686             pushback(c);
12687             if (IS_SPCARG(c)) {
12688                 rb_warning0("`*' interpreted as argument prefix");
12689                 c = tSTAR;
12690             }
12691             else if (IS_BEG()) {
12692                 c = tSTAR;
12693             }
12694             else {
12695                 warn_balanced("*", "argument prefix");
12696                 c = '*';
12697             }
12698         }
12699         switch (lex_state) {
12700           case EXPR_FNAME: case EXPR_DOT:
12701             lex_state = EXPR_ARG; break;
12702           default:
12703             lex_state = EXPR_BEG; break;
12704         }
12705         return c;
12706 
12707       case '!':
12708         c = nextc();
12709         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
12710             lex_state = EXPR_ARG;
12711             if (c == '@') {
12712                 return '!';
12713             }
12714         }
12715         else {
12716             lex_state = EXPR_BEG;
12717         }
12718         if (c == '=') {
12719             return tNEQ;
12720         }
12721         if (c == '~') {
12722             return tNMATCH;
12723         }
12724         pushback(c);
12725         return '!';
12726 
12727       case '=':
12728         if (was_bol()) {
12729             /* skip embedded rd document */
12730             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
12731 #ifdef RIPPER
12732                 int first_p = TRUE;
12733 
12734                 lex_goto_eol(parser);
12735                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
12736 #endif
12737                 for (;;) {
12738                     lex_goto_eol(parser);
12739 #ifdef RIPPER
12740                     if (!first_p) {
12741                         ripper_dispatch_scan_event(parser, tEMBDOC);
12742                     }
12743                     first_p = FALSE;
12744 #endif
12745                     c = nextc();
12746                     if (c == -1) {
12747                         compile_error(PARSER_ARG "embedded document meets end of file");
12748                         return 0;
12749                     }
12750                     if (c != '=') continue;
12751                     if (strncmp(lex_p, "end", 3) == 0 &&
12752                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
12753                         break;
12754                     }
12755                 }
12756                 lex_goto_eol(parser);
12757 #ifdef RIPPER
12758                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
12759 #endif
12760                 goto retry;
12761             }
12762         }
12763 
12764         switch (lex_state) {
12765           case EXPR_FNAME: case EXPR_DOT:
12766             lex_state = EXPR_ARG; break;
12767           default:
12768             lex_state = EXPR_BEG; break;
12769         }
12770         if ((c = nextc()) == '=') {
12771             if ((c = nextc()) == '=') {
12772                 return tEQQ;
12773             }
12774             pushback(c);
12775             return tEQ;
12776         }
12777         if (c == '~') {
12778             return tMATCH;
12779         }
12780         else if (c == '>') {
12781             return tASSOC;
12782         }
12783         pushback(c);
12784         return '=';
12785 
12786       case '<':
12787         last_state = lex_state;
12788         c = nextc();
12789         if (c == '<' &&
12790             lex_state != EXPR_DOT &&
12791             lex_state != EXPR_CLASS &&
12792             !IS_END() &&
12793             (!IS_ARG() || space_seen)) {
12794             int token = heredoc_identifier();
12795             if (token) return token;
12796         }
12797         switch (lex_state) {
12798           case EXPR_FNAME: case EXPR_DOT:
12799             lex_state = EXPR_ARG; break;
12800           default:
12801             lex_state = EXPR_BEG; break;
12802         }
12803         if (c == '=') {
12804             if ((c = nextc()) == '>') {
12805                 return tCMP;
12806             }
12807             pushback(c);
12808             return tLEQ;
12809         }
12810         if (c == '<') {
12811             if ((c = nextc()) == '=') {
12812                 set_yylval_id(tLSHFT);
12813                 lex_state = EXPR_BEG;
12814                 return tOP_ASGN;
12815             }
12816             pushback(c);
12817             warn_balanced("<<", "here document");
12818             return tLSHFT;
12819         }
12820         pushback(c);
12821         return '<';
12822 
12823       case '>':
12824         switch (lex_state) {
12825           case EXPR_FNAME: case EXPR_DOT:
12826             lex_state = EXPR_ARG; break;
12827           default:
12828             lex_state = EXPR_BEG; break;
12829         }
12830         if ((c = nextc()) == '=') {
12831             return tGEQ;
12832         }
12833         if (c == '>') {
12834             if ((c = nextc()) == '=') {
12835                 set_yylval_id(tRSHFT);
12836                 lex_state = EXPR_BEG;
12837                 return tOP_ASGN;
12838             }
12839             pushback(c);
12840             return tRSHFT;
12841         }
12842         pushback(c);
12843         return '>';
12844 
12845       case '"':
12846         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
12847         return tSTRING_BEG;
12848 
12849       case '`':
12850         if (lex_state == EXPR_FNAME) {
12851             lex_state = EXPR_ENDFN;
12852             return c;
12853         }
12854         if (lex_state == EXPR_DOT) {
12855             if (cmd_state)
12856                 lex_state = EXPR_CMDARG;
12857             else
12858                 lex_state = EXPR_ARG;
12859             return c;
12860         }
12861         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
12862         return tXSTRING_BEG;
12863 
12864       case '\'':
12865         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
12866         return tSTRING_BEG;
12867 
12868       case '?':
12869         if (IS_END()) {
12870             lex_state = EXPR_VALUE;
12871             return '?';
12872         }
12873         c = nextc();
12874         if (c == -1) {
12875             compile_error(PARSER_ARG "incomplete character syntax");
12876             return 0;
12877         }
12878         if (rb_enc_isspace(c, parser->enc)) {
12879             if (!IS_ARG()) {
12880                 int c2 = 0;
12881                 switch (c) {
12882                   case ' ':
12883                     c2 = 's';
12884                     break;
12885                   case '\n':
12886                     c2 = 'n';
12887                     break;
12888                   case '\t':
12889                     c2 = 't';
12890                     break;
12891                   case '\v':
12892                     c2 = 'v';
12893                     break;
12894                   case '\r':
12895                     c2 = 'r';
12896                     break;
12897                   case '\f':
12898                     c2 = 'f';
12899                     break;
12900                 }
12901                 if (c2) {
12902                     rb_warnI("invalid character syntax; use ?\\%c", c2);
12903                 }
12904             }
12905           ternary:
12906             pushback(c);
12907             lex_state = EXPR_VALUE;
12908             return '?';
12909         }
12910         newtok();
12911         enc = parser->enc;
12912         if (!parser_isascii()) {
12913             if (tokadd_mbchar(c) == -1) return 0;
12914         }
12915         else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
12916                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
12917             goto ternary;
12918         }
12919         else if (c == '\\') {
12920             if (peek('u')) {
12921                 nextc();
12922                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
12923                 if (0x80 <= c) {
12924                     tokaddmbc(c, enc);
12925                 }
12926                 else {
12927                     tokadd(c);
12928                 }
12929             }
12930             else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
12931                 nextc();
12932                 if (tokadd_mbchar(c) == -1) return 0;
12933             }
12934             else {
12935                 c = read_escape(0, &enc);
12936                 tokadd(c);
12937             }
12938         }
12939         else {
12940             tokadd(c);
12941         }
12942         tokfix();
12943         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
12944         lex_state = EXPR_END;
12945         return tCHAR;
12946 
12947       case '&':
12948         if ((c = nextc()) == '&') {
12949             lex_state = EXPR_BEG;
12950             if ((c = nextc()) == '=') {
12951                 set_yylval_id(tANDOP);
12952                 lex_state = EXPR_BEG;
12953                 return tOP_ASGN;
12954             }
12955             pushback(c);
12956             return tANDOP;
12957         }
12958         else if (c == '=') {
12959             set_yylval_id('&');
12960             lex_state = EXPR_BEG;
12961             return tOP_ASGN;
12962         }
12963         pushback(c);
12964         if (IS_SPCARG(c)) {
12965             rb_warning0("`&' interpreted as argument prefix");
12966             c = tAMPER;
12967         }
12968         else if (IS_BEG()) {
12969             c = tAMPER;
12970         }
12971         else {
12972             warn_balanced("&", "argument prefix");
12973             c = '&';
12974         }
12975         switch (lex_state) {
12976           case EXPR_FNAME: case EXPR_DOT:
12977             lex_state = EXPR_ARG; break;
12978           default:
12979             lex_state = EXPR_BEG;
12980         }
12981         return c;
12982 
12983       case '|':
12984         if ((c = nextc()) == '|') {
12985             lex_state = EXPR_BEG;
12986             if ((c = nextc()) == '=') {
12987                 set_yylval_id(tOROP);
12988                 lex_state = EXPR_BEG;
12989                 return tOP_ASGN;
12990             }
12991             pushback(c);
12992             return tOROP;
12993         }
12994         if (c == '=') {
12995             set_yylval_id('|');
12996             lex_state = EXPR_BEG;
12997             return tOP_ASGN;
12998         }
12999         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13000             lex_state = EXPR_ARG;
13001         }
13002         else {
13003             lex_state = EXPR_BEG;
13004         }
13005         pushback(c);
13006         return '|';
13007 
13008       case '+':
13009         c = nextc();
13010         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13011             lex_state = EXPR_ARG;
13012             if (c == '@') {
13013                 return tUPLUS;
13014             }
13015             pushback(c);
13016             return '+';
13017         }
13018         if (c == '=') {
13019             set_yylval_id('+');
13020             lex_state = EXPR_BEG;
13021             return tOP_ASGN;
13022         }
13023         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13024             lex_state = EXPR_BEG;
13025             pushback(c);
13026             if (c != -1 && ISDIGIT(c)) {
13027                 c = '+';
13028                 goto start_num;
13029             }
13030             return tUPLUS;
13031         }
13032         lex_state = EXPR_BEG;
13033         pushback(c);
13034         warn_balanced("+", "unary operator");
13035         return '+';
13036 
13037       case '-':
13038         c = nextc();
13039         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13040             lex_state = EXPR_ARG;
13041             if (c == '@') {
13042                 return tUMINUS;
13043             }
13044             pushback(c);
13045             return '-';
13046         }
13047         if (c == '=') {
13048             set_yylval_id('-');
13049             lex_state = EXPR_BEG;
13050             return tOP_ASGN;
13051         }
13052         if (c == '>') {
13053             lex_state = EXPR_ARG;
13054             return tLAMBDA;
13055         }
13056         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13057             lex_state = EXPR_BEG;
13058             pushback(c);
13059             if (c != -1 && ISDIGIT(c)) {
13060                 return tUMINUS_NUM;
13061             }
13062             return tUMINUS;
13063         }
13064         lex_state = EXPR_BEG;
13065         pushback(c);
13066         warn_balanced("-", "unary operator");
13067         return '-';
13068 
13069       case '.':
13070         lex_state = EXPR_BEG;
13071         if ((c = nextc()) == '.') {
13072             if ((c = nextc()) == '.') {
13073                 return tDOT3;
13074             }
13075             pushback(c);
13076             return tDOT2;
13077         }
13078         pushback(c);
13079         if (c != -1 && ISDIGIT(c)) {
13080             yyerror("no .<digit> floating literal anymore; put 0 before dot");
13081         }
13082         lex_state = EXPR_DOT;
13083         return '.';
13084 
13085       start_num:
13086       case '0': case '1': case '2': case '3': case '4':
13087       case '5': case '6': case '7': case '8': case '9':
13088         {
13089             int is_float, seen_point, seen_e, nondigit;
13090 
13091             is_float = seen_point = seen_e = nondigit = 0;
13092             lex_state = EXPR_END;
13093             newtok();
13094             if (c == '-' || c == '+') {
13095                 tokadd(c);
13096                 c = nextc();
13097             }
13098             if (c == '0') {
13099 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13100                 int start = toklen();
13101                 c = nextc();
13102                 if (c == 'x' || c == 'X') {
13103                     /* hexadecimal */
13104                     c = nextc();
13105                     if (c != -1 && ISXDIGIT(c)) {
13106                         do {
13107                             if (c == '_') {
13108                                 if (nondigit) break;
13109                                 nondigit = c;
13110                                 continue;
13111                             }
13112                             if (!ISXDIGIT(c)) break;
13113                             nondigit = 0;
13114                             tokadd(c);
13115                         } while ((c = nextc()) != -1);
13116                     }
13117                     pushback(c);
13118                     tokfix();
13119                     if (toklen() == start) {
13120                         no_digits();
13121                     }
13122                     else if (nondigit) goto trailing_uc;
13123                     set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
13124                     return tINTEGER;
13125                 }
13126                 if (c == 'b' || c == 'B') {
13127                     /* binary */
13128                     c = nextc();
13129                     if (c == '0' || c == '1') {
13130                         do {
13131                             if (c == '_') {
13132                                 if (nondigit) break;
13133                                 nondigit = c;
13134                                 continue;
13135                             }
13136                             if (c != '0' && c != '1') break;
13137                             nondigit = 0;
13138                             tokadd(c);
13139                         } while ((c = nextc()) != -1);
13140                     }
13141                     pushback(c);
13142                     tokfix();
13143                     if (toklen() == start) {
13144                         no_digits();
13145                     }
13146                     else if (nondigit) goto trailing_uc;
13147                     set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
13148                     return tINTEGER;
13149                 }
13150                 if (c == 'd' || c == 'D') {
13151                     /* decimal */
13152                     c = nextc();
13153                     if (c != -1 && ISDIGIT(c)) {
13154                         do {
13155                             if (c == '_') {
13156                                 if (nondigit) break;
13157                                 nondigit = c;
13158                                 continue;
13159                             }
13160                             if (!ISDIGIT(c)) break;
13161                             nondigit = 0;
13162                             tokadd(c);
13163                         } while ((c = nextc()) != -1);
13164                     }
13165                     pushback(c);
13166                     tokfix();
13167                     if (toklen() == start) {
13168                         no_digits();
13169                     }
13170                     else if (nondigit) goto trailing_uc;
13171                     set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13172                     return tINTEGER;
13173                 }
13174                 if (c == '_') {
13175                     /* 0_0 */
13176                     goto octal_number;
13177                 }
13178                 if (c == 'o' || c == 'O') {
13179                     /* prefixed octal */
13180                     c = nextc();
13181                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
13182                         no_digits();
13183                     }
13184                 }
13185                 if (c >= '0' && c <= '7') {
13186                     /* octal */
13187                   octal_number:
13188                     do {
13189                         if (c == '_') {
13190                             if (nondigit) break;
13191                             nondigit = c;
13192                             continue;
13193                         }
13194                         if (c < '0' || c > '9') break;
13195                         if (c > '7') goto invalid_octal;
13196                         nondigit = 0;
13197                         tokadd(c);
13198                     } while ((c = nextc()) != -1);
13199                     if (toklen() > start) {
13200                         pushback(c);
13201                         tokfix();
13202                         if (nondigit) goto trailing_uc;
13203                         set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
13204                         return tINTEGER;
13205                     }
13206                     if (nondigit) {
13207                         pushback(c);
13208                         goto trailing_uc;
13209                     }
13210                 }
13211                 if (c > '7' && c <= '9') {
13212                   invalid_octal:
13213                     yyerror("Invalid octal digit");
13214                 }
13215                 else if (c == '.' || c == 'e' || c == 'E') {
13216                     tokadd('0');
13217                 }
13218                 else {
13219                     pushback(c);
13220                     set_yylval_literal(INT2FIX(0));
13221                     return tINTEGER;
13222                 }
13223             }
13224 
13225             for (;;) {
13226                 switch (c) {
13227                   case '0': case '1': case '2': case '3': case '4':
13228                   case '5': case '6': case '7': case '8': case '9':
13229                     nondigit = 0;
13230                     tokadd(c);
13231                     break;
13232 
13233                   case '.':
13234                     if (nondigit) goto trailing_uc;
13235                     if (seen_point || seen_e) {
13236                         goto decode_num;
13237                     }
13238                     else {
13239                         int c0 = nextc();
13240                         if (c0 == -1 || !ISDIGIT(c0)) {
13241                             pushback(c0);
13242                             goto decode_num;
13243                         }
13244                         c = c0;
13245                     }
13246                     tokadd('.');
13247                     tokadd(c);
13248                     is_float++;
13249                     seen_point++;
13250                     nondigit = 0;
13251                     break;
13252 
13253                   case 'e':
13254                   case 'E':
13255                     if (nondigit) {
13256                         pushback(c);
13257                         c = nondigit;
13258                         goto decode_num;
13259                     }
13260                     if (seen_e) {
13261                         goto decode_num;
13262                     }
13263                     tokadd(c);
13264                     seen_e++;
13265                     is_float++;
13266                     nondigit = c;
13267                     c = nextc();
13268                     if (c != '-' && c != '+') continue;
13269                     tokadd(c);
13270                     nondigit = c;
13271                     break;
13272 
13273                   case '_':     /* `_' in number just ignored */
13274                     if (nondigit) goto decode_num;
13275                     nondigit = c;
13276                     break;
13277 
13278                   default:
13279                     goto decode_num;
13280                 }
13281                 c = nextc();
13282             }
13283 
13284           decode_num:
13285             pushback(c);
13286             if (nondigit) {
13287                 char tmp[30];
13288               trailing_uc:
13289                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13290                 yyerror(tmp);
13291             }
13292             tokfix();
13293             if (is_float) {
13294                 double d = strtod(tok(), 0);
13295                 if (errno == ERANGE) {
13296                     rb_warningS("Float %s out of range", tok());
13297                     errno = 0;
13298                 }
13299                 set_yylval_literal(DBL2NUM(d));
13300                 return tFLOAT;
13301             }
13302             set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13303             return tINTEGER;
13304         }
13305 
13306       case ')':
13307       case ']':
13308         paren_nest--;
13309       case '}':
13310         COND_LEXPOP();
13311         CMDARG_LEXPOP();
13312         if (c == ')')
13313             lex_state = EXPR_ENDFN;
13314         else
13315             lex_state = EXPR_ENDARG;
13316         return c;
13317 
13318       case ':':
13319         c = nextc();
13320         if (c == ':') {
13321             if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
13322                 lex_state = EXPR_BEG;
13323                 return tCOLON3;
13324             }
13325             lex_state = EXPR_DOT;
13326             return tCOLON2;
13327         }
13328         if (IS_END() || ISSPACE(c)) {
13329             pushback(c);
13330             warn_balanced(":", "symbol literal");
13331             lex_state = EXPR_BEG;
13332             return ':';
13333         }
13334         switch (c) {
13335           case '\'':
13336             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13337             break;
13338           case '"':
13339             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13340             break;
13341           default:
13342             pushback(c);
13343             break;
13344         }
13345         lex_state = EXPR_FNAME;
13346         return tSYMBEG;
13347 
13348       case '/':
13349         if (IS_BEG()) {
13350             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13351             return tREGEXP_BEG;
13352         }
13353         if ((c = nextc()) == '=') {
13354             set_yylval_id('/');
13355             lex_state = EXPR_BEG;
13356             return tOP_ASGN;
13357         }
13358         pushback(c);
13359         if (IS_SPCARG(c)) {
13360             (void)arg_ambiguous();
13361             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13362             return tREGEXP_BEG;
13363         }
13364         switch (lex_state) {
13365           case EXPR_FNAME: case EXPR_DOT:
13366             lex_state = EXPR_ARG; break;
13367           default:
13368             lex_state = EXPR_BEG; break;
13369         }
13370         warn_balanced("/", "regexp literal");
13371         return '/';
13372 
13373       case '^':
13374         if ((c = nextc()) == '=') {
13375             set_yylval_id('^');
13376             lex_state = EXPR_BEG;
13377             return tOP_ASGN;
13378         }
13379         switch (lex_state) {
13380           case EXPR_FNAME: case EXPR_DOT:
13381             lex_state = EXPR_ARG; break;
13382           default:
13383             lex_state = EXPR_BEG; break;
13384         }
13385         pushback(c);
13386         return '^';
13387 
13388       case ';':
13389         lex_state = EXPR_BEG;
13390         command_start = TRUE;
13391         return ';';
13392 
13393       case ',':
13394         lex_state = EXPR_BEG;
13395         return ',';
13396 
13397       case '~':
13398         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13399             if ((c = nextc()) != '@') {
13400                 pushback(c);
13401             }
13402             lex_state = EXPR_ARG;
13403         }
13404         else {
13405             lex_state = EXPR_BEG;
13406         }
13407         return '~';
13408 
13409       case '(':
13410         if (IS_BEG()) {
13411             c = tLPAREN;
13412         }
13413         else if (IS_SPCARG(-1)) {
13414             c = tLPAREN_ARG;
13415         }
13416         paren_nest++;
13417         COND_PUSH(0);
13418         CMDARG_PUSH(0);
13419         lex_state = EXPR_BEG;
13420         return c;
13421 
13422       case '[':
13423         paren_nest++;
13424         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13425             lex_state = EXPR_ARG;
13426             if ((c = nextc()) == ']') {
13427                 if ((c = nextc()) == '=') {
13428                     return tASET;
13429                 }
13430                 pushback(c);
13431                 return tAREF;
13432             }
13433             pushback(c);
13434             return '[';
13435         }
13436         else if (IS_BEG()) {
13437             c = tLBRACK;
13438         }
13439         else if (IS_ARG() && space_seen) {
13440             c = tLBRACK;
13441         }
13442         lex_state = EXPR_BEG;
13443         COND_PUSH(0);
13444         CMDARG_PUSH(0);
13445         return c;
13446 
13447       case '{':
13448         if (lpar_beg && lpar_beg == paren_nest) {
13449             lex_state = EXPR_BEG;
13450             lpar_beg = 0;
13451             --paren_nest;
13452             COND_PUSH(0);
13453             CMDARG_PUSH(0);
13454             return tLAMBEG;
13455         }
13456         if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
13457             c = '{';          /* block (primary) */
13458         else if (lex_state == EXPR_ENDARG)
13459             c = tLBRACE_ARG;  /* block (expr) */
13460         else
13461             c = tLBRACE;      /* hash */
13462         COND_PUSH(0);
13463         CMDARG_PUSH(0);
13464         lex_state = EXPR_BEG;
13465         if (c != tLBRACE) command_start = TRUE;
13466         return c;
13467 
13468       case '\\':
13469         c = nextc();
13470         if (c == '\n') {
13471             space_seen = 1;
13472 #ifdef RIPPER
13473             ripper_dispatch_scan_event(parser, tSP);
13474 #endif
13475             goto retry; /* skip \\n */
13476         }
13477         pushback(c);
13478         return '\\';
13479 
13480       case '%':
13481         if (IS_BEG()) {
13482             int term;
13483             int paren;
13484 
13485             c = nextc();
13486           quotation:
13487             if (c == -1 || !ISALNUM(c)) {
13488                 term = c;
13489                 c = 'Q';
13490             }
13491             else {
13492                 term = nextc();
13493                 if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
13494                     yyerror("unknown type of %string");
13495                     return 0;
13496                 }
13497             }
13498             if (c == -1 || term == -1) {
13499                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13500                 return 0;
13501             }
13502             paren = term;
13503             if (term == '(') term = ')';
13504             else if (term == '[') term = ']';
13505             else if (term == '{') term = '}';
13506             else if (term == '<') term = '>';
13507             else paren = 0;
13508 
13509             switch (c) {
13510               case 'Q':
13511                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13512                 return tSTRING_BEG;
13513 
13514               case 'q':
13515                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
13516                 return tSTRING_BEG;
13517 
13518               case 'W':
13519                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
13520                 do {c = nextc();} while (ISSPACE(c));
13521                 pushback(c);
13522                 return tWORDS_BEG;
13523 
13524               case 'w':
13525                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
13526                 do {c = nextc();} while (ISSPACE(c));
13527                 pushback(c);
13528                 return tQWORDS_BEG;
13529 
13530               case 'x':
13531                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13532                 return tXSTRING_BEG;
13533 
13534               case 'r':
13535                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13536                 return tREGEXP_BEG;
13537 
13538               case 's':
13539                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13540                 lex_state = EXPR_FNAME;
13541                 return tSYMBEG;
13542 
13543               default:
13544                 yyerror("unknown type of %string");
13545                 return 0;
13546             }
13547         }
13548         if ((c = nextc()) == '=') {
13549             set_yylval_id('%');
13550             lex_state = EXPR_BEG;
13551             return tOP_ASGN;
13552         }
13553         if (IS_SPCARG(c)) {
13554             goto quotation;
13555         }
13556         switch (lex_state) {
13557           case EXPR_FNAME: case EXPR_DOT:
13558             lex_state = EXPR_ARG; break;
13559           default:
13560             lex_state = EXPR_BEG; break;
13561         }
13562         pushback(c);
13563         warn_balanced("%%", "string literal");
13564         return '%';
13565 
13566       case '$':
13567         lex_state = EXPR_END;
13568         newtok();
13569         c = nextc();
13570         switch (c) {
13571           case '_':             /* $_: last read line string */
13572             c = nextc();
13573             if (parser_is_identchar()) {
13574                 tokadd('$');
13575                 tokadd('_');
13576                 break;
13577             }
13578             pushback(c);
13579             c = '_';
13580             /* fall through */
13581           case '~':             /* $~: match-data */
13582           case '*':             /* $*: argv */
13583           case '$':             /* $$: pid */
13584           case '?':             /* $?: last status */
13585           case '!':             /* $!: error string */
13586           case '@':             /* $@: error position */
13587           case '/':             /* $/: input record separator */
13588           case '\\':            /* $\: output record separator */
13589           case ';':             /* $;: field separator */
13590           case ',':             /* $,: output field separator */
13591           case '.':             /* $.: last read line number */
13592           case '=':             /* $=: ignorecase */
13593           case ':':             /* $:: load path */
13594           case '<':             /* $<: reading filename */
13595           case '>':             /* $>: default output handle */
13596           case '\"':            /* $": already loaded files */
13597             tokadd('$');
13598             tokadd(c);
13599             tokfix();
13600             set_yylval_name(rb_intern(tok()));
13601             return tGVAR;
13602 
13603           case '-':
13604             tokadd('$');
13605             tokadd(c);
13606             c = nextc();
13607             if (parser_is_identchar()) {
13608                 if (tokadd_mbchar(c) == -1) return 0;
13609             }
13610             else {
13611                 pushback(c);
13612             }
13613           gvar:
13614             tokfix();
13615             set_yylval_name(rb_intern(tok()));
13616             return tGVAR;
13617 
13618           case '&':             /* $&: last match */
13619           case '`':             /* $`: string before last match */
13620           case '\'':            /* $': string after last match */
13621           case '+':             /* $+: string matches last paren. */
13622             if (last_state == EXPR_FNAME) {
13623                 tokadd('$');
13624                 tokadd(c);
13625                 goto gvar;
13626             }
13627             set_yylval_node(NEW_BACK_REF(c));
13628             return tBACK_REF;
13629 
13630           case '1': case '2': case '3':
13631           case '4': case '5': case '6':
13632           case '7': case '8': case '9':
13633             tokadd('$');
13634             do {
13635                 tokadd(c);
13636                 c = nextc();
13637             } while (c != -1 && ISDIGIT(c));
13638             pushback(c);
13639             if (last_state == EXPR_FNAME) goto gvar;
13640             tokfix();
13641             set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
13642             return tNTH_REF;
13643 
13644           default:
13645             if (!parser_is_identchar()) {
13646                 pushback(c);
13647                 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
13648                 return 0;
13649             }
13650           case '0':
13651             tokadd('$');
13652         }
13653         break;
13654 
13655       case '@':
13656         c = nextc();
13657         newtok();
13658         tokadd('@');
13659         if (c == '@') {
13660             tokadd('@');
13661             c = nextc();
13662         }
13663         if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
13664             pushback(c);
13665             if (tokidx == 1) {
13666                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
13667             }
13668             else {
13669                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
13670             }
13671             return 0;
13672         }
13673         break;
13674 
13675       case '_':
13676         if (was_bol() && whole_match_p("__END__", 7, 0)) {
13677             ruby__end__seen = 1;
13678             parser->eofp = Qtrue;
13679 #ifndef RIPPER
13680             return -1;
13681 #else
13682             lex_goto_eol(parser);
13683             ripper_dispatch_scan_event(parser, k__END__);
13684             return 0;
13685 #endif
13686         }
13687         newtok();
13688         break;
13689 
13690       default:
13691         if (!parser_is_identchar()) {
13692             rb_compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
13693             goto retry;
13694         }
13695 
13696         newtok();
13697         break;
13698     }
13699 
13700     mb = ENC_CODERANGE_7BIT;
13701     do {
13702         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
13703         if (tokadd_mbchar(c) == -1) return 0;
13704         c = nextc();
13705     } while (parser_is_identchar());
13706     switch (tok()[0]) {
13707       case '@': case '$':
13708         pushback(c);
13709         break;
13710       default:
13711         if ((c == '!' || c == '?') && !peek('=')) {
13712             tokadd(c);
13713         }
13714         else {
13715             pushback(c);
13716         }
13717     }
13718     tokfix();
13719 
13720     {
13721         int result = 0;
13722 
13723         last_state = lex_state;
13724         switch (tok()[0]) {
13725           case '$':
13726             lex_state = EXPR_END;
13727             result = tGVAR;
13728             break;
13729           case '@':
13730             lex_state = EXPR_END;
13731             if (tok()[1] == '@')
13732                 result = tCVAR;
13733             else
13734                 result = tIVAR;
13735             break;
13736 
13737           default:
13738             if (toklast() == '!' || toklast() == '?') {
13739                 result = tFID;
13740             }
13741             else {
13742                 if (lex_state == EXPR_FNAME) {
13743                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
13744                         (!peek('=') || (peek_n('>', 1)))) {
13745                         result = tIDENTIFIER;
13746                         tokadd(c);
13747                         tokfix();
13748                     }
13749                     else {
13750                         pushback(c);
13751                     }
13752                 }
13753                 if (result == 0 && ISUPPER(tok()[0])) {
13754                     result = tCONSTANT;
13755                 }
13756                 else {
13757                     result = tIDENTIFIER;
13758                 }
13759             }
13760 
13761             if (IS_LABEL_POSSIBLE()) {
13762                 if (IS_LABEL_SUFFIX(0)) {
13763                     lex_state = EXPR_BEG;
13764                     nextc();
13765                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
13766                     return tLABEL;
13767                 }
13768             }
13769             if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
13770                 const struct kwtable *kw;
13771 
13772                 /* See if it is a reserved word.  */
13773                 kw = rb_reserved_word(tok(), toklen());
13774                 if (kw) {
13775                     enum lex_state_e state = lex_state;
13776                     lex_state = kw->state;
13777                     if (state == EXPR_FNAME) {
13778                         set_yylval_name(rb_intern(kw->name));
13779                         return kw->id[0];
13780                     }
13781                     if (kw->id[0] == keyword_do) {
13782                         command_start = TRUE;
13783                         if (lpar_beg && lpar_beg == paren_nest) {
13784                             lpar_beg = 0;
13785                             --paren_nest;
13786                             return keyword_do_LAMBDA;
13787                         }
13788                         if (COND_P()) return keyword_do_cond;
13789                         if (CMDARG_P() && state != EXPR_CMDARG)
13790                             return keyword_do_block;
13791                         if (state == EXPR_ENDARG || state == EXPR_BEG)
13792                             return keyword_do_block;
13793                         return keyword_do;
13794                     }
13795                     if (state == EXPR_BEG || state == EXPR_VALUE)
13796                         return kw->id[0];
13797                     else {
13798                         if (kw->id[0] != kw->id[1])
13799                             lex_state = EXPR_BEG;
13800                         return kw->id[1];
13801                     }
13802                 }
13803             }
13804 
13805             if (IS_BEG() ||
13806                 lex_state == EXPR_DOT ||
13807                 IS_ARG()) {
13808                 if (cmd_state) {
13809                     lex_state = EXPR_CMDARG;
13810                 }
13811                 else {
13812                     lex_state = EXPR_ARG;
13813                 }
13814             }
13815             else if (lex_state == EXPR_FNAME) {
13816                 lex_state = EXPR_ENDFN;
13817             }
13818             else {
13819                 lex_state = EXPR_END;
13820             }
13821         }
13822         {
13823             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
13824 
13825             set_yylval_name(ident);
13826             if (last_state != EXPR_DOT && last_state != EXPR_FNAME &&
13827                 is_local_id(ident) && lvar_defined(ident)) {
13828                 lex_state = EXPR_END;
13829             }
13830         }
13831         return result;
13832     }
13833 }
13834 
13835 #if YYPURE
13836 static int
13837 yylex(void *lval, void *p)
13838 #else
13839 yylex(void *p)
13840 #endif
13841 {
13842     struct parser_params *parser = (struct parser_params*)p;
13843     int t;
13844 
13845 #if YYPURE
13846     parser->parser_yylval = lval;
13847     parser->parser_yylval->val = Qundef;
13848 #endif
13849     t = parser_yylex(parser);
13850 #ifdef RIPPER
13851     if (!NIL_P(parser->delayed)) {
13852         ripper_dispatch_delayed_token(parser, t);
13853         return t;
13854     }
13855     if (t != 0)
13856         ripper_dispatch_scan_event(parser, t);
13857 #endif
13858 
13859     return t;
13860 }
13861 
13862 #ifndef RIPPER
13863 static NODE*
13864 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
13865 {
13866     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
13867     nd_set_line(n, ruby_sourceline);
13868     return n;
13869 }
13870 
13871 enum node_type
13872 nodetype(NODE *node)                    /* for debug */
13873 {
13874     return (enum node_type)nd_type(node);
13875 }
13876 
13877 int
13878 nodeline(NODE *node)
13879 {
13880     return nd_line(node);
13881 }
13882 
13883 static NODE*
13884 newline_node(NODE *node)
13885 {
13886     if (node) {
13887         node = remove_begin(node);
13888         node->flags |= NODE_FL_NEWLINE;
13889     }
13890     return node;
13891 }
13892 
13893 static void
13894 fixpos(NODE *node, NODE *orig)
13895 {
13896     if (!node) return;
13897     if (!orig) return;
13898     if (orig == (NODE*)1) return;
13899     nd_set_line(node, nd_line(orig));
13900 }
13901 
13902 static void
13903 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
13904 {
13905     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
13906 }
13907 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
13908 
13909 static void
13910 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
13911 {
13912     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
13913 }
13914 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
13915 
13916 static NODE*
13917 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
13918 {
13919     NODE *end, *h = head, *nd;
13920 
13921     if (tail == 0) return head;
13922 
13923     if (h == 0) return tail;
13924     switch (nd_type(h)) {
13925       case NODE_LIT:
13926       case NODE_STR:
13927       case NODE_SELF:
13928       case NODE_TRUE:
13929       case NODE_FALSE:
13930       case NODE_NIL:
13931         parser_warning(h, "unused literal ignored");
13932         return tail;
13933       default:
13934         h = end = NEW_BLOCK(head);
13935         end->nd_end = end;
13936         fixpos(end, head);
13937         head = end;
13938         break;
13939       case NODE_BLOCK:
13940         end = h->nd_end;
13941         break;
13942     }
13943 
13944     nd = end->nd_head;
13945     switch (nd_type(nd)) {
13946       case NODE_RETURN:
13947       case NODE_BREAK:
13948       case NODE_NEXT:
13949       case NODE_REDO:
13950       case NODE_RETRY:
13951         if (RTEST(ruby_verbose)) {
13952             parser_warning(nd, "statement not reached");
13953         }
13954         break;
13955 
13956       default:
13957         break;
13958     }
13959 
13960     if (nd_type(tail) != NODE_BLOCK) {
13961         tail = NEW_BLOCK(tail);
13962         tail->nd_end = tail;
13963     }
13964     end->nd_next = tail;
13965     h->nd_end = tail->nd_end;
13966     return head;
13967 }
13968 
13969 /* append item to the list */
13970 static NODE*
13971 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
13972 {
13973     NODE *last;
13974 
13975     if (list == 0) return NEW_LIST(item);
13976     if (list->nd_next) {
13977         last = list->nd_next->nd_end;
13978     }
13979     else {
13980         last = list;
13981     }
13982 
13983     list->nd_alen += 1;
13984     last->nd_next = NEW_LIST(item);
13985     list->nd_next->nd_end = last->nd_next;
13986     return list;
13987 }
13988 
13989 /* concat two lists */
13990 static NODE*
13991 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
13992 {
13993     NODE *last;
13994 
13995     if (head->nd_next) {
13996         last = head->nd_next->nd_end;
13997     }
13998     else {
13999         last = head;
14000     }
14001 
14002     head->nd_alen += tail->nd_alen;
14003     last->nd_next = tail;
14004     if (tail->nd_next) {
14005         head->nd_next->nd_end = tail->nd_next->nd_end;
14006     }
14007     else {
14008         head->nd_next->nd_end = tail;
14009     }
14010 
14011     return head;
14012 }
14013 
14014 static int
14015 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14016 {
14017     if (NIL_P(tail)) return 1;
14018     if (!rb_enc_compatible(head, tail)) {
14019         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14020                       rb_enc_name(rb_enc_get(head)),
14021                       rb_enc_name(rb_enc_get(tail)));
14022         rb_str_resize(head, 0);
14023         rb_str_resize(tail, 0);
14024         return 0;
14025     }
14026     rb_str_buf_append(head, tail);
14027     return 1;
14028 }
14029 
14030 /* concat two string literals */
14031 static NODE *
14032 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14033 {
14034     enum node_type htype;
14035 
14036     if (!head) return tail;
14037     if (!tail) return head;
14038 
14039     htype = nd_type(head);
14040     if (htype == NODE_EVSTR) {
14041         NODE *node = NEW_DSTR(Qnil);
14042         head = list_append(node, head);
14043     }
14044     switch (nd_type(tail)) {
14045       case NODE_STR:
14046         if (htype == NODE_STR) {
14047             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
14048               error:
14049                 rb_gc_force_recycle((VALUE)head);
14050                 rb_gc_force_recycle((VALUE)tail);
14051                 return 0;
14052             }
14053             rb_gc_force_recycle((VALUE)tail);
14054         }
14055         else {
14056             list_append(head, tail);
14057         }
14058         break;
14059 
14060       case NODE_DSTR:
14061         if (htype == NODE_STR) {
14062             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14063                 goto error;
14064             tail->nd_lit = head->nd_lit;
14065             rb_gc_force_recycle((VALUE)head);
14066             head = tail;
14067         }
14068         else if (NIL_P(tail->nd_lit)) {
14069             head->nd_alen += tail->nd_alen - 1;
14070             head->nd_next->nd_end->nd_next = tail->nd_next;
14071             head->nd_next->nd_end = tail->nd_next->nd_end;
14072             rb_gc_force_recycle((VALUE)tail);
14073         }
14074         else {
14075             nd_set_type(tail, NODE_ARRAY);
14076             tail->nd_head = NEW_STR(tail->nd_lit);
14077             list_concat(head, tail);
14078         }
14079         break;
14080 
14081       case NODE_EVSTR:
14082         if (htype == NODE_STR) {
14083             nd_set_type(head, NODE_DSTR);
14084             head->nd_alen = 1;
14085         }
14086         list_append(head, tail);
14087         break;
14088     }
14089     return head;
14090 }
14091 
14092 static NODE *
14093 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14094 {
14095     if (nd_type(node) == NODE_EVSTR) {
14096         node = list_append(NEW_DSTR(Qnil), node);
14097     }
14098     return node;
14099 }
14100 
14101 static NODE *
14102 new_evstr_gen(struct parser_params *parser, NODE *node)
14103 {
14104     NODE *head = node;
14105 
14106     if (node) {
14107         switch (nd_type(node)) {
14108           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14109             return node;
14110         }
14111     }
14112     return NEW_EVSTR(head);
14113 }
14114 
14115 static NODE *
14116 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14117 {
14118     value_expr(recv);
14119     value_expr(arg1);
14120     return NEW_CALL(recv, id, NEW_LIST(arg1));
14121 }
14122 
14123 static NODE *
14124 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14125 {
14126     value_expr(recv);
14127     return NEW_CALL(recv, id, 0);
14128 }
14129 
14130 static NODE*
14131 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14132 {
14133     value_expr(node1);
14134     value_expr(node2);
14135     if (node1) {
14136         switch (nd_type(node1)) {
14137           case NODE_DREGX:
14138           case NODE_DREGX_ONCE:
14139             return NEW_MATCH2(node1, node2);
14140 
14141           case NODE_LIT:
14142             if (TYPE(node1->nd_lit) == T_REGEXP) {
14143                 return NEW_MATCH2(node1, node2);
14144             }
14145         }
14146     }
14147 
14148     if (node2) {
14149         switch (nd_type(node2)) {
14150           case NODE_DREGX:
14151           case NODE_DREGX_ONCE:
14152             return NEW_MATCH3(node2, node1);
14153 
14154           case NODE_LIT:
14155             if (TYPE(node2->nd_lit) == T_REGEXP) {
14156                 return NEW_MATCH3(node2, node1);
14157             }
14158         }
14159     }
14160 
14161     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14162 }
14163 
14164 static NODE*
14165 gettable_gen(struct parser_params *parser, ID id)
14166 {
14167     if (id == keyword_self) {
14168         return NEW_SELF();
14169     }
14170     else if (id == keyword_nil) {
14171         return NEW_NIL();
14172     }
14173     else if (id == keyword_true) {
14174         return NEW_TRUE();
14175     }
14176     else if (id == keyword_false) {
14177         return NEW_FALSE();
14178     }
14179     else if (id == keyword__FILE__) {
14180         return NEW_STR(rb_external_str_new_with_enc(ruby_sourcefile, strlen(ruby_sourcefile),
14181                                                     rb_filesystem_encoding()));
14182     }
14183     else if (id == keyword__LINE__) {
14184         return NEW_LIT(INT2FIX(ruby_sourceline));
14185     }
14186     else if (id == keyword__ENCODING__) {
14187         return NEW_LIT(rb_enc_from_encoding(parser->enc));
14188     }
14189     else if (is_local_id(id)) {
14190         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14191         if (local_id(id)) return NEW_LVAR(id);
14192         /* method call without arguments */
14193         return NEW_VCALL(id);
14194     }
14195     else if (is_global_id(id)) {
14196         return NEW_GVAR(id);
14197     }
14198     else if (is_instance_id(id)) {
14199         return NEW_IVAR(id);
14200     }
14201     else if (is_const_id(id)) {
14202         return NEW_CONST(id);
14203     }
14204     else if (is_class_id(id)) {
14205         return NEW_CVAR(id);
14206     }
14207     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14208     return 0;
14209 }
14210 #else  /* !RIPPER */
14211 static int
14212 id_is_var_gen(struct parser_params *parser, ID id)
14213 {
14214     if (is_notop_id(id)) {
14215         switch (id & ID_SCOPE_MASK) {
14216           case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14217             return 1;
14218           case ID_LOCAL:
14219             if (dyna_in_block() && dvar_defined(id)) return 1;
14220             if (local_id(id)) return 1;
14221             /* method call without arguments */
14222             return 0;
14223         }
14224     }
14225     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14226     return 0;
14227 }
14228 #endif /* !RIPPER */
14229 
14230 #ifdef RIPPER
14231 static VALUE
14232 assignable_gen(struct parser_params *parser, VALUE lhs)
14233 #else
14234 static NODE*
14235 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14236 #endif
14237 {
14238 #ifdef RIPPER
14239     ID id = get_id(lhs);
14240 # define assignable_result(x) get_value(lhs)
14241 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14242 #else
14243 # define assignable_result(x) (x)
14244 #endif
14245     if (!id) return assignable_result(0);
14246     if (id == keyword_self) {
14247         yyerror("Can't change the value of self");
14248     }
14249     else if (id == keyword_nil) {
14250         yyerror("Can't assign to nil");
14251     }
14252     else if (id == keyword_true) {
14253         yyerror("Can't assign to true");
14254     }
14255     else if (id == keyword_false) {
14256         yyerror("Can't assign to false");
14257     }
14258     else if (id == keyword__FILE__) {
14259         yyerror("Can't assign to __FILE__");
14260     }
14261     else if (id == keyword__LINE__) {
14262         yyerror("Can't assign to __LINE__");
14263     }
14264     else if (id == keyword__ENCODING__) {
14265         yyerror("Can't assign to __ENCODING__");
14266     }
14267     else if (is_local_id(id)) {
14268         if (dyna_in_block()) {
14269             if (dvar_curr(id)) {
14270                 return assignable_result(NEW_DASGN_CURR(id, val));
14271             }
14272             else if (dvar_defined(id)) {
14273                 return assignable_result(NEW_DASGN(id, val));
14274             }
14275             else if (local_id(id)) {
14276                 return assignable_result(NEW_LASGN(id, val));
14277             }
14278             else {
14279                 dyna_var(id);
14280                 return assignable_result(NEW_DASGN_CURR(id, val));
14281             }
14282         }
14283         else {
14284             if (!local_id(id)) {
14285                 local_var(id);
14286             }
14287             return assignable_result(NEW_LASGN(id, val));
14288         }
14289     }
14290     else if (is_global_id(id)) {
14291         return assignable_result(NEW_GASGN(id, val));
14292     }
14293     else if (is_instance_id(id)) {
14294         return assignable_result(NEW_IASGN(id, val));
14295     }
14296     else if (is_const_id(id)) {
14297         if (!in_def && !in_single)
14298             return assignable_result(NEW_CDECL(id, val, 0));
14299         yyerror("dynamic constant assignment");
14300     }
14301     else if (is_class_id(id)) {
14302         return assignable_result(NEW_CVASGN(id, val));
14303     }
14304     else {
14305         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14306     }
14307     return assignable_result(0);
14308 #undef assignable_result
14309 #undef parser_yyerror
14310 }
14311 
14312 #define LVAR_USED ((int)1 << (sizeof(int) * CHAR_BIT - 1))
14313 
14314 static ID
14315 shadowing_lvar_gen(struct parser_params *parser, ID name)
14316 {
14317     if (idUScore == name) return name;
14318     if (dyna_in_block()) {
14319         if (dvar_curr(name)) {
14320             yyerror("duplicated argument name");
14321         }
14322         else if (dvar_defined_get(name) || local_id(name)) {
14323             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14324             vtable_add(lvtbl->vars, name);
14325             if (lvtbl->used) {
14326                 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
14327             }
14328         }
14329     }
14330     else {
14331         if (local_id(name)) {
14332             yyerror("duplicated argument name");
14333         }
14334     }
14335     return name;
14336 }
14337 
14338 static void
14339 new_bv_gen(struct parser_params *parser, ID name)
14340 {
14341     if (!name) return;
14342     if (!is_local_id(name)) {
14343         compile_error(PARSER_ARG "invalid local variable - %s",
14344                       rb_id2name(name));
14345         return;
14346     }
14347     shadowing_lvar(name);
14348     dyna_var(name);
14349 }
14350 
14351 #ifndef RIPPER
14352 static NODE *
14353 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14354 {
14355     if (recv && nd_type(recv) == NODE_SELF)
14356         recv = (NODE *)1;
14357     return NEW_ATTRASGN(recv, tASET, idx);
14358 }
14359 
14360 static void
14361 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14362 {
14363     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14364         compile_error(PARSER_ARG "both block arg and actual block given");
14365     }
14366 }
14367 
14368 ID
14369 rb_id_attrset(ID id)
14370 {
14371     id &= ~ID_SCOPE_MASK;
14372     id |= ID_ATTRSET;
14373     return id;
14374 }
14375 
14376 static NODE *
14377 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14378 {
14379     if (recv && nd_type(recv) == NODE_SELF)
14380         recv = (NODE *)1;
14381     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14382 }
14383 
14384 static void
14385 rb_backref_error_gen(struct parser_params *parser, NODE *node)
14386 {
14387     switch (nd_type(node)) {
14388       case NODE_NTH_REF:
14389         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14390         break;
14391       case NODE_BACK_REF:
14392         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14393         break;
14394     }
14395 }
14396 
14397 static NODE *
14398 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14399 {
14400     if (!node2) return node1;
14401     switch (nd_type(node1)) {
14402       case NODE_BLOCK_PASS:
14403         if (node1->nd_head)
14404             node1->nd_head = arg_concat(node1->nd_head, node2);
14405         else
14406             node1->nd_head = NEW_LIST(node2);
14407         return node1;
14408       case NODE_ARGSPUSH:
14409         if (nd_type(node2) != NODE_ARRAY) break;
14410         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14411         nd_set_type(node1, NODE_ARGSCAT);
14412         return node1;
14413       case NODE_ARGSCAT:
14414         if (nd_type(node2) != NODE_ARRAY ||
14415             nd_type(node1->nd_body) != NODE_ARRAY) break;
14416         node1->nd_body = list_concat(node1->nd_body, node2);
14417         return node1;
14418     }
14419     return NEW_ARGSCAT(node1, node2);
14420 }
14421 
14422 static NODE *
14423 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14424 {
14425     if (!node1) return NEW_LIST(node2);
14426     switch (nd_type(node1))  {
14427       case NODE_ARRAY:
14428         return list_append(node1, node2);
14429       case NODE_BLOCK_PASS:
14430         node1->nd_head = arg_append(node1->nd_head, node2);
14431         return node1;
14432       case NODE_ARGSPUSH:
14433         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14434         nd_set_type(node1, NODE_ARGSCAT);
14435         return node1;
14436     }
14437     return NEW_ARGSPUSH(node1, node2);
14438 }
14439 
14440 static NODE *
14441 splat_array(NODE* node)
14442 {
14443     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14444     if (nd_type(node) == NODE_ARRAY) return node;
14445     return 0;
14446 }
14447 
14448 static NODE *
14449 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14450 {
14451     if (!lhs) return 0;
14452 
14453     switch (nd_type(lhs)) {
14454       case NODE_GASGN:
14455       case NODE_IASGN:
14456       case NODE_IASGN2:
14457       case NODE_LASGN:
14458       case NODE_DASGN:
14459       case NODE_DASGN_CURR:
14460       case NODE_MASGN:
14461       case NODE_CDECL:
14462       case NODE_CVASGN:
14463         lhs->nd_value = rhs;
14464         break;
14465 
14466       case NODE_ATTRASGN:
14467       case NODE_CALL:
14468         lhs->nd_args = arg_append(lhs->nd_args, rhs);
14469         break;
14470 
14471       default:
14472         /* should not happen */
14473         break;
14474     }
14475 
14476     return lhs;
14477 }
14478 
14479 static int
14480 value_expr_gen(struct parser_params *parser, NODE *node)
14481 {
14482     int cond = 0;
14483 
14484     if (!node) {
14485         rb_warning0("empty expression");
14486     }
14487     while (node) {
14488         switch (nd_type(node)) {
14489           case NODE_DEFN:
14490           case NODE_DEFS:
14491             parser_warning(node, "void value expression");
14492             return FALSE;
14493 
14494           case NODE_RETURN:
14495           case NODE_BREAK:
14496           case NODE_NEXT:
14497           case NODE_REDO:
14498           case NODE_RETRY:
14499             if (!cond) yyerror("void value expression");
14500             /* or "control never reach"? */
14501             return FALSE;
14502 
14503           case NODE_BLOCK:
14504             while (node->nd_next) {
14505                 node = node->nd_next;
14506             }
14507             node = node->nd_head;
14508             break;
14509 
14510           case NODE_BEGIN:
14511             node = node->nd_body;
14512             break;
14513 
14514           case NODE_IF:
14515             if (!node->nd_body) {
14516                 node = node->nd_else;
14517                 break;
14518             }
14519             else if (!node->nd_else) {
14520                 node = node->nd_body;
14521                 break;
14522             }
14523             if (!value_expr(node->nd_body)) return FALSE;
14524             node = node->nd_else;
14525             break;
14526 
14527           case NODE_AND:
14528           case NODE_OR:
14529             cond = 1;
14530             node = node->nd_2nd;
14531             break;
14532 
14533           default:
14534             return TRUE;
14535         }
14536     }
14537 
14538     return TRUE;
14539 }
14540 
14541 static void
14542 void_expr_gen(struct parser_params *parser, NODE *node)
14543 {
14544     const char *useless = 0;
14545 
14546     if (!RTEST(ruby_verbose)) return;
14547 
14548     if (!node) return;
14549     switch (nd_type(node)) {
14550       case NODE_CALL:
14551         switch (node->nd_mid) {
14552           case '+':
14553           case '-':
14554           case '*':
14555           case '/':
14556           case '%':
14557           case tPOW:
14558           case tUPLUS:
14559           case tUMINUS:
14560           case '|':
14561           case '^':
14562           case '&':
14563           case tCMP:
14564           case '>':
14565           case tGEQ:
14566           case '<':
14567           case tLEQ:
14568           case tEQ:
14569           case tNEQ:
14570             useless = rb_id2name(node->nd_mid);
14571             break;
14572         }
14573         break;
14574 
14575       case NODE_LVAR:
14576       case NODE_DVAR:
14577       case NODE_GVAR:
14578       case NODE_IVAR:
14579       case NODE_CVAR:
14580       case NODE_NTH_REF:
14581       case NODE_BACK_REF:
14582         useless = "a variable";
14583         break;
14584       case NODE_CONST:
14585         useless = "a constant";
14586         break;
14587       case NODE_LIT:
14588       case NODE_STR:
14589       case NODE_DSTR:
14590       case NODE_DREGX:
14591       case NODE_DREGX_ONCE:
14592         useless = "a literal";
14593         break;
14594       case NODE_COLON2:
14595       case NODE_COLON3:
14596         useless = "::";
14597         break;
14598       case NODE_DOT2:
14599         useless = "..";
14600         break;
14601       case NODE_DOT3:
14602         useless = "...";
14603         break;
14604       case NODE_SELF:
14605         useless = "self";
14606         break;
14607       case NODE_NIL:
14608         useless = "nil";
14609         break;
14610       case NODE_TRUE:
14611         useless = "true";
14612         break;
14613       case NODE_FALSE:
14614         useless = "false";
14615         break;
14616       case NODE_DEFINED:
14617         useless = "defined?";
14618         break;
14619     }
14620 
14621     if (useless) {
14622         int line = ruby_sourceline;
14623 
14624         ruby_sourceline = nd_line(node);
14625         rb_warnS("possibly useless use of %s in void context", useless);
14626         ruby_sourceline = line;
14627     }
14628 }
14629 
14630 static void
14631 void_stmts_gen(struct parser_params *parser, NODE *node)
14632 {
14633     if (!RTEST(ruby_verbose)) return;
14634     if (!node) return;
14635     if (nd_type(node) != NODE_BLOCK) return;
14636 
14637     for (;;) {
14638         if (!node->nd_next) return;
14639         void_expr0(node->nd_head);
14640         node = node->nd_next;
14641     }
14642 }
14643 
14644 static NODE *
14645 remove_begin(NODE *node)
14646 {
14647     NODE **n = &node, *n1 = node;
14648     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
14649         *n = n1 = n1->nd_body;
14650     }
14651     return node;
14652 }
14653 
14654 static void
14655 reduce_nodes_gen(struct parser_params *parser, NODE **body)
14656 {
14657     NODE *node = *body;
14658 
14659     if (!node) {
14660         *body = NEW_NIL();
14661         return;
14662     }
14663 #define subnodes(n1, n2) \
14664     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
14665      (!node->n2) ? (body = &node->n1, 1) : \
14666      (reduce_nodes(&node->n1), body = &node->n2, 1))
14667 
14668     while (node) {
14669         int newline = (int)(node->flags & NODE_FL_NEWLINE);
14670         switch (nd_type(node)) {
14671           end:
14672           case NODE_NIL:
14673             *body = 0;
14674             return;
14675           case NODE_RETURN:
14676             *body = node = node->nd_stts;
14677             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14678             continue;
14679           case NODE_BEGIN:
14680             *body = node = node->nd_body;
14681             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14682             continue;
14683           case NODE_BLOCK:
14684             body = &node->nd_end->nd_head;
14685             break;
14686           case NODE_IF:
14687             if (subnodes(nd_body, nd_else)) break;
14688             return;
14689           case NODE_CASE:
14690             body = &node->nd_body;
14691             break;
14692           case NODE_WHEN:
14693             if (!subnodes(nd_body, nd_next)) goto end;
14694             break;
14695           case NODE_ENSURE:
14696             if (!subnodes(nd_head, nd_resq)) goto end;
14697             break;
14698           case NODE_RESCUE:
14699             if (node->nd_else) {
14700                 body = &node->nd_resq;
14701                 break;
14702             }
14703             if (!subnodes(nd_head, nd_resq)) goto end;
14704             break;
14705           default:
14706             return;
14707         }
14708         node = *body;
14709         if (newline && node) node->flags |= NODE_FL_NEWLINE;
14710     }
14711 
14712 #undef subnodes
14713 }
14714 
14715 static int
14716 assign_in_cond(struct parser_params *parser, NODE *node)
14717 {
14718     switch (nd_type(node)) {
14719       case NODE_MASGN:
14720         yyerror("multiple assignment in conditional");
14721         return 1;
14722 
14723       case NODE_LASGN:
14724       case NODE_DASGN:
14725       case NODE_DASGN_CURR:
14726       case NODE_GASGN:
14727       case NODE_IASGN:
14728         break;
14729 
14730       default:
14731         return 0;
14732     }
14733 
14734     if (!node->nd_value) return 1;
14735     switch (nd_type(node->nd_value)) {
14736       case NODE_LIT:
14737       case NODE_STR:
14738       case NODE_NIL:
14739       case NODE_TRUE:
14740       case NODE_FALSE:
14741         /* reports always */
14742         parser_warn(node->nd_value, "found = in conditional, should be ==");
14743         return 1;
14744 
14745       case NODE_DSTR:
14746       case NODE_XSTR:
14747       case NODE_DXSTR:
14748       case NODE_EVSTR:
14749       case NODE_DREGX:
14750       default:
14751         break;
14752     }
14753     return 1;
14754 }
14755 
14756 static void
14757 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14758 {
14759     if (!e_option_supplied(parser)) parser_warn(node, str);
14760 }
14761 
14762 static void
14763 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14764 {
14765     if (!e_option_supplied(parser)) parser_warning(node, str);
14766 }
14767 
14768 static void
14769 fixup_nodes(NODE **rootnode)
14770 {
14771     NODE *node, *next, *head;
14772 
14773     for (node = *rootnode; node; node = next) {
14774         enum node_type type;
14775         VALUE val;
14776 
14777         next = node->nd_next;
14778         head = node->nd_head;
14779         rb_gc_force_recycle((VALUE)node);
14780         *rootnode = next;
14781         switch (type = nd_type(head)) {
14782           case NODE_DOT2:
14783           case NODE_DOT3:
14784             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
14785                                type == NODE_DOT3);
14786             rb_gc_force_recycle((VALUE)head->nd_beg);
14787             rb_gc_force_recycle((VALUE)head->nd_end);
14788             nd_set_type(head, NODE_LIT);
14789             head->nd_lit = val;
14790             break;
14791           default:
14792             break;
14793         }
14794     }
14795 }
14796 
14797 static NODE *cond0(struct parser_params*,NODE*);
14798 
14799 static NODE*
14800 range_op(struct parser_params *parser, NODE *node)
14801 {
14802     enum node_type type;
14803 
14804     if (node == 0) return 0;
14805 
14806     type = nd_type(node);
14807     value_expr(node);
14808     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
14809         warn_unless_e_option(parser, node, "integer literal in conditional range");
14810         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
14811     }
14812     return cond0(parser, node);
14813 }
14814 
14815 static int
14816 literal_node(NODE *node)
14817 {
14818     if (!node) return 1;        /* same as NODE_NIL */
14819     switch (nd_type(node)) {
14820       case NODE_LIT:
14821       case NODE_STR:
14822       case NODE_DSTR:
14823       case NODE_EVSTR:
14824       case NODE_DREGX:
14825       case NODE_DREGX_ONCE:
14826       case NODE_DSYM:
14827         return 2;
14828       case NODE_TRUE:
14829       case NODE_FALSE:
14830       case NODE_NIL:
14831         return 1;
14832     }
14833     return 0;
14834 }
14835 
14836 static NODE*
14837 cond0(struct parser_params *parser, NODE *node)
14838 {
14839     if (node == 0) return 0;
14840     assign_in_cond(parser, node);
14841 
14842     switch (nd_type(node)) {
14843       case NODE_DSTR:
14844       case NODE_EVSTR:
14845       case NODE_STR:
14846         rb_warn0("string literal in condition");
14847         break;
14848 
14849       case NODE_DREGX:
14850       case NODE_DREGX_ONCE:
14851         warning_unless_e_option(parser, node, "regex literal in condition");
14852         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
14853 
14854       case NODE_AND:
14855       case NODE_OR:
14856         node->nd_1st = cond0(parser, node->nd_1st);
14857         node->nd_2nd = cond0(parser, node->nd_2nd);
14858         break;
14859 
14860       case NODE_DOT2:
14861       case NODE_DOT3:
14862         node->nd_beg = range_op(parser, node->nd_beg);
14863         node->nd_end = range_op(parser, node->nd_end);
14864         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
14865         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
14866         if (!e_option_supplied(parser)) {
14867             int b = literal_node(node->nd_beg);
14868             int e = literal_node(node->nd_end);
14869             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
14870                 parser_warn(node, "range literal in condition");
14871             }
14872         }
14873         break;
14874 
14875       case NODE_DSYM:
14876         parser_warning(node, "literal in condition");
14877         break;
14878 
14879       case NODE_LIT:
14880         if (TYPE(node->nd_lit) == T_REGEXP) {
14881             warn_unless_e_option(parser, node, "regex literal in condition");
14882             nd_set_type(node, NODE_MATCH);
14883         }
14884         else {
14885             parser_warning(node, "literal in condition");
14886         }
14887       default:
14888         break;
14889     }
14890     return node;
14891 }
14892 
14893 static NODE*
14894 cond_gen(struct parser_params *parser, NODE *node)
14895 {
14896     if (node == 0) return 0;
14897     return cond0(parser, node);
14898 }
14899 
14900 static NODE*
14901 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
14902 {
14903     value_expr(left);
14904     if (left && (enum node_type)nd_type(left) == type) {
14905         NODE *node = left, *second;
14906         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
14907             node = second;
14908         }
14909         node->nd_2nd = NEW_NODE(type, second, right, 0);
14910         return left;
14911     }
14912     return NEW_NODE(type, left, right, 0);
14913 }
14914 
14915 static void
14916 no_blockarg(struct parser_params *parser, NODE *node)
14917 {
14918     if (node && nd_type(node) == NODE_BLOCK_PASS) {
14919         compile_error(PARSER_ARG "block argument should not be given");
14920     }
14921 }
14922 
14923 static NODE *
14924 ret_args_gen(struct parser_params *parser, NODE *node)
14925 {
14926     if (node) {
14927         no_blockarg(parser, node);
14928         if (nd_type(node) == NODE_ARRAY) {
14929             if (node->nd_next == 0) {
14930                 node = node->nd_head;
14931             }
14932             else {
14933                 nd_set_type(node, NODE_VALUES);
14934             }
14935         }
14936     }
14937     return node;
14938 }
14939 
14940 static NODE *
14941 new_yield_gen(struct parser_params *parser, NODE *node)
14942 {
14943     long state = Qtrue;
14944 
14945     if (node) {
14946         no_blockarg(parser, node);
14947         if (node && nd_type(node) == NODE_SPLAT) {
14948             state = Qtrue;
14949         }
14950     }
14951     else {
14952         state = Qfalse;
14953     }
14954     return NEW_YIELD(node, state);
14955 }
14956 
14957 static NODE*
14958 negate_lit(NODE *node)
14959 {
14960     switch (TYPE(node->nd_lit)) {
14961       case T_FIXNUM:
14962         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
14963         break;
14964       case T_BIGNUM:
14965         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
14966         break;
14967       case T_FLOAT:
14968         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
14969         break;
14970       default:
14971         break;
14972     }
14973     return node;
14974 }
14975 
14976 static NODE *
14977 arg_blk_pass(NODE *node1, NODE *node2)
14978 {
14979     if (node2) {
14980         node2->nd_head = node1;
14981         return node2;
14982     }
14983     return node1;
14984 }
14985 
14986 static NODE*
14987 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
14988 {
14989     int saved_line = ruby_sourceline;
14990     NODE *node;
14991     NODE *i1, *i2 = 0;
14992 
14993     node = NEW_ARGS(m ? m->nd_plen : 0, o);
14994     i1 = m ? m->nd_next : 0;
14995     node->nd_next = NEW_ARGS_AUX(r, b);
14996 
14997     if (p) {
14998         i2 = p->nd_next;
14999         node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
15000     }
15001     else if (i1) {
15002         node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
15003     }
15004     if (i1 || i2) {
15005         node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
15006     }
15007     ruby_sourceline = saved_line;
15008     return node;
15009 }
15010 #endif /* !RIPPER */
15011 
15012 static void
15013 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15014 {
15015     int i, cnt;
15016     ID *v, *u;
15017 
15018     if (!local->used) return;
15019     v = local->vars->tbl;
15020     u = local->used->tbl;
15021     cnt = local->used->pos;
15022     if (cnt != local->vars->pos) {
15023         rb_bug("local->used->pos != local->vars->pos");
15024     }
15025     for (i = 0; i < cnt; ++i) {
15026         if (!v[i] || (u[i] & LVAR_USED)) continue;
15027         if (idUScore == v[i]) continue;
15028         rb_compile_warn(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15029     }
15030 }
15031 
15032 static void
15033 local_push_gen(struct parser_params *parser, int inherit_dvars)
15034 {
15035     struct local_vars *local;
15036 
15037     local = ALLOC(struct local_vars);
15038     local->prev = lvtbl;
15039     local->args = vtable_alloc(0);
15040     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15041     local->used = !inherit_dvars && RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15042     local->cmdargs = cmdarg_stack;
15043     cmdarg_stack = 0;
15044     lvtbl = local;
15045 }
15046 
15047 static void
15048 local_pop_gen(struct parser_params *parser)
15049 {
15050     struct local_vars *local = lvtbl->prev;
15051     if (lvtbl->used) {
15052         warn_unused_var(parser, lvtbl);
15053         vtable_free(lvtbl->used);
15054     }
15055     vtable_free(lvtbl->args);
15056     vtable_free(lvtbl->vars);
15057     cmdarg_stack = lvtbl->cmdargs;
15058     xfree(lvtbl);
15059     lvtbl = local;
15060 }
15061 
15062 #ifndef RIPPER
15063 static ID*
15064 vtable_tblcpy(ID *buf, const struct vtable *src)
15065 {
15066     int i, cnt = vtable_size(src);
15067 
15068     if (cnt > 0) {
15069         buf[0] = cnt;
15070         for (i = 0; i < cnt; i++) {
15071             buf[i] = src->tbl[i];
15072         }
15073         return buf;
15074     }
15075     return 0;
15076 }
15077 
15078 static ID*
15079 local_tbl_gen(struct parser_params *parser)
15080 {
15081     int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15082     ID *buf;
15083 
15084     if (cnt <= 0) return 0;
15085     buf = ALLOC_N(ID, cnt + 1);
15086     vtable_tblcpy(buf+1, lvtbl->args);
15087     vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15088     buf[0] = cnt;
15089     return buf;
15090 }
15091 #endif
15092 
15093 static int
15094 arg_var_gen(struct parser_params *parser, ID id)
15095 {
15096     vtable_add(lvtbl->args, id);
15097     return vtable_size(lvtbl->args) - 1;
15098 }
15099 
15100 static int
15101 local_var_gen(struct parser_params *parser, ID id)
15102 {
15103     vtable_add(lvtbl->vars, id);
15104     if (lvtbl->used) {
15105         vtable_add(lvtbl->used, (ID)ruby_sourceline);
15106     }
15107     return vtable_size(lvtbl->vars) - 1;
15108 }
15109 
15110 static int
15111 local_id_gen(struct parser_params *parser, ID id)
15112 {
15113     struct vtable *vars, *args, *used;
15114 
15115     vars = lvtbl->vars;
15116     args = lvtbl->args;
15117     used = lvtbl->used;
15118 
15119     while (vars && POINTER_P(vars->prev)) {
15120         vars = vars->prev;
15121         args = args->prev;
15122         if (used) used = used->prev;
15123     }
15124 
15125     if (vars && vars->prev == DVARS_INHERIT) {
15126         return rb_local_defined(id);
15127     }
15128     else if (vtable_included(args, id)) {
15129         return 1;
15130     }
15131     else {
15132         int i = vtable_included(vars, id);
15133         if (i && used) used->tbl[i-1] |= LVAR_USED;
15134         return i != 0;
15135     }
15136 }
15137 
15138 static const struct vtable *
15139 dyna_push_gen(struct parser_params *parser)
15140 {
15141     lvtbl->args = vtable_alloc(lvtbl->args);
15142     lvtbl->vars = vtable_alloc(lvtbl->vars);
15143     if (lvtbl->used) {
15144         lvtbl->used = vtable_alloc(lvtbl->used);
15145     }
15146     return lvtbl->args;
15147 }
15148 
15149 static void
15150 dyna_pop_1(struct parser_params *parser)
15151 {
15152     struct vtable *tmp;
15153 
15154     if ((tmp = lvtbl->used) != 0) {
15155         warn_unused_var(parser, lvtbl);
15156         lvtbl->used = lvtbl->used->prev;
15157         vtable_free(tmp);
15158     }
15159     tmp = lvtbl->args;
15160     lvtbl->args = lvtbl->args->prev;
15161     vtable_free(tmp);
15162     tmp = lvtbl->vars;
15163     lvtbl->vars = lvtbl->vars->prev;
15164     vtable_free(tmp);
15165 }
15166 
15167 static void
15168 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15169 {
15170     while (lvtbl->args != lvargs) {
15171         dyna_pop_1(parser);
15172         if (!lvtbl->args) {
15173             struct local_vars *local = lvtbl->prev;
15174             xfree(lvtbl);
15175             lvtbl = local;
15176         }
15177     }
15178     dyna_pop_1(parser);
15179 }
15180 
15181 static int
15182 dyna_in_block_gen(struct parser_params *parser)
15183 {
15184     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15185 }
15186 
15187 static int
15188 dvar_defined_gen(struct parser_params *parser, ID id, int get)
15189 {
15190     struct vtable *vars, *args, *used;
15191     int i;
15192 
15193     args = lvtbl->args;
15194     vars = lvtbl->vars;
15195     used = lvtbl->used;
15196 
15197     while (POINTER_P(vars)) {
15198         if (vtable_included(args, id)) {
15199             return 1;
15200         }
15201         if ((i = vtable_included(vars, id)) != 0) {
15202             if (used) used->tbl[i-1] |= LVAR_USED;
15203             return 1;
15204         }
15205         args = args->prev;
15206         vars = vars->prev;
15207         if (get) used = 0;
15208         if (used) used = used->prev;
15209     }
15210 
15211     if (vars == DVARS_INHERIT) {
15212         return rb_dvar_defined(id);
15213     }
15214 
15215     return 0;
15216 }
15217 
15218 static int
15219 dvar_curr_gen(struct parser_params *parser, ID id)
15220 {
15221     return (vtable_included(lvtbl->args, id) ||
15222             vtable_included(lvtbl->vars, id));
15223 }
15224 
15225 #ifndef RIPPER
15226 static void
15227 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
15228 {
15229     int c = RE_OPTION_ENCODING_IDX(options);
15230 
15231     if (c) {
15232         int opt, idx;
15233         rb_char_to_option_kcode(c, &opt, &idx);
15234         if (idx != ENCODING_GET(str) &&
15235             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15236             goto error;
15237         }
15238         ENCODING_SET(str, idx);
15239     }
15240     else if (RE_OPTION_ENCODING_NONE(options)) {
15241         if (!ENCODING_IS_ASCII8BIT(str) &&
15242             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15243             c = 'n';
15244             goto error;
15245         }
15246         rb_enc_associate(str, rb_ascii8bit_encoding());
15247     }
15248     else if (parser->enc == rb_usascii_encoding()) {
15249         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15250             /* raise in re.c */
15251             rb_enc_associate(str, rb_usascii_encoding());
15252         }
15253         else {
15254             rb_enc_associate(str, rb_ascii8bit_encoding());
15255         }
15256     }
15257     return;
15258 
15259   error:
15260     compile_error(PARSER_ARG
15261         "regexp encoding option '%c' differs from source encoding '%s'",
15262         c, rb_enc_name(rb_enc_get(str)));
15263 }
15264 
15265 static int
15266 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
15267 {
15268     VALUE err;
15269     reg_fragment_setenc(str, options);
15270     err = rb_reg_check_preprocess(str);
15271     if (err != Qnil) {
15272         err = rb_obj_as_string(err);
15273         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15274         RB_GC_GUARD(err);
15275         return 0;
15276     }
15277     return 1;
15278 }
15279 
15280 typedef struct {
15281     struct parser_params* parser;
15282     rb_encoding *enc;
15283     NODE *succ_block;
15284     NODE *fail_block;
15285     int num;
15286 } reg_named_capture_assign_t;
15287 
15288 static int
15289 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
15290           int back_num, int *back_refs, OnigRegex regex, void *arg0)
15291 {
15292     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
15293     struct parser_params* parser = arg->parser;
15294     rb_encoding *enc = arg->enc;
15295     long len = name_end - name;
15296     const char *s = (const char *)name;
15297     ID var;
15298 
15299     arg->num++;
15300 
15301     if (arg->succ_block == 0) {
15302         arg->succ_block = NEW_BEGIN(0);
15303         arg->fail_block = NEW_BEGIN(0);
15304     }
15305 
15306     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15307         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15308         !rb_enc_symname2_p(s, len, enc)) {
15309         return ST_CONTINUE;
15310     }
15311     var = rb_intern3(s, len, enc);
15312     if (dvar_defined(var) || local_id(var)) {
15313         rb_warningS("named capture conflicts a local variable - %s",
15314                     rb_id2name(var));
15315     }
15316     arg->succ_block = block_append(arg->succ_block,
15317         newline_node(node_assign(assignable(var,0),
15318             NEW_CALL(
15319               gettable(rb_intern("$~")),
15320               idAREF,
15321               NEW_LIST(NEW_LIT(ID2SYM(var))))
15322             )));
15323     arg->fail_block = block_append(arg->fail_block,
15324         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
15325     return ST_CONTINUE;
15326 }
15327 
15328 static NODE *
15329 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
15330 {
15331     reg_named_capture_assign_t arg;
15332 
15333     arg.parser = parser;
15334     arg.enc = rb_enc_get(regexp);
15335     arg.succ_block = 0;
15336     arg.fail_block = 0;
15337     arg.num = 0;
15338     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
15339 
15340     if (arg.num == 0)
15341         return match;
15342 
15343     return
15344         block_append(
15345             newline_node(match),
15346             NEW_IF(gettable(rb_intern("$~")),
15347                 block_append(
15348                     newline_node(arg.succ_block),
15349                     newline_node(
15350                         NEW_CALL(
15351                           gettable(rb_intern("$~")),
15352                           rb_intern("begin"),
15353                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15354                 block_append(
15355                     newline_node(arg.fail_block),
15356                     newline_node(
15357                         NEW_LIT(Qnil)))));
15358 }
15359 
15360 static VALUE
15361 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15362 {
15363     VALUE re;
15364     VALUE err;
15365 
15366     reg_fragment_setenc(str, options);
15367     err = rb_errinfo();
15368     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
15369     if (NIL_P(re)) {
15370         ID mesg = rb_intern("mesg");
15371         VALUE m = rb_attr_get(rb_errinfo(), mesg);
15372         rb_set_errinfo(err);
15373         if (!NIL_P(err)) {
15374             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15375         }
15376         else {
15377             compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
15378         }
15379         return Qnil;
15380     }
15381     return re;
15382 }
15383 
15384 void
15385 rb_gc_mark_parser(void)
15386 {
15387 }
15388 
15389 NODE*
15390 rb_parser_append_print(VALUE vparser, NODE *node)
15391 {
15392     NODE *prelude = 0;
15393     NODE *scope = node;
15394     struct parser_params *parser;
15395 
15396     if (!node) return node;
15397 
15398     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15399 
15400     node = node->nd_body;
15401 
15402     if (nd_type(node) == NODE_PRELUDE) {
15403         prelude = node;
15404         node = node->nd_body;
15405     }
15406 
15407     node = block_append(node,
15408                         NEW_FCALL(rb_intern("print"),
15409                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
15410     if (prelude) {
15411         prelude->nd_body = node;
15412         scope->nd_body = prelude;
15413     }
15414     else {
15415         scope->nd_body = node;
15416     }
15417 
15418     return scope;
15419 }
15420 
15421 NODE *
15422 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15423 {
15424     NODE *prelude = 0;
15425     NODE *scope = node;
15426     struct parser_params *parser;
15427 
15428     if (!node) return node;
15429 
15430     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15431 
15432     node = node->nd_body;
15433 
15434     if (nd_type(node) == NODE_PRELUDE) {
15435         prelude = node;
15436         node = node->nd_body;
15437     }
15438     if (split) {
15439         node = block_append(NEW_GASGN(rb_intern("$F"),
15440                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
15441                                                rb_intern("split"), 0)),
15442                             node);
15443     }
15444     if (chop) {
15445         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15446                                      rb_intern("chop!"), 0), node);
15447     }
15448 
15449     node = NEW_OPT_N(node);
15450 
15451     if (prelude) {
15452         prelude->nd_body = node;
15453         scope->nd_body = prelude;
15454     }
15455     else {
15456         scope->nd_body = node;
15457     }
15458 
15459     return scope;
15460 }
15461 
15462 static const struct {
15463     ID token;
15464     const char *name;
15465 } op_tbl[] = {
15466     {tDOT2,     ".."},
15467     {tDOT3,     "..."},
15468     {tPOW,      "**"},
15469     {tUPLUS,    "+@"},
15470     {tUMINUS,   "-@"},
15471     {tCMP,      "<=>"},
15472     {tGEQ,      ">="},
15473     {tLEQ,      "<="},
15474     {tEQ,       "=="},
15475     {tEQQ,      "==="},
15476     {tNEQ,      "!="},
15477     {tMATCH,    "=~"},
15478     {tNMATCH,   "!~"},
15479     {tAREF,     "[]"},
15480     {tASET,     "[]="},
15481     {tLSHFT,    "<<"},
15482     {tRSHFT,    ">>"},
15483     {tCOLON2,   "::"},
15484 };
15485 
15486 #define op_tbl_count numberof(op_tbl)
15487 
15488 #ifndef ENABLE_SELECTOR_NAMESPACE
15489 #define ENABLE_SELECTOR_NAMESPACE 0
15490 #endif
15491 
15492 static struct symbols {
15493     ID last_id;
15494     st_table *sym_id;
15495     st_table *id_str;
15496 #if ENABLE_SELECTOR_NAMESPACE
15497     st_table *ivar2_id;
15498     st_table *id_ivar2;
15499 #endif
15500     VALUE op_sym[tLAST_TOKEN];
15501 } global_symbols = {tLAST_ID};
15502 
15503 static const struct st_hash_type symhash = {
15504     rb_str_hash_cmp,
15505     rb_str_hash,
15506 };
15507 
15508 #if ENABLE_SELECTOR_NAMESPACE
15509 struct ivar2_key {
15510     ID id;
15511     VALUE klass;
15512 };
15513 
15514 static int
15515 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15516 {
15517     if (key1->id == key2->id && key1->klass == key2->klass) {
15518         return 0;
15519     }
15520     return 1;
15521 }
15522 
15523 static int
15524 ivar2_hash(struct ivar2_key *key)
15525 {
15526     return (key->id << 8) ^ (key->klass >> 2);
15527 }
15528 
15529 static const struct st_hash_type ivar2_hash_type = {
15530     ivar2_cmp,
15531     ivar2_hash,
15532 };
15533 #endif
15534 
15535 void
15536 Init_sym(void)
15537 {
15538     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15539     global_symbols.id_str = st_init_numtable_with_size(1000);
15540 #if ENABLE_SELECTOR_NAMESPACE
15541     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15542     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15543 #endif
15544 
15545     Init_id();
15546 }
15547 
15548 void
15549 rb_gc_mark_symbols(void)
15550 {
15551     rb_mark_tbl(global_symbols.id_str);
15552     rb_gc_mark_locations(global_symbols.op_sym,
15553                          global_symbols.op_sym + tLAST_TOKEN);
15554 }
15555 #endif /* !RIPPER */
15556 
15557 static ID
15558 internal_id_gen(struct parser_params *parser)
15559 {
15560     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
15561     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
15562     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
15563 }
15564 
15565 #ifndef RIPPER
15566 static int
15567 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
15568 {
15569     int mb = 0;
15570 
15571     if (m >= e) return 0;
15572     if (is_global_name_punct(*m)) {
15573         ++m;
15574     }
15575     else if (*m == '-') {
15576         ++m;
15577         if (m < e && is_identchar(m, e, enc)) {
15578             if (!ISASCII(*m)) mb = 1;
15579             m += rb_enc_mbclen(m, e, enc);
15580         }
15581     }
15582     else {
15583         if (!rb_enc_isdigit(*m, enc)) return 0;
15584         do {
15585             if (!ISASCII(*m)) mb = 1;
15586             ++m;
15587         } while (m < e && rb_enc_isdigit(*m, enc));
15588     }
15589     return m == e ? mb + 1 : 0;
15590 }
15591 
15592 int
15593 rb_symname_p(const char *name)
15594 {
15595     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
15596 }
15597 
15598 int
15599 rb_enc_symname_p(const char *name, rb_encoding *enc)
15600 {
15601     return rb_enc_symname2_p(name, strlen(name), enc);
15602 }
15603 
15604 int
15605 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
15606 {
15607     const char *m = name;
15608     const char *e = m + len;
15609     int localid = FALSE;
15610 
15611     if (!m || len <= 0) return FALSE;
15612     switch (*m) {
15613       case '\0':
15614         return FALSE;
15615 
15616       case '$':
15617         if (is_special_global_name(++m, e, enc)) return TRUE;
15618         goto id;
15619 
15620       case '@':
15621         if (*++m == '@') ++m;
15622         goto id;
15623 
15624       case '<':
15625         switch (*++m) {
15626           case '<': ++m; break;
15627           case '=': if (*++m == '>') ++m; break;
15628           default: break;
15629         }
15630         break;
15631 
15632       case '>':
15633         switch (*++m) {
15634           case '>': case '=': ++m; break;
15635         }
15636         break;
15637 
15638       case '=':
15639         switch (*++m) {
15640           case '~': ++m; break;
15641           case '=': if (*++m == '=') ++m; break;
15642           default: return FALSE;
15643         }
15644         break;
15645 
15646       case '*':
15647         if (*++m == '*') ++m;
15648         break;
15649 
15650       case '+': case '-':
15651         if (*++m == '@') ++m;
15652         break;
15653 
15654       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
15655         ++m;
15656         break;
15657 
15658       case '[':
15659         if (*++m != ']') return FALSE;
15660         if (*++m == '=') ++m;
15661         break;
15662 
15663       case '!':
15664         if (len == 1) return TRUE;
15665         switch (*++m) {
15666           case '=': case '~': ++m; break;
15667           default: return FALSE;
15668         }
15669         break;
15670 
15671       default:
15672         localid = !rb_enc_isupper(*m, enc);
15673       id:
15674         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
15675             return FALSE;
15676         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
15677         if (localid) {
15678             switch (*m) {
15679               case '!': case '?': case '=': ++m;
15680             }
15681         }
15682         break;
15683     }
15684     return m == e;
15685 }
15686 
15687 static ID
15688 register_symid(ID id, const char *name, long len, rb_encoding *enc)
15689 {
15690     VALUE str = rb_enc_str_new(name, len, enc);
15691     OBJ_FREEZE(str);
15692     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
15693     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
15694     return id;
15695 }
15696 
15697 ID
15698 rb_intern3(const char *name, long len, rb_encoding *enc)
15699 {
15700     const char *m = name;
15701     const char *e = m + len;
15702     unsigned char c;
15703     VALUE str;
15704     ID id;
15705     long last;
15706     int mb;
15707     st_data_t data;
15708     struct RString fake_str;
15709     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
15710     fake_str.basic.klass = rb_cString;
15711     fake_str.as.heap.len = len;
15712     fake_str.as.heap.ptr = (char *)name;
15713     fake_str.as.heap.aux.capa = len;
15714     str = (VALUE)&fake_str;
15715     rb_enc_associate(str, enc);
15716     OBJ_FREEZE(str);
15717 
15718     if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
15719         rb_raise(rb_eEncodingError, "invalid encoding symbol");
15720     }
15721 
15722     if (st_lookup(global_symbols.sym_id, str, &data))
15723         return (ID)data;
15724 
15725     if (rb_cString && !rb_enc_asciicompat(enc)) {
15726         id = ID_JUNK;
15727         goto new_id;
15728     }
15729     last = len-1;
15730     id = 0;
15731     switch (*m) {
15732       case '$':
15733         id |= ID_GLOBAL;
15734         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
15735             if (!--mb) enc = rb_ascii8bit_encoding();
15736             goto new_id;
15737         }
15738         break;
15739       case '@':
15740         if (m[1] == '@') {
15741             m++;
15742             id |= ID_CLASS;
15743         }
15744         else {
15745             id |= ID_INSTANCE;
15746         }
15747         m++;
15748         break;
15749       default:
15750         c = m[0];
15751         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
15752             /* operators */
15753             int i;
15754 
15755             if (len == 1) {
15756                 id = c;
15757                 goto id_register;
15758             }
15759             for (i = 0; i < op_tbl_count; i++) {
15760                 if (*op_tbl[i].name == *m &&
15761                     strcmp(op_tbl[i].name, m) == 0) {
15762                     id = op_tbl[i].token;
15763                     goto id_register;
15764                 }
15765             }
15766         }
15767 
15768         if (m[last] == '=') {
15769             /* attribute assignment */
15770             id = rb_intern3(name, last, enc);
15771             if (id > tLAST_TOKEN && !is_attrset_id(id)) {
15772                 enc = rb_enc_get(rb_id2str(id));
15773                 id = rb_id_attrset(id);
15774                 goto id_register;
15775             }
15776             id = ID_ATTRSET;
15777         }
15778         else if (rb_enc_isupper(m[0], enc)) {
15779             id = ID_CONST;
15780         }
15781         else {
15782             id = ID_LOCAL;
15783         }
15784         break;
15785     }
15786     mb = 0;
15787     if (!rb_enc_isdigit(*m, enc)) {
15788         while (m <= name + last && is_identchar(m, e, enc)) {
15789             if (ISASCII(*m)) {
15790                 m++;
15791             }
15792             else {
15793                 mb = 1;
15794                 m += rb_enc_mbclen(m, e, enc);
15795             }
15796         }
15797     }
15798     if (m - name < len) id = ID_JUNK;
15799     if (enc != rb_usascii_encoding()) {
15800         /*
15801          * this clause makes sense only when called from other than
15802          * rb_intern_str() taking care of code-range.
15803          */
15804         if (!mb) {
15805             for (; m <= name + len; ++m) {
15806                 if (!ISASCII(*m)) goto mbstr;
15807             }
15808             enc = rb_usascii_encoding();
15809         }
15810       mbstr:;
15811     }
15812   new_id:
15813     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
15814         if (len > 20) {
15815             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
15816                      name);
15817         }
15818         else {
15819             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
15820                      (int)len, name);
15821         }
15822     }
15823     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
15824   id_register:
15825     return register_symid(id, name, len, enc);
15826 }
15827 
15828 ID
15829 rb_intern2(const char *name, long len)
15830 {
15831     return rb_intern3(name, len, rb_usascii_encoding());
15832 }
15833 
15834 #undef rb_intern
15835 ID
15836 rb_intern(const char *name)
15837 {
15838     return rb_intern2(name, strlen(name));
15839 }
15840 
15841 ID
15842 rb_intern_str(VALUE str)
15843 {
15844     rb_encoding *enc;
15845     ID id;
15846 
15847     if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
15848         enc = rb_usascii_encoding();
15849     }
15850     else {
15851         enc = rb_enc_get(str);
15852     }
15853     id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
15854     RB_GC_GUARD(str);
15855     return id;
15856 }
15857 
15858 VALUE
15859 rb_id2str(ID id)
15860 {
15861     st_data_t data;
15862 
15863     if (id < tLAST_TOKEN) {
15864         int i = 0;
15865 
15866         if (id < INT_MAX && rb_ispunct((int)id)) {
15867             VALUE str = global_symbols.op_sym[i = (int)id];
15868             if (!str) {
15869                 char name[2];
15870                 name[0] = (char)id;
15871                 name[1] = 0;
15872                 str = rb_usascii_str_new(name, 1);
15873                 OBJ_FREEZE(str);
15874                 global_symbols.op_sym[i] = str;
15875             }
15876             return str;
15877         }
15878         for (i = 0; i < op_tbl_count; i++) {
15879             if (op_tbl[i].token == id) {
15880                 VALUE str = global_symbols.op_sym[i];
15881                 if (!str) {
15882                     str = rb_usascii_str_new2(op_tbl[i].name);
15883                     OBJ_FREEZE(str);
15884                     global_symbols.op_sym[i] = str;
15885                 }
15886                 return str;
15887             }
15888         }
15889     }
15890 
15891     if (st_lookup(global_symbols.id_str, id, &data)) {
15892         VALUE str = (VALUE)data;
15893         if (RBASIC(str)->klass == 0)
15894             RBASIC(str)->klass = rb_cString;
15895         return str;
15896     }
15897 
15898     if (is_attrset_id(id)) {
15899         ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
15900         VALUE str;
15901 
15902         while (!(str = rb_id2str(id2))) {
15903             if (!is_local_id(id2)) return 0;
15904             id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
15905         }
15906         str = rb_str_dup(str);
15907         rb_str_cat(str, "=", 1);
15908         rb_intern_str(str);
15909         if (st_lookup(global_symbols.id_str, id, &data)) {
15910             VALUE str = (VALUE)data;
15911             if (RBASIC(str)->klass == 0)
15912                 RBASIC(str)->klass = rb_cString;
15913             return str;
15914         }
15915     }
15916     return 0;
15917 }
15918 
15919 const char *
15920 rb_id2name(ID id)
15921 {
15922     VALUE str = rb_id2str(id);
15923 
15924     if (!str) return 0;
15925     return RSTRING_PTR(str);
15926 }
15927 
15928 static int
15929 symbols_i(VALUE sym, ID value, VALUE ary)
15930 {
15931     rb_ary_push(ary, ID2SYM(value));
15932     return ST_CONTINUE;
15933 }
15934 
15935 /*
15936  *  call-seq:
15937  *     Symbol.all_symbols    => array
15938  *
15939  *  Returns an array of all the symbols currently in Ruby's symbol
15940  *  table.
15941  *
15942  *     Symbol.all_symbols.size    #=> 903
15943  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
15944  *                                     :chown, :EOFError, :$;, :String,
15945  *                                     :LOCK_SH, :"setuid?", :$<,
15946  *                                     :default_proc, :compact, :extend,
15947  *                                     :Tms, :getwd, :$=, :ThreadGroup,
15948  *                                     :wait2, :$>]
15949  */
15950 
15951 VALUE
15952 rb_sym_all_symbols(void)
15953 {
15954     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
15955 
15956     st_foreach(global_symbols.sym_id, symbols_i, ary);
15957     return ary;
15958 }
15959 
15960 int
15961 rb_is_const_id(ID id)
15962 {
15963     return is_const_id(id);
15964 }
15965 
15966 int
15967 rb_is_class_id(ID id)
15968 {
15969     return is_class_id(id);
15970 }
15971 
15972 int
15973 rb_is_instance_id(ID id)
15974 {
15975     return is_instance_id(id);
15976 }
15977 
15978 int
15979 rb_is_local_id(ID id)
15980 {
15981     return is_local_id(id);
15982 }
15983 
15984 int
15985 rb_is_junk_id(ID id)
15986 {
15987     return is_junk_id(id);
15988 }
15989 
15990 #endif /* !RIPPER */
15991 
15992 static void
15993 parser_initialize(struct parser_params *parser)
15994 {
15995     parser->eofp = Qfalse;
15996 
15997     parser->parser_lex_strterm = 0;
15998     parser->parser_cond_stack = 0;
15999     parser->parser_cmdarg_stack = 0;
16000     parser->parser_class_nest = 0;
16001     parser->parser_paren_nest = 0;
16002     parser->parser_lpar_beg = 0;
16003     parser->parser_in_single = 0;
16004     parser->parser_in_def = 0;
16005     parser->parser_in_defined = 0;
16006     parser->parser_compile_for_eval = 0;
16007     parser->parser_cur_mid = 0;
16008     parser->parser_tokenbuf = NULL;
16009     parser->parser_tokidx = 0;
16010     parser->parser_toksiz = 0;
16011     parser->parser_heredoc_end = 0;
16012     parser->parser_command_start = TRUE;
16013     parser->parser_deferred_nodes = 0;
16014     parser->parser_lex_pbeg = 0;
16015     parser->parser_lex_p = 0;
16016     parser->parser_lex_pend = 0;
16017     parser->parser_lvtbl = 0;
16018     parser->parser_ruby__end__seen = 0;
16019     parser->parser_ruby_sourcefile = 0;
16020 #ifndef RIPPER
16021     parser->is_ripper = 0;
16022     parser->parser_eval_tree_begin = 0;
16023     parser->parser_eval_tree = 0;
16024 #else
16025     parser->is_ripper = 1;
16026     parser->parser_ruby_sourcefile_string = Qnil;
16027     parser->delayed = Qnil;
16028 
16029     parser->result = Qnil;
16030     parser->parsing_thread = Qnil;
16031     parser->toplevel_p = TRUE;
16032 #endif
16033 #ifdef YYMALLOC
16034     parser->heap = NULL;
16035 #endif
16036     parser->enc = rb_usascii_encoding();
16037 }
16038 
16039 #ifdef RIPPER
16040 #define parser_mark ripper_parser_mark
16041 #define parser_free ripper_parser_free
16042 #endif
16043 
16044 static void
16045 parser_mark(void *ptr)
16046 {
16047     struct parser_params *p = (struct parser_params*)ptr;
16048 
16049     rb_gc_mark((VALUE)p->parser_lex_strterm);
16050     rb_gc_mark((VALUE)p->parser_deferred_nodes);
16051     rb_gc_mark(p->parser_lex_input);
16052     rb_gc_mark(p->parser_lex_lastline);
16053     rb_gc_mark(p->parser_lex_nextline);
16054 #ifndef RIPPER
16055     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
16056     rb_gc_mark((VALUE)p->parser_eval_tree) ;
16057     rb_gc_mark(p->debug_lines);
16058 #else
16059     rb_gc_mark(p->parser_ruby_sourcefile_string);
16060     rb_gc_mark(p->delayed);
16061     rb_gc_mark(p->value);
16062     rb_gc_mark(p->result);
16063     rb_gc_mark(p->parsing_thread);
16064 #endif
16065 #ifdef YYMALLOC
16066     rb_gc_mark((VALUE)p->heap);
16067 #endif
16068 }
16069 
16070 static void
16071 parser_free(void *ptr)
16072 {
16073     struct parser_params *p = (struct parser_params*)ptr;
16074     struct local_vars *local, *prev;
16075 
16076     if (p->parser_tokenbuf) {
16077         xfree(p->parser_tokenbuf);
16078     }
16079     for (local = p->parser_lvtbl; local; local = prev) {
16080         if (local->vars) xfree(local->vars);
16081         prev = local->prev;
16082         xfree(local);
16083     }
16084 #ifndef RIPPER
16085     xfree(p->parser_ruby_sourcefile);
16086 #endif
16087     xfree(p);
16088 }
16089 
16090 static size_t
16091 parser_memsize(const void *ptr)
16092 {
16093     struct parser_params *p = (struct parser_params*)ptr;
16094     struct local_vars *local;
16095     size_t size = sizeof(*p);
16096 
16097     if (!ptr) return 0;
16098     size += p->parser_toksiz;
16099     for (local = p->parser_lvtbl; local; local = local->prev) {
16100         size += sizeof(*local);
16101         if (local->vars) size += local->vars->capa * sizeof(ID);
16102     }
16103 #ifndef RIPPER
16104     if (p->parser_ruby_sourcefile) {
16105         size += strlen(p->parser_ruby_sourcefile) + 1;
16106     }
16107 #endif
16108     return size;
16109 }
16110 
16111 static
16112 #ifndef RIPPER
16113 const
16114 #endif
16115 rb_data_type_t parser_data_type = {
16116     "parser",
16117     {
16118         parser_mark,
16119         parser_free,
16120         parser_memsize,
16121     },
16122 };
16123 
16124 #ifndef RIPPER
16125 #undef rb_reserved_word
16126 
16127 const struct kwtable *
16128 rb_reserved_word(const char *str, unsigned int len)
16129 {
16130     return reserved_word(str, len);
16131 }
16132 
16133 static struct parser_params *
16134 parser_new(void)
16135 {
16136     struct parser_params *p;
16137 
16138     p = ALLOC_N(struct parser_params, 1);
16139     MEMZERO(p, struct parser_params, 1);
16140     parser_initialize(p);
16141     return p;
16142 }
16143 
16144 VALUE
16145 rb_parser_new(void)
16146 {
16147     struct parser_params *p = parser_new();
16148 
16149     return TypedData_Wrap_Struct(0, &parser_data_type, p);
16150 }
16151 
16152 /*
16153  *  call-seq:
16154  *    ripper#end_seen?   -> Boolean
16155  *
16156  *  Return true if parsed source ended by +\_\_END\_\_+.
16157  */
16158 VALUE
16159 rb_parser_end_seen_p(VALUE vparser)
16160 {
16161     struct parser_params *parser;
16162 
16163     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16164     return ruby__end__seen ? Qtrue : Qfalse;
16165 }
16166 
16167 /*
16168  *  call-seq:
16169  *    ripper#encoding   -> encoding
16170  *
16171  *  Return encoding of the source.
16172  */
16173 VALUE
16174 rb_parser_encoding(VALUE vparser)
16175 {
16176     struct parser_params *parser;
16177 
16178     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16179     return rb_enc_from_encoding(parser->enc);
16180 }
16181 
16182 /*
16183  *  call-seq:
16184  *    ripper.yydebug   -> true or false
16185  *
16186  *  Get yydebug.
16187  */
16188 VALUE
16189 rb_parser_get_yydebug(VALUE self)
16190 {
16191     struct parser_params *parser;
16192 
16193     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16194     return yydebug ? Qtrue : Qfalse;
16195 }
16196 
16197 /*
16198  *  call-seq:
16199  *    ripper.yydebug = flag
16200  *
16201  *  Set yydebug.
16202  */
16203 VALUE
16204 rb_parser_set_yydebug(VALUE self, VALUE flag)
16205 {
16206     struct parser_params *parser;
16207 
16208     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16209     yydebug = RTEST(flag);
16210     return flag;
16211 }
16212 
16213 #ifdef YYMALLOC
16214 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16215 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16216 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16217                            (n)->u3.cnt = (c), (p))
16218 
16219 void *
16220 rb_parser_malloc(struct parser_params *parser, size_t size)
16221 {
16222     size_t cnt = HEAPCNT(1, size);
16223     NODE *n = NEWHEAP();
16224     void *ptr = xmalloc(size);
16225 
16226     return ADD2HEAP(n, cnt, ptr);
16227 }
16228 
16229 void *
16230 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16231 {
16232     size_t cnt = HEAPCNT(nelem, size);
16233     NODE *n = NEWHEAP();
16234     void *ptr = xcalloc(nelem, size);
16235 
16236     return ADD2HEAP(n, cnt, ptr);
16237 }
16238 
16239 void *
16240 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16241 {
16242     NODE *n;
16243     size_t cnt = HEAPCNT(1, size);
16244 
16245     if (ptr && (n = parser->heap) != NULL) {
16246         do {
16247             if (n->u1.node == ptr) {
16248                 n->u1.node = ptr = xrealloc(ptr, size);
16249                 if (n->u3.cnt) n->u3.cnt = cnt;
16250                 return ptr;
16251             }
16252         } while ((n = n->u2.node) != NULL);
16253     }
16254     n = NEWHEAP();
16255     ptr = xrealloc(ptr, size);
16256     return ADD2HEAP(n, cnt, ptr);
16257 }
16258 
16259 void
16260 rb_parser_free(struct parser_params *parser, void *ptr)
16261 {
16262     NODE **prev = &parser->heap, *n;
16263 
16264     while ((n = *prev) != NULL) {
16265         if (n->u1.node == ptr) {
16266             *prev = n->u2.node;
16267             rb_gc_force_recycle((VALUE)n);
16268             break;
16269         }
16270         prev = &n->u2.node;
16271     }
16272     xfree(ptr);
16273 }
16274 #endif
16275 #endif
16276 
16277 #ifdef RIPPER
16278 #ifdef RIPPER_DEBUG
16279 extern int rb_is_pointer_to_heap(VALUE);
16280 
16281 /* :nodoc: */
16282 static VALUE
16283 ripper_validate_object(VALUE self, VALUE x)
16284 {
16285     if (x == Qfalse) return x;
16286     if (x == Qtrue) return x;
16287     if (x == Qnil) return x;
16288     if (x == Qundef)
16289         rb_raise(rb_eArgError, "Qundef given");
16290     if (FIXNUM_P(x)) return x;
16291     if (SYMBOL_P(x)) return x;
16292     if (!rb_is_pointer_to_heap(x))
16293         rb_raise(rb_eArgError, "invalid pointer: %p", x);
16294     switch (TYPE(x)) {
16295       case T_STRING:
16296       case T_OBJECT:
16297       case T_ARRAY:
16298       case T_BIGNUM:
16299       case T_FLOAT:
16300         return x;
16301       case T_NODE:
16302         if (nd_type(x) != NODE_LASGN) {
16303             rb_raise(rb_eArgError, "NODE given: %p", x);
16304         }
16305         return ((NODE *)x)->nd_rval;
16306       default:
16307         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16308                  x, rb_obj_classname(x));
16309     }
16310     return x;
16311 }
16312 #endif
16313 
16314 #define validate(x) ((x) = get_value(x))
16315 
16316 static VALUE
16317 ripper_dispatch0(struct parser_params *parser, ID mid)
16318 {
16319     return rb_funcall(parser->value, mid, 0);
16320 }
16321 
16322 static VALUE
16323 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16324 {
16325     validate(a);
16326     return rb_funcall(parser->value, mid, 1, a);
16327 }
16328 
16329 static VALUE
16330 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16331 {
16332     validate(a);
16333     validate(b);
16334     return rb_funcall(parser->value, mid, 2, a, b);
16335 }
16336 
16337 static VALUE
16338 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16339 {
16340     validate(a);
16341     validate(b);
16342     validate(c);
16343     return rb_funcall(parser->value, mid, 3, a, b, c);
16344 }
16345 
16346 static VALUE
16347 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16348 {
16349     validate(a);
16350     validate(b);
16351     validate(c);
16352     validate(d);
16353     return rb_funcall(parser->value, mid, 4, a, b, c, d);
16354 }
16355 
16356 static VALUE
16357 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16358 {
16359     validate(a);
16360     validate(b);
16361     validate(c);
16362     validate(d);
16363     validate(e);
16364     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16365 }
16366 
16367 static const struct kw_assoc {
16368     ID id;
16369     const char *name;
16370 } keyword_to_name[] = {
16371     {keyword_class,     "class"},
16372     {keyword_module,    "module"},
16373     {keyword_def,       "def"},
16374     {keyword_undef,     "undef"},
16375     {keyword_begin,     "begin"},
16376     {keyword_rescue,    "rescue"},
16377     {keyword_ensure,    "ensure"},
16378     {keyword_end,       "end"},
16379     {keyword_if,        "if"},
16380     {keyword_unless,    "unless"},
16381     {keyword_then,      "then"},
16382     {keyword_elsif,     "elsif"},
16383     {keyword_else,      "else"},
16384     {keyword_case,      "case"},
16385     {keyword_when,      "when"},
16386     {keyword_while,     "while"},
16387     {keyword_until,     "until"},
16388     {keyword_for,       "for"},
16389     {keyword_break,     "break"},
16390     {keyword_next,      "next"},
16391     {keyword_redo,      "redo"},
16392     {keyword_retry,     "retry"},
16393     {keyword_in,        "in"},
16394     {keyword_do,        "do"},
16395     {keyword_do_cond,   "do"},
16396     {keyword_do_block,  "do"},
16397     {keyword_return,    "return"},
16398     {keyword_yield,     "yield"},
16399     {keyword_super,     "super"},
16400     {keyword_self,      "self"},
16401     {keyword_nil,       "nil"},
16402     {keyword_true,      "true"},
16403     {keyword_false,     "false"},
16404     {keyword_and,       "and"},
16405     {keyword_or,        "or"},
16406     {keyword_not,       "not"},
16407     {modifier_if,       "if"},
16408     {modifier_unless,   "unless"},
16409     {modifier_while,    "while"},
16410     {modifier_until,    "until"},
16411     {modifier_rescue,   "rescue"},
16412     {keyword_alias,     "alias"},
16413     {keyword_defined,   "defined?"},
16414     {keyword_BEGIN,     "BEGIN"},
16415     {keyword_END,       "END"},
16416     {keyword__LINE__,   "__LINE__"},
16417     {keyword__FILE__,   "__FILE__"},
16418     {keyword__ENCODING__, "__ENCODING__"},
16419     {0, NULL}
16420 };
16421 
16422 static const char*
16423 keyword_id_to_str(ID id)
16424 {
16425     const struct kw_assoc *a;
16426 
16427     for (a = keyword_to_name; a->id; a++) {
16428         if (a->id == id)
16429             return a->name;
16430     }
16431     return NULL;
16432 }
16433 
16434 #undef ripper_id2sym
16435 static VALUE
16436 ripper_id2sym(ID id)
16437 {
16438     const char *name;
16439     char buf[8];
16440 
16441     if (id <= 256) {
16442         buf[0] = (char)id;
16443         buf[1] = '\0';
16444         return ID2SYM(rb_intern2(buf, 1));
16445     }
16446     if ((name = keyword_id_to_str(id))) {
16447         return ID2SYM(rb_intern(name));
16448     }
16449     switch (id) {
16450       case tOROP:
16451         name = "||";
16452         break;
16453       case tANDOP:
16454         name = "&&";
16455         break;
16456       default:
16457         name = rb_id2name(id);
16458         if (!name) {
16459             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16460         }
16461         return ID2SYM(id);
16462     }
16463     return ID2SYM(rb_intern(name));
16464 }
16465 
16466 static ID
16467 ripper_get_id(VALUE v)
16468 {
16469     NODE *nd;
16470     if (!RB_TYPE_P(v, T_NODE)) return 0;
16471     nd = (NODE *)v;
16472     if (nd_type(nd) != NODE_LASGN) return 0;
16473     return nd->nd_vid;
16474 }
16475 
16476 static VALUE
16477 ripper_get_value(VALUE v)
16478 {
16479     NODE *nd;
16480     if (v == Qundef) return Qnil;
16481     if (!RB_TYPE_P(v, T_NODE)) return v;
16482     nd = (NODE *)v;
16483     if (nd_type(nd) != NODE_LASGN) return Qnil;
16484     return nd->nd_rval;
16485 }
16486 
16487 static void
16488 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16489 {
16490     VALUE str;
16491     va_list args;
16492 
16493     va_start(args, fmt);
16494     str = rb_vsprintf(fmt, args);
16495     va_end(args);
16496     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16497 }
16498 
16499 static void
16500 ripper_warn0(struct parser_params *parser, const char *fmt)
16501 {
16502     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16503 }
16504 
16505 static void
16506 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16507 {
16508     rb_funcall(parser->value, rb_intern("warn"), 2,
16509                STR_NEW2(fmt), INT2NUM(a));
16510 }
16511 
16512 #if 0
16513 static void
16514 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16515 {
16516     rb_funcall(parser->value, rb_intern("warn"), 2,
16517                STR_NEW2(fmt), STR_NEW2(str));
16518 }
16519 #endif
16520 
16521 static void
16522 ripper_warning0(struct parser_params *parser, const char *fmt)
16523 {
16524     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16525 }
16526 
16527 static void
16528 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16529 {
16530     rb_funcall(parser->value, rb_intern("warning"), 2,
16531                STR_NEW2(fmt), STR_NEW2(str));
16532 }
16533 
16534 static VALUE
16535 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16536 {
16537     return rb_funcall(src, ripper_id_gets, 0);
16538 }
16539 
16540 static VALUE
16541 ripper_s_allocate(VALUE klass)
16542 {
16543     struct parser_params *p;
16544     VALUE self;
16545 
16546     p = ALLOC_N(struct parser_params, 1);
16547     MEMZERO(p, struct parser_params, 1);
16548     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16549     p->value = self;
16550     return self;
16551 }
16552 
16553 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16554 
16555 /*
16556  *  call-seq:
16557  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
16558  *
16559  *  Create a new Ripper object.
16560  *  _src_ must be a String, an IO, or an Object which has #gets method.
16561  *
16562  *  This method does not starts parsing.
16563  *  See also Ripper#parse and Ripper.parse.
16564  */
16565 static VALUE
16566 ripper_initialize(int argc, VALUE *argv, VALUE self)
16567 {
16568     struct parser_params *parser;
16569     VALUE src, fname, lineno;
16570 
16571     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16572     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
16573     if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
16574         parser->parser_lex_gets = ripper_lex_get_generic;
16575     }
16576     else {
16577         StringValue(src);
16578         parser->parser_lex_gets = lex_get_str;
16579     }
16580     parser->parser_lex_input = src;
16581     parser->eofp = Qfalse;
16582     if (NIL_P(fname)) {
16583         fname = STR_NEW2("(ripper)");
16584     }
16585     else {
16586         StringValue(fname);
16587     }
16588     parser_initialize(parser);
16589 
16590     parser->parser_ruby_sourcefile_string = fname;
16591     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
16592     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
16593 
16594     return Qnil;
16595 }
16596 
16597 struct ripper_args {
16598     struct parser_params *parser;
16599     int argc;
16600     VALUE *argv;
16601 };
16602 
16603 static VALUE
16604 ripper_parse0(VALUE parser_v)
16605 {
16606     struct parser_params *parser;
16607 
16608     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16609     parser_prepare(parser);
16610     ripper_yyparse((void*)parser);
16611     return parser->result;
16612 }
16613 
16614 static VALUE
16615 ripper_ensure(VALUE parser_v)
16616 {
16617     struct parser_params *parser;
16618 
16619     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16620     parser->parsing_thread = Qnil;
16621     return Qnil;
16622 }
16623 
16624 /*
16625  *  call-seq:
16626  *    ripper#parse
16627  *
16628  *  Start parsing and returns the value of the root action.
16629  */
16630 static VALUE
16631 ripper_parse(VALUE self)
16632 {
16633     struct parser_params *parser;
16634 
16635     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16636     if (!ripper_initialized_p(parser)) {
16637         rb_raise(rb_eArgError, "method called for uninitialized object");
16638     }
16639     if (!NIL_P(parser->parsing_thread)) {
16640         if (parser->parsing_thread == rb_thread_current())
16641             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
16642         else
16643             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
16644     }
16645     parser->parsing_thread = rb_thread_current();
16646     rb_ensure(ripper_parse0, self, ripper_ensure, self);
16647 
16648     return parser->result;
16649 }
16650 
16651 /*
16652  *  call-seq:
16653  *    ripper#column   -> Integer
16654  *
16655  *  Return column number of current parsing line.
16656  *  This number starts from 0.
16657  */
16658 static VALUE
16659 ripper_column(VALUE self)
16660 {
16661     struct parser_params *parser;
16662     long col;
16663 
16664     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16665     if (!ripper_initialized_p(parser)) {
16666         rb_raise(rb_eArgError, "method called for uninitialized object");
16667     }
16668     if (NIL_P(parser->parsing_thread)) return Qnil;
16669     col = parser->tokp - parser->parser_lex_pbeg;
16670     return LONG2NUM(col);
16671 }
16672 
16673 /*
16674  *  call-seq:
16675  *    ripper#filename   -> String
16676  *
16677  *  Return current parsing filename.
16678  */
16679 static VALUE
16680 ripper_filename(VALUE self)
16681 {
16682     struct parser_params *parser;
16683 
16684     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16685     if (!ripper_initialized_p(parser)) {
16686         rb_raise(rb_eArgError, "method called for uninitialized object");
16687     }
16688     return parser->parser_ruby_sourcefile_string;
16689 }
16690 
16691 /*
16692  *  call-seq:
16693  *    ripper#lineno   -> Integer
16694  *
16695  *  Return line number of current parsing line.
16696  *  This number starts from 1.
16697  */
16698 static VALUE
16699 ripper_lineno(VALUE self)
16700 {
16701     struct parser_params *parser;
16702 
16703     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16704     if (!ripper_initialized_p(parser)) {
16705         rb_raise(rb_eArgError, "method called for uninitialized object");
16706     }
16707     if (NIL_P(parser->parsing_thread)) return Qnil;
16708     return INT2NUM(parser->parser_ruby_sourceline);
16709 }
16710 
16711 #ifdef RIPPER_DEBUG
16712 /* :nodoc: */
16713 static VALUE
16714 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
16715 {
16716     StringValue(msg);
16717     if (obj == Qundef) {
16718         rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
16719     }
16720     return Qnil;
16721 }
16722 
16723 /* :nodoc: */
16724 static VALUE
16725 ripper_value(VALUE self, VALUE obj)
16726 {
16727     return ULONG2NUM(obj);
16728 }
16729 #endif
16730 
16731 
16732 void
16733 InitVM_ripper(void)
16734 {
16735     parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
16736 }
16737 
16738 void
16739 Init_ripper(void)
16740 {
16741     VALUE Ripper;
16742 
16743     InitVM(ripper);
16744     Ripper = rb_define_class("Ripper", rb_cObject);
16745     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
16746     rb_define_alloc_func(Ripper, ripper_s_allocate);
16747     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
16748     rb_define_method(Ripper, "parse", ripper_parse, 0);
16749     rb_define_method(Ripper, "column", ripper_column, 0);
16750     rb_define_method(Ripper, "filename", ripper_filename, 0);
16751     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
16752     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
16753     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
16754     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
16755     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
16756 #ifdef RIPPER_DEBUG
16757     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
16758     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
16759     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
16760 #endif
16761 
16762     ripper_id_gets = rb_intern("gets");
16763     ripper_init_eventids1(Ripper);
16764     ripper_init_eventids2(Ripper);
16765     /* ensure existing in symbol table */
16766     (void)rb_intern("||");
16767     (void)rb_intern("&&");
16768 
16769 # if 0
16770     /* Hack to let RDoc document SCRIPT_LINES__ */
16771 
16772     /*
16773      * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
16774      * after the assignment will be added as an Array of lines with the file
16775      * name as the key.
16776      */
16777     rb_define_global_const("SCRIPT_LINES__", Qnil);
16778 #endif
16779 
16780 }
16781 #endif /* RIPPER */
16782