• Main Page
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

ext/ripper/ripper.c

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.4.3.  */
00002 
00003 /* Skeleton implementation for Bison's Yacc-like parsers in C
00004    
00005       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
00006    2009, 2010 Free Software Foundation, Inc.
00007    
00008    This program is free software: you can redistribute it and/or modify
00009    it under the terms of the GNU General Public License as published by
00010    the Free Software Foundation, either version 3 of the License, or
00011    (at your option) any later version.
00012    
00013    This program is distributed in the hope that it will be useful,
00014    but WITHOUT ANY WARRANTY; without even the implied warranty of
00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016    GNU General Public License for more details.
00017    
00018    You should have received a copy of the GNU General Public License
00019    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00020 
00021 /* As a special exception, you may create a larger work that contains
00022    part or all of the Bison parser skeleton and distribute that work
00023    under terms of your choice, so long as that work isn't itself a
00024    parser generator using the skeleton or a modified version thereof
00025    as a parser skeleton.  Alternatively, if you modify or redistribute
00026    the parser skeleton itself, you may (at your option) remove this
00027    special exception, which will cause the skeleton and the resulting
00028    Bison output files to be licensed under the GNU General Public
00029    License without this special exception.
00030    
00031    This special exception was added by the Free Software Foundation in
00032    version 2.2 of Bison.  */
00033 
00034 /* C LALR(1) parser skeleton written by Richard Stallman, by
00035    simplifying the original so-called "semantic" parser.  */
00036 
00037 /* All symbols defined below should begin with yy or YY, to avoid
00038    infringing on user name space.  This should be done even for local
00039    variables, as they might otherwise be expanded by user macros.
00040    There are some unavoidable exceptions within include files to
00041    define necessary library symbols; they are noted "INFRINGES ON
00042    USER NAME SPACE" below.  */
00043 
00044 /* Identify Bison output.  */
00045 #define YYBISON 1
00046 
00047 /* Bison version.  */
00048 #define YYBISON_VERSION "2.4.3"
00049 
00050 /* Skeleton name.  */
00051 #define YYSKELETON_NAME "yacc.c"
00052 
00053 /* Pure parsers.  */
00054 #define YYPURE 1
00055 
00056 /* Push parsers.  */
00057 #define YYPUSH 0
00058 
00059 /* Pull parsers.  */
00060 #define YYPULL 1
00061 
00062 /* Using locations.  */
00063 #define YYLSP_NEEDED 0
00064 
00065 
00066 
00067 /* Copy the first part of user declarations.  */
00068 
00069 /* Line 189 of yacc.c  */
00070 #line 12 "ripper.y"
00071 
00072 
00073 #define YYDEBUG 1
00074 #define YYERROR_VERBOSE 1
00075 #define YYSTACK_USE_ALLOCA 0
00076 
00077 #include "ruby/ruby.h"
00078 #include "ruby/st.h"
00079 #include "ruby/encoding.h"
00080 #include "node.h"
00081 #include "parse.h"
00082 #include "id.h"
00083 #include "regenc.h"
00084 #include <stdio.h>
00085 #include <errno.h>
00086 #include <ctype.h>
00087 
00088 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
00089 
00090 #define YYMALLOC(size)          rb_parser_malloc(parser, size)
00091 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, ptr, size)
00092 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, nelem, size)
00093 #define YYFREE(ptr)             rb_parser_free(parser, ptr)
00094 #define malloc  YYMALLOC
00095 #define realloc YYREALLOC
00096 #define calloc  YYCALLOC
00097 #define free    YYFREE
00098 
00099 #ifndef RIPPER
00100 static ID register_symid(ID, const char *, long, rb_encoding *);
00101 #define REGISTER_SYMID(id, name) register_symid(id, name, strlen(name), enc)
00102 #include "id.c"
00103 #endif
00104 
00105 #define is_notop_id(id) ((id)>tLAST_TOKEN)
00106 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00107 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00108 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00109 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00110 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00111 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00112 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00113 
00114 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00115         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00116          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00117          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00118 
00119 enum lex_state_e {
00120     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
00121     EXPR_END,                   /* newline significant, +/- is an operator. */
00122     EXPR_ENDARG,                /* ditto, and unbound braces. */
00123     EXPR_ENDFN,                 /* ditto, and unbound braces. */
00124     EXPR_ARG,                   /* newline significant, +/- is an operator. */
00125     EXPR_CMDARG,                /* newline significant, +/- is an operator. */
00126     EXPR_MID,                   /* newline significant, +/- is an operator. */
00127     EXPR_FNAME,                 /* ignore newline, no reserved words. */
00128     EXPR_DOT,                   /* right after `.' or `::', no reserved words. */
00129     EXPR_CLASS,                 /* immediate after `class', no here document. */
00130     EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
00131     EXPR_MAX_STATE
00132 };
00133 
00134 typedef VALUE stack_type;
00135 
00136 # define BITSTACK_PUSH(stack, n)        (stack = (stack<<1)|((n)&1))
00137 # define BITSTACK_POP(stack)    (stack = stack >> 1)
00138 # define BITSTACK_LEXPOP(stack) (stack = (stack >> 1) | (stack & 1))
00139 # define BITSTACK_SET_P(stack)  (stack&1)
00140 
00141 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, n)
00142 #define COND_POP()      BITSTACK_POP(cond_stack)
00143 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00144 #define COND_P()        BITSTACK_SET_P(cond_stack)
00145 
00146 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, n)
00147 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00148 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00149 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00150 
00151 struct vtable {
00152     ID *tbl;
00153     int pos;
00154     int capa;
00155     struct vtable *prev;
00156 };
00157 
00158 struct local_vars {
00159     struct vtable *args;
00160     struct vtable *vars;
00161     struct local_vars *prev;
00162 };
00163 
00164 #define DVARS_INHERIT ((void*)1)
00165 #define DVARS_TOPSCOPE NULL
00166 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00167 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00168 
00169 static int
00170 vtable_size(const struct vtable *tbl)
00171 {
00172     if (POINTER_P(tbl)) {
00173         return tbl->pos;
00174     }
00175     else {
00176         return 0;
00177     }
00178 }
00179 
00180 #define VTBL_DEBUG 0
00181 
00182 static struct vtable *
00183 vtable_alloc(struct vtable *prev)
00184 {
00185     struct vtable *tbl = ALLOC(struct vtable);
00186     tbl->pos = 0;
00187     tbl->capa = 8;
00188     tbl->tbl = ALLOC_N(ID, tbl->capa);
00189     tbl->prev = prev;
00190     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00191     return tbl;
00192 }
00193 
00194 static void
00195 vtable_free(struct vtable *tbl)
00196 {
00197     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00198     if (POINTER_P(tbl)) {
00199         if (tbl->tbl) {
00200             xfree(tbl->tbl);
00201         }
00202         xfree(tbl);
00203     }
00204 }
00205 
00206 static void
00207 vtable_add(struct vtable *tbl, ID id)
00208 {
00209     if (!POINTER_P(tbl)) {
00210         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00211     }
00212     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00213 
00214     if (tbl->pos == tbl->capa) {
00215         tbl->capa = tbl->capa * 2;
00216         REALLOC_N(tbl->tbl, ID, tbl->capa);
00217     }
00218     tbl->tbl[tbl->pos++] = id;
00219 }
00220 
00221 static int
00222 vtable_included(const struct vtable * tbl, ID id)
00223 {
00224     int i;
00225 
00226     if (POINTER_P(tbl)) {
00227         for (i = 0; i < tbl->pos; i++) {
00228             if (tbl->tbl[i] == id) {
00229                 return 1;
00230             }
00231         }
00232     }
00233     return 0;
00234 }
00235 
00236 
00237 #ifndef RIPPER
00238 typedef struct token_info {
00239     const char *token;
00240     int linenum;
00241     int column;
00242     int nonspc;
00243     struct token_info *next;
00244 } token_info;
00245 #endif
00246 
00247 /*
00248     Structure of Lexer Buffer:
00249 
00250  lex_pbeg      tokp         lex_p        lex_pend
00251     |           |              |            |
00252     |-----------+--------------+------------|
00253                 |<------------>|
00254                      token
00255 */
00256 struct parser_params {
00257     int is_ripper;
00258     NODE *heap;
00259 
00260     YYSTYPE *parser_yylval;
00261     VALUE eofp;
00262 
00263     NODE *parser_lex_strterm;
00264     enum lex_state_e parser_lex_state;
00265     stack_type parser_cond_stack;
00266     stack_type parser_cmdarg_stack;
00267     int parser_class_nest;
00268     int parser_paren_nest;
00269     int parser_lpar_beg;
00270     int parser_in_single;
00271     int parser_in_def;
00272     int parser_compile_for_eval;
00273     VALUE parser_cur_mid;
00274     int parser_in_defined;
00275     char *parser_tokenbuf;
00276     int parser_tokidx;
00277     int parser_toksiz;
00278     VALUE parser_lex_input;
00279     VALUE parser_lex_lastline;
00280     VALUE parser_lex_nextline;
00281     const char *parser_lex_pbeg;
00282     const char *parser_lex_p;
00283     const char *parser_lex_pend;
00284     int parser_heredoc_end;
00285     int parser_command_start;
00286     NODE *parser_deferred_nodes;
00287     long parser_lex_gets_ptr;
00288     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00289     struct local_vars *parser_lvtbl;
00290     int parser_ruby__end__seen;
00291     int line_count;
00292     int has_shebang;
00293     char *parser_ruby_sourcefile; /* current source file */
00294     int parser_ruby_sourceline; /* current line no. */
00295     rb_encoding *enc;
00296     rb_encoding *utf8;
00297 
00298     int parser_yydebug;
00299 
00300 #ifndef RIPPER
00301     /* Ruby core only */
00302     NODE *parser_eval_tree_begin;
00303     NODE *parser_eval_tree;
00304     VALUE debug_lines;
00305     VALUE coverage;
00306     int nerr;
00307 
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 #ifdef YYMALLOC
00334 void *rb_parser_malloc(struct parser_params *, size_t);
00335 void *rb_parser_realloc(struct parser_params *, void *, size_t);
00336 void *rb_parser_calloc(struct parser_params *, size_t, size_t);
00337 void rb_parser_free(struct parser_params *, void *);
00338 #endif
00339 
00340 static int parser_yyerror(struct parser_params*, const char*);
00341 #define yyerror(msg) parser_yyerror(parser, msg)
00342 
00343 #define YYLEX_PARAM parser
00344 
00345 #define lex_strterm             (parser->parser_lex_strterm)
00346 #define lex_state               (parser->parser_lex_state)
00347 #define cond_stack              (parser->parser_cond_stack)
00348 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00349 #define class_nest              (parser->parser_class_nest)
00350 #define paren_nest              (parser->parser_paren_nest)
00351 #define lpar_beg                (parser->parser_lpar_beg)
00352 #define in_single               (parser->parser_in_single)
00353 #define in_def                  (parser->parser_in_def)
00354 #define compile_for_eval        (parser->parser_compile_for_eval)
00355 #define cur_mid                 (parser->parser_cur_mid)
00356 #define in_defined              (parser->parser_in_defined)
00357 #define tokenbuf                (parser->parser_tokenbuf)
00358 #define tokidx                  (parser->parser_tokidx)
00359 #define toksiz                  (parser->parser_toksiz)
00360 #define lex_input               (parser->parser_lex_input)
00361 #define lex_lastline            (parser->parser_lex_lastline)
00362 #define lex_nextline            (parser->parser_lex_nextline)
00363 #define lex_pbeg                (parser->parser_lex_pbeg)
00364 #define lex_p                   (parser->parser_lex_p)
00365 #define lex_pend                (parser->parser_lex_pend)
00366 #define heredoc_end             (parser->parser_heredoc_end)
00367 #define command_start           (parser->parser_command_start)
00368 #define deferred_nodes          (parser->parser_deferred_nodes)
00369 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00370 #define lex_gets                (parser->parser_lex_gets)
00371 #define lvtbl                   (parser->parser_lvtbl)
00372 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00373 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00374 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00375 #define yydebug                 (parser->parser_yydebug)
00376 #ifdef RIPPER
00377 #else
00378 #define ruby_eval_tree          (parser->parser_eval_tree)
00379 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00380 #define ruby_debug_lines        (parser->debug_lines)
00381 #define ruby_coverage           (parser->coverage)
00382 #endif
00383 
00384 static int yylex(void*, void*);
00385 
00386 #ifndef RIPPER
00387 #define yyparse ruby_yyparse
00388 
00389 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00390 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, type, a1, a2, a3)
00391 
00392 static NODE *cond_gen(struct parser_params*,NODE*);
00393 #define cond(node) cond_gen(parser, node)
00394 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00395 #define logop(type,node1,node2) logop_gen(parser, type, node1, node2)
00396 
00397 static NODE *newline_node(NODE*);
00398 static void fixpos(NODE*,NODE*);
00399 
00400 static int value_expr_gen(struct parser_params*,NODE*);
00401 static void void_expr_gen(struct parser_params*,NODE*);
00402 static NODE *remove_begin(NODE*);
00403 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00404 #define void_expr0(node) void_expr_gen(parser, (node))
00405 #define void_expr(node) void_expr0((node) = remove_begin(node))
00406 static void void_stmts_gen(struct parser_params*,NODE*);
00407 #define void_stmts(node) void_stmts_gen(parser, node)
00408 static void reduce_nodes_gen(struct parser_params*,NODE**);
00409 #define reduce_nodes(n) reduce_nodes_gen(parser,n)
00410 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00411 #define block_dup_check(n1,n2) block_dup_check_gen(parser,n1,n2)
00412 
00413 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00414 #define block_append(h,t) block_append_gen(parser,h,t)
00415 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00416 #define list_append(l,i) list_append_gen(parser,l,i)
00417 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00418 #define list_concat(h,t) list_concat_gen(parser,h,t)
00419 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00420 #define arg_append(h,t) arg_append_gen(parser,h,t)
00421 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00422 #define arg_concat(h,t) arg_concat_gen(parser,h,t)
00423 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00424 #define literal_concat(h,t) literal_concat_gen(parser,h,t)
00425 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00426 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00427 #define new_evstr(n) new_evstr_gen(parser,n)
00428 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00429 #define evstr2dstr(n) evstr2dstr_gen(parser,n)
00430 static NODE *splat_array(NODE*);
00431 
00432 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00433 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, recv,id,arg1)
00434 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00435 #define call_uni_op(recv,id) call_uni_op_gen(parser, recv,id)
00436 
00437 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
00438 #define new_args(f,o,r,p,b) new_args_gen(parser, f,o,r,p,b)
00439 
00440 static NODE *negate_lit(NODE*);
00441 static NODE *ret_args_gen(struct parser_params*,NODE*);
00442 #define ret_args(node) ret_args_gen(parser, node)
00443 static NODE *arg_blk_pass(NODE*,NODE*);
00444 static NODE *new_yield_gen(struct parser_params*,NODE*);
00445 #define new_yield(node) new_yield_gen(parser, node)
00446 
00447 static NODE *gettable_gen(struct parser_params*,ID);
00448 #define gettable(id) gettable_gen(parser,id)
00449 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00450 #define assignable(id,node) assignable_gen(parser, id, node)
00451 
00452 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00453 #define aryset(node1,node2) aryset_gen(parser, node1, node2)
00454 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00455 #define attrset(node,id) attrset_gen(parser, node, id)
00456 
00457 static void rb_backref_error_gen(struct parser_params*,NODE*);
00458 #define rb_backref_error(n) rb_backref_error_gen(parser,n)
00459 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00460 #define node_assign(node1, node2) node_assign_gen(parser, node1, node2)
00461 
00462 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00463 #define match_op(node1,node2) match_op_gen(parser, node1, node2)
00464 
00465 static ID  *local_tbl_gen(struct parser_params*);
00466 #define local_tbl() local_tbl_gen(parser)
00467 
00468 static void fixup_nodes(NODE **);
00469 
00470 extern int rb_dvar_defined(ID);
00471 extern int rb_local_defined(ID);
00472 extern int rb_parse_in_eval(void);
00473 extern int rb_parse_in_main(void);
00474 
00475 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00476 #define reg_compile(str,options) reg_compile_gen(parser, str, options)
00477 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00478 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, str, options)
00479 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00480 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, str, options)
00481 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00482 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,regexp,match)
00483 
00484 #define get_id(id) (id)
00485 #define get_value(val) (val)
00486 #else
00487 #define remove_begin(node) (node)
00488 #define rb_dvar_defined(id) 0
00489 #define rb_local_defined(id) 0
00490 static ID ripper_get_id(VALUE);
00491 #define get_id(id) ripper_get_id(id)
00492 static VALUE ripper_get_value(VALUE);
00493 #define get_value(val) ripper_get_value(val)
00494 static VALUE assignable_gen(struct parser_params*,VALUE);
00495 #define assignable(lhs,node) assignable_gen(parser, lhs)
00496 #endif /* !RIPPER */
00497 
00498 static ID formal_argument_gen(struct parser_params*, ID);
00499 #define formal_argument(id) formal_argument_gen(parser, id)
00500 static ID shadowing_lvar_gen(struct parser_params*,ID);
00501 #define shadowing_lvar(name) shadowing_lvar_gen(parser, name)
00502 static void new_bv_gen(struct parser_params*,ID);
00503 #define new_bv(id) new_bv_gen(parser, id)
00504 
00505 static void local_push_gen(struct parser_params*,int);
00506 #define local_push(top) local_push_gen(parser,top)
00507 static void local_pop_gen(struct parser_params*);
00508 #define local_pop() local_pop_gen(parser)
00509 static int local_var_gen(struct parser_params*, ID);
00510 #define local_var(id) local_var_gen(parser, id);
00511 static int arg_var_gen(struct parser_params*, ID);
00512 #define arg_var(id) arg_var_gen(parser, id)
00513 static int  local_id_gen(struct parser_params*, ID);
00514 #define local_id(id) local_id_gen(parser, id)
00515 static ID   internal_id_gen(struct parser_params*);
00516 #define internal_id() internal_id_gen(parser)
00517 
00518 static const struct vtable *dyna_push_gen(struct parser_params *);
00519 #define dyna_push() dyna_push_gen(parser)
00520 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00521 #define dyna_pop(node) dyna_pop_gen(parser, node)
00522 static int dyna_in_block_gen(struct parser_params*);
00523 #define dyna_in_block() dyna_in_block_gen(parser)
00524 #define dyna_var(id) local_var(id)
00525 static int dvar_defined_gen(struct parser_params*,ID);
00526 #define dvar_defined(id) dvar_defined_gen(parser, id)
00527 static int dvar_curr_gen(struct parser_params*,ID);
00528 #define dvar_curr(id) dvar_curr_gen(parser, id)
00529 
00530 static int lvar_defined_gen(struct parser_params*, ID);
00531 #define lvar_defined(id) lvar_defined_gen(parser, id)
00532 
00533 #define RE_OPTION_ONCE (1<<16)
00534 #define RE_OPTION_ENCODING_SHIFT 8
00535 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00536 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00537 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00538 #define RE_OPTION_MASK  0xff
00539 #define RE_OPTION_ARG_ENCODING_NONE 32
00540 
00541 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00542 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00543 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00544 #define nd_func u1.id
00545 #if SIZEOF_SHORT == 2
00546 #define nd_term(node) ((signed short)(node)->u2.id)
00547 #else
00548 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00549 #endif
00550 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00551 #define nd_nest u3.cnt
00552 
00553 /****** Ripper *******/
00554 
00555 #ifdef RIPPER
00556 #define RIPPER_VERSION "0.1.0"
00557 
00558 #include "eventids1.c"
00559 #include "eventids2.c"
00560 static ID ripper_id_gets;
00561 
00562 static VALUE ripper_dispatch0(struct parser_params*,ID);
00563 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00564 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00565 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00566 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00567 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00568 
00569 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00570 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), a)
00571 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), a, b)
00572 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), a, b, c)
00573 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), a, b, c, d)
00574 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), a, b, c, d, e)
00575 
00576 #define yyparse ripper_yyparse
00577 
00578 #define ripper_intern(s) ID2SYM(rb_intern(s))
00579 static VALUE ripper_id2sym(ID);
00580 #ifdef __GNUC__
00581 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00582                            ID2SYM(id) : ripper_id2sym(id))
00583 #endif
00584 
00585 #define arg_new() dispatch0(args_new)
00586 #define arg_add(l,a) dispatch2(args_add, l, a)
00587 #define arg_add_star(l,a) dispatch2(args_add_star, l, a)
00588 #define arg_add_block(l,b) dispatch2(args_add_block, l, b)
00589 #define arg_add_optblock(l,b) ((b)==Qundef? l : dispatch2(args_add_block, l, b))
00590 #define bare_assoc(v) dispatch1(bare_assoc_hash, v)
00591 #define arg_add_assocs(l,b) arg_add(l, bare_assoc(b))
00592 
00593 #define args2mrhs(a) dispatch1(mrhs_new_from_args, a)
00594 #define mrhs_new() dispatch0(mrhs_new)
00595 #define mrhs_add(l,a) dispatch2(mrhs_add, l, a)
00596 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, l, a)
00597 
00598 #define mlhs_new() dispatch0(mlhs_new)
00599 #define mlhs_add(l,a) dispatch2(mlhs_add, l, a)
00600 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, l, a)
00601 
00602 #define params_new(pars, opts, rest, pars2, blk) \
00603         dispatch5(params, pars, opts, rest, pars2, blk)
00604 
00605 #define blockvar_new(p,v) dispatch2(block_var, p, v)
00606 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, l, a)
00607 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, l, a)
00608 
00609 #define method_optarg(m,a) ((a)==Qundef ? m : dispatch2(method_add_arg,m,a))
00610 #define method_arg(m,a) dispatch2(method_add_arg,m,a)
00611 #define method_add_block(m,b) dispatch2(method_add_block, m, b)
00612 
00613 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00614 
00615 #define FIXME 0
00616 
00617 #endif /* RIPPER */
00618 
00619 #ifndef RIPPER
00620 # define ifndef_ripper(x) x
00621 #else
00622 # define ifndef_ripper(x)
00623 #endif
00624 
00625 #ifndef RIPPER
00626 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, fmt)
00627 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, fmt, a)
00628 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, fmt, a)
00629 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, fmt)
00630 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, fmt, a)
00631 #else
00632 # define rb_warn0(fmt)    ripper_warn0(parser, fmt)
00633 # define rb_warnI(fmt,a)  ripper_warnI(parser, fmt, a)
00634 # define rb_warnS(fmt,a)  ripper_warnS(parser, fmt, a)
00635 # define rb_warning0(fmt) ripper_warning0(parser, fmt)
00636 # define rb_warningS(fmt,a) ripper_warningS(parser, fmt, a)
00637 static void ripper_warn0(struct parser_params*, const char*);
00638 static void ripper_warnI(struct parser_params*, const char*, int);
00639 #if 0
00640 static void ripper_warnS(struct parser_params*, const char*, const char*);
00641 #endif
00642 static void ripper_warning0(struct parser_params*, const char*);
00643 static void ripper_warningS(struct parser_params*, const char*, const char*);
00644 #endif
00645 
00646 #ifdef RIPPER
00647 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00648 # define rb_compile_error ripper_compile_error
00649 # define compile_error ripper_compile_error
00650 # define PARSER_ARG parser,
00651 #else
00652 # define compile_error parser->nerr++,rb_compile_error
00653 # define PARSER_ARG ruby_sourcefile, ruby_sourceline,
00654 #endif
00655 
00656 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00657    for instance).  This is too low for Ruby to parse some files, such as
00658    date/format.rb, therefore bump the value up to at least Bison's default. */
00659 #ifdef OLD_YACC
00660 #ifndef YYMAXDEPTH
00661 #define YYMAXDEPTH 10000
00662 #endif
00663 #endif
00664 
00665 #ifndef RIPPER
00666 static void token_info_push(struct parser_params*, const char *token);
00667 static void token_info_pop(struct parser_params*, const char *token);
00668 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, token) : (void)0)
00669 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, token) : (void)0)
00670 #else
00671 #define token_info_push(token) /* nothing */
00672 #define token_info_pop(token) /* nothing */
00673 #endif
00674 
00675 
00676 /* Line 189 of yacc.c  */
00677 #line 678 "parse.c"
00678 
00679 /* Enabling traces.  */
00680 #ifndef YYDEBUG
00681 # define YYDEBUG 1
00682 #endif
00683 
00684 /* Enabling verbose error messages.  */
00685 #ifdef YYERROR_VERBOSE
00686 # undef YYERROR_VERBOSE
00687 # define YYERROR_VERBOSE 1
00688 #else
00689 # define YYERROR_VERBOSE 0
00690 #endif
00691 
00692 /* Enabling the token table.  */
00693 #ifndef YYTOKEN_TABLE
00694 # define YYTOKEN_TABLE 0
00695 #endif
00696 
00697 
00698 /* Tokens.  */
00699 #ifndef YYTOKENTYPE
00700 # define YYTOKENTYPE
00701    /* Put the tokens into the symbol table, so that GDB and other debuggers
00702       know about them.  */
00703    enum yytokentype {
00704      keyword_class = 258,
00705      keyword_module = 259,
00706      keyword_def = 260,
00707      keyword_undef = 261,
00708      keyword_begin = 262,
00709      keyword_rescue = 263,
00710      keyword_ensure = 264,
00711      keyword_end = 265,
00712      keyword_if = 266,
00713      keyword_unless = 267,
00714      keyword_then = 268,
00715      keyword_elsif = 269,
00716      keyword_else = 270,
00717      keyword_case = 271,
00718      keyword_when = 272,
00719      keyword_while = 273,
00720      keyword_until = 274,
00721      keyword_for = 275,
00722      keyword_break = 276,
00723      keyword_next = 277,
00724      keyword_redo = 278,
00725      keyword_retry = 279,
00726      keyword_in = 280,
00727      keyword_do = 281,
00728      keyword_do_cond = 282,
00729      keyword_do_block = 283,
00730      keyword_do_LAMBDA = 284,
00731      keyword_return = 285,
00732      keyword_yield = 286,
00733      keyword_super = 287,
00734      keyword_self = 288,
00735      keyword_nil = 289,
00736      keyword_true = 290,
00737      keyword_false = 291,
00738      keyword_and = 292,
00739      keyword_or = 293,
00740      keyword_not = 294,
00741      modifier_if = 295,
00742      modifier_unless = 296,
00743      modifier_while = 297,
00744      modifier_until = 298,
00745      modifier_rescue = 299,
00746      keyword_alias = 300,
00747      keyword_defined = 301,
00748      keyword_BEGIN = 302,
00749      keyword_END = 303,
00750      keyword__LINE__ = 304,
00751      keyword__FILE__ = 305,
00752      keyword__ENCODING__ = 306,
00753      tIDENTIFIER = 307,
00754      tFID = 308,
00755      tGVAR = 309,
00756      tIVAR = 310,
00757      tCONSTANT = 311,
00758      tCVAR = 312,
00759      tLABEL = 313,
00760      tINTEGER = 314,
00761      tFLOAT = 315,
00762      tSTRING_CONTENT = 316,
00763      tCHAR = 317,
00764      tNTH_REF = 318,
00765      tBACK_REF = 319,
00766      tREGEXP_END = 320,
00767      tUPLUS = 321,
00768      tUMINUS = 322,
00769      tPOW = 323,
00770      tCMP = 324,
00771      tEQ = 325,
00772      tEQQ = 326,
00773      tNEQ = 327,
00774      tGEQ = 328,
00775      tLEQ = 329,
00776      tANDOP = 330,
00777      tOROP = 331,
00778      tMATCH = 332,
00779      tNMATCH = 333,
00780      tDOT2 = 334,
00781      tDOT3 = 335,
00782      tAREF = 336,
00783      tASET = 337,
00784      tLSHFT = 338,
00785      tRSHFT = 339,
00786      tCOLON2 = 340,
00787      tCOLON3 = 341,
00788      tOP_ASGN = 342,
00789      tASSOC = 343,
00790      tLPAREN = 344,
00791      tLPAREN_ARG = 345,
00792      tRPAREN = 346,
00793      tLBRACK = 347,
00794      tLBRACE = 348,
00795      tLBRACE_ARG = 349,
00796      tSTAR = 350,
00797      tAMPER = 351,
00798      tLAMBDA = 352,
00799      tSYMBEG = 353,
00800      tSTRING_BEG = 354,
00801      tXSTRING_BEG = 355,
00802      tREGEXP_BEG = 356,
00803      tWORDS_BEG = 357,
00804      tQWORDS_BEG = 358,
00805      tSTRING_DBEG = 359,
00806      tSTRING_DVAR = 360,
00807      tSTRING_END = 361,
00808      tLAMBEG = 362,
00809      tLOWEST = 363,
00810      tUMINUS_NUM = 364,
00811      idNULL = 365,
00812      idRespond_to = 366,
00813      idIFUNC = 367,
00814      idCFUNC = 368,
00815      id_core_set_method_alias = 369,
00816      id_core_set_variable_alias = 370,
00817      id_core_undef_method = 371,
00818      id_core_define_method = 372,
00819      id_core_define_singleton_method = 373,
00820      id_core_set_postexe = 374,
00821      tLAST_TOKEN = 375
00822    };
00823 #endif
00824 
00825 
00826 
00827 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00828 typedef union YYSTYPE
00829 {
00830 
00831 /* Line 214 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 
00842 /* Line 214 of yacc.c  */
00843 #line 844 "parse.c"
00844 } YYSTYPE;
00845 # define YYSTYPE_IS_TRIVIAL 1
00846 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00847 # define YYSTYPE_IS_DECLARED 1
00848 #endif
00849 
00850 
00851 /* Copy the second part of user declarations.  */
00852 
00853 
00854 /* Line 264 of yacc.c  */
00855 #line 856 "parse.c"
00856 
00857 #ifdef short
00858 # undef short
00859 #endif
00860 
00861 #ifdef YYTYPE_UINT8
00862 typedef YYTYPE_UINT8 yytype_uint8;
00863 #else
00864 typedef unsigned char yytype_uint8;
00865 #endif
00866 
00867 #ifdef YYTYPE_INT8
00868 typedef YYTYPE_INT8 yytype_int8;
00869 #elif (defined __STDC__ || defined __C99__FUNC__ \
00870      || defined __cplusplus || defined _MSC_VER)
00871 typedef signed char yytype_int8;
00872 #else
00873 typedef short int yytype_int8;
00874 #endif
00875 
00876 #ifdef YYTYPE_UINT16
00877 typedef YYTYPE_UINT16 yytype_uint16;
00878 #else
00879 typedef unsigned short int yytype_uint16;
00880 #endif
00881 
00882 #ifdef YYTYPE_INT16
00883 typedef YYTYPE_INT16 yytype_int16;
00884 #else
00885 typedef short int yytype_int16;
00886 #endif
00887 
00888 #ifndef YYSIZE_T
00889 # ifdef __SIZE_TYPE__
00890 #  define YYSIZE_T __SIZE_TYPE__
00891 # elif defined size_t
00892 #  define YYSIZE_T size_t
00893 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00894      || defined __cplusplus || defined _MSC_VER)
00895 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00896 #  define YYSIZE_T size_t
00897 # else
00898 #  define YYSIZE_T unsigned int
00899 # endif
00900 #endif
00901 
00902 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00903 
00904 #ifndef YY_
00905 # if defined YYENABLE_NLS && YYENABLE_NLS
00906 #  if ENABLE_NLS
00907 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00908 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00909 #  endif
00910 # endif
00911 # ifndef YY_
00912 #  define YY_(msgid) msgid
00913 # endif
00914 #endif
00915 
00916 /* Suppress unused-variable warnings by "using" E.  */
00917 #if ! defined lint || defined __GNUC__
00918 # define YYUSE(e) ((void) (e))
00919 #else
00920 # define YYUSE(e) /* empty */
00921 #endif
00922 
00923 /* Identity function, used to suppress warnings about constant conditions.  */
00924 #ifndef lint
00925 # define YYID(n) (n)
00926 #else
00927 #if (defined __STDC__ || defined __C99__FUNC__ \
00928      || defined __cplusplus || defined _MSC_VER)
00929 static int
00930 YYID (int yyi)
00931 #else
00932 static int
00933 YYID (yyi)
00934     int yyi;
00935 #endif
00936 {
00937   return yyi;
00938 }
00939 #endif
00940 
00941 #if ! defined yyoverflow || YYERROR_VERBOSE
00942 
00943 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00944 
00945 # ifdef YYSTACK_USE_ALLOCA
00946 #  if YYSTACK_USE_ALLOCA
00947 #   ifdef __GNUC__
00948 #    define YYSTACK_ALLOC __builtin_alloca
00949 #   elif defined __BUILTIN_VA_ARG_INCR
00950 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00951 #   elif defined _AIX
00952 #    define YYSTACK_ALLOC __alloca
00953 #   elif defined _MSC_VER
00954 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00955 #    define alloca _alloca
00956 #   else
00957 #    define YYSTACK_ALLOC alloca
00958 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00959      || defined __cplusplus || defined _MSC_VER)
00960 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00961 #     ifndef _STDLIB_H
00962 #      define _STDLIB_H 1
00963 #     endif
00964 #    endif
00965 #   endif
00966 #  endif
00967 # endif
00968 
00969 # ifdef YYSTACK_ALLOC
00970    /* Pacify GCC's `empty if-body' warning.  */
00971 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00972 #  ifndef YYSTACK_ALLOC_MAXIMUM
00973     /* The OS might guarantee only one guard page at the bottom of the stack,
00974        and a page size can be as small as 4096 bytes.  So we cannot safely
00975        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00976        to allow for a few compiler-allocated temporary stack slots.  */
00977 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00978 #  endif
00979 # else
00980 #  define YYSTACK_ALLOC YYMALLOC
00981 #  define YYSTACK_FREE YYFREE
00982 #  ifndef YYSTACK_ALLOC_MAXIMUM
00983 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00984 #  endif
00985 #  if (defined __cplusplus && ! defined _STDLIB_H \
00986        && ! ((defined YYMALLOC || defined malloc) \
00987              && (defined YYFREE || defined free)))
00988 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00989 #   ifndef _STDLIB_H
00990 #    define _STDLIB_H 1
00991 #   endif
00992 #  endif
00993 #  ifndef YYMALLOC
00994 #   define YYMALLOC malloc
00995 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00996      || defined __cplusplus || defined _MSC_VER)
00997 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00998 #   endif
00999 #  endif
01000 #  ifndef YYFREE
01001 #   define YYFREE free
01002 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01003      || defined __cplusplus || defined _MSC_VER)
01004 void free (void *); /* INFRINGES ON USER NAME SPACE */
01005 #   endif
01006 #  endif
01007 # endif
01008 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01009 
01010 
01011 #if (! defined yyoverflow \
01012      && (! defined __cplusplus \
01013          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01014 
01015 /* A type that is properly aligned for any stack member.  */
01016 union yyalloc
01017 {
01018   yytype_int16 yyss_alloc;
01019   YYSTYPE yyvs_alloc;
01020 };
01021 
01022 /* The size of the maximum gap between one aligned stack and the next.  */
01023 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01024 
01025 /* The size of an array large to enough to hold all stacks, each with
01026    N elements.  */
01027 # define YYSTACK_BYTES(N) \
01028      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01029       + YYSTACK_GAP_MAXIMUM)
01030 
01031 /* Copy COUNT objects from FROM to TO.  The source and destination do
01032    not overlap.  */
01033 # ifndef YYCOPY
01034 #  if defined __GNUC__ && 1 < __GNUC__
01035 #   define YYCOPY(To, From, Count) \
01036       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01037 #  else
01038 #   define YYCOPY(To, From, Count)              \
01039       do                                        \
01040         {                                       \
01041           YYSIZE_T yyi;                         \
01042           for (yyi = 0; yyi < (Count); yyi++)   \
01043             (To)[yyi] = (From)[yyi];            \
01044         }                                       \
01045       while (YYID (0))
01046 #  endif
01047 # endif
01048 
01049 /* Relocate STACK from its old location to the new one.  The
01050    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01051    elements in the stack, and YYPTR gives the new location of the
01052    stack.  Advance YYPTR to a properly aligned location for the next
01053    stack.  */
01054 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01055     do                                                                  \
01056       {                                                                 \
01057         YYSIZE_T yynewbytes;                                            \
01058         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01059         Stack = &yyptr->Stack_alloc;                                    \
01060         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01061         yyptr += yynewbytes / sizeof (*yyptr);                          \
01062       }                                                                 \
01063     while (YYID (0))
01064 
01065 #endif
01066 
01067 /* YYFINAL -- State number of the termination state.  */
01068 #define YYFINAL  3
01069 /* YYLAST -- Last index in YYTABLE.  */
01070 #define YYLAST   10410
01071 
01072 /* YYNTOKENS -- Number of terminals.  */
01073 #define YYNTOKENS  148
01074 /* YYNNTS -- Number of nonterminals.  */
01075 #define YYNNTS  172
01076 /* YYNRULES -- Number of rules.  */
01077 #define YYNRULES  565
01078 /* YYNRULES -- Number of states.  */
01079 #define YYNSTATES  975
01080 
01081 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01082 #define YYUNDEFTOK  2
01083 #define YYMAXUTOK   375
01084 
01085 #define YYTRANSLATE(YYX)                                                \
01086   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01087 
01088 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01089 static const yytype_uint8 yytranslate[] =
01090 {
01091        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01092      147,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01093        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01094        2,     2,   146,   123,     2,     2,     2,   121,   116,     2,
01095      142,   143,   119,   117,   140,   118,   139,   120,     2,     2,
01096        2,     2,     2,     2,     2,     2,     2,     2,   111,   145,
01097      113,   109,   112,   110,     2,     2,     2,     2,     2,     2,
01098        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01099        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01100        2,   138,     2,   144,   115,     2,   141,     2,     2,     2,
01101        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01102        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01103        2,     2,     2,   136,   114,   137,   124,     2,     2,     2,
01104        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01105        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01106        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01107        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01108        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01109        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01110        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01111        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01112        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01113        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01114        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01115        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01116        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01117        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01118       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01119       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01120       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01121       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01122       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01123       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
01124       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
01125       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
01126       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
01127      105,   106,   107,   108,   122,   125,   126,   127,   128,   129,
01128      130,   131,   132,   133,   134,   135
01129 };
01130 
01131 #if YYDEBUG
01132 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01133    YYRHS.  */
01134 static const yytype_uint16 yyprhs[] =
01135 {
01136        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01137       23,    24,    30,    35,    38,    40,    42,    46,    49,    50,
01138       55,    59,    63,    67,    70,    74,    78,    82,    86,    90,
01139       95,    99,   103,   107,   114,   120,   126,   132,   138,   142,
01140      146,   150,   154,   156,   158,   162,   166,   170,   173,   175,
01141      177,   179,   181,   183,   188,   193,   194,   200,   203,   207,
01142      212,   218,   223,   229,   232,   235,   238,   241,   244,   246,
01143      250,   252,   256,   258,   261,   265,   271,   274,   279,   282,
01144      287,   289,   293,   295,   299,   302,   306,   308,   312,   314,
01145      319,   323,   327,   331,   335,   338,   340,   342,   347,   351,
01146      355,   359,   363,   366,   368,   370,   372,   375,   377,   381,
01147      383,   385,   387,   389,   391,   393,   395,   397,   399,   401,
01148      402,   407,   409,   411,   413,   415,   417,   419,   421,   423,
01149      425,   427,   429,   431,   433,   435,   437,   439,   441,   443,
01150      445,   447,   449,   451,   453,   455,   457,   459,   461,   463,
01151      465,   467,   469,   471,   473,   475,   477,   479,   481,   483,
01152      485,   487,   489,   491,   493,   495,   497,   499,   501,   503,
01153      505,   507,   509,   511,   513,   515,   517,   519,   521,   523,
01154      525,   527,   529,   531,   533,   535,   537,   539,   541,   543,
01155      545,   547,   551,   557,   561,   567,   574,   580,   586,   592,
01156      598,   603,   607,   611,   615,   619,   623,   627,   631,   635,
01157      639,   644,   649,   652,   655,   659,   663,   667,   671,   675,
01158      679,   683,   687,   691,   695,   699,   703,   707,   710,   713,
01159      717,   721,   725,   729,   730,   735,   742,   744,   746,   748,
01160      751,   756,   759,   763,   765,   767,   769,   771,   773,   776,
01161      779,   784,   786,   787,   790,   793,   796,   798,   800,   802,
01162      805,   809,   814,   818,   823,   826,   828,   830,   832,   834,
01163      836,   838,   840,   842,   844,   845,   850,   851,   856,   860,
01164      864,   867,   871,   875,   877,   882,   886,   888,   889,   896,
01165      901,   905,   908,   910,   913,   916,   923,   930,   931,   932,
01166      940,   941,   942,   950,   956,   961,   962,   963,   973,   974,
01167      981,   982,   983,   992,   993,   999,  1000,  1007,  1008,  1009,
01168     1019,  1021,  1023,  1025,  1027,  1029,  1031,  1033,  1035,  1037,
01169     1039,  1041,  1043,  1045,  1047,  1049,  1051,  1053,  1055,  1058,
01170     1060,  1062,  1064,  1070,  1072,  1075,  1077,  1079,  1081,  1085,
01171     1087,  1091,  1093,  1098,  1105,  1109,  1115,  1118,  1123,  1125,
01172     1129,  1136,  1145,  1150,  1157,  1162,  1165,  1172,  1175,  1180,
01173     1187,  1190,  1195,  1198,  1203,  1205,  1207,  1209,  1213,  1215,
01174     1220,  1222,  1225,  1227,  1231,  1233,  1235,  1236,  1237,  1242,
01175     1247,  1249,  1253,  1257,  1258,  1264,  1267,  1272,  1277,  1280,
01176     1285,  1290,  1294,  1298,  1302,  1305,  1307,  1312,  1313,  1319,
01177     1320,  1326,  1332,  1334,  1336,  1343,  1345,  1347,  1349,  1351,
01178     1354,  1356,  1359,  1361,  1363,  1365,  1367,  1369,  1371,  1373,
01179     1376,  1380,  1384,  1388,  1392,  1396,  1397,  1401,  1403,  1406,
01180     1410,  1414,  1415,  1419,  1420,  1423,  1424,  1427,  1428,  1431,
01181     1433,  1434,  1438,  1439,  1440,  1446,  1448,  1450,  1452,  1454,
01182     1457,  1459,  1461,  1463,  1465,  1469,  1471,  1473,  1476,  1479,
01183     1481,  1483,  1485,  1487,  1489,  1491,  1493,  1495,  1497,  1499,
01184     1501,  1503,  1505,  1507,  1509,  1511,  1513,  1514,  1519,  1522,
01185     1526,  1529,  1536,  1545,  1550,  1557,  1562,  1569,  1572,  1577,
01186     1584,  1587,  1592,  1595,  1600,  1602,  1603,  1605,  1607,  1609,
01187     1611,  1613,  1615,  1617,  1621,  1623,  1627,  1631,  1635,  1637,
01188     1641,  1643,  1647,  1649,  1651,  1654,  1656,  1658,  1660,  1663,
01189     1666,  1668,  1670,  1671,  1676,  1678,  1681,  1683,  1687,  1691,
01190     1694,  1696,  1698,  1700,  1702,  1704,  1706,  1708,  1710,  1712,
01191     1714,  1716,  1718,  1719,  1721,  1722,  1724,  1727,  1730,  1731,
01192     1733,  1735,  1737,  1739,  1741,  1744
01193 };
01194 
01195 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01196 static const yytype_int16 yyrhs[] =
01197 {
01198      149,     0,    -1,    -1,   150,   151,    -1,   152,   312,    -1,
01199      319,    -1,   153,    -1,   152,   318,   153,    -1,     1,   153,
01200       -1,   158,    -1,    -1,    47,   154,   136,   151,   137,    -1,
01201      156,   255,   230,   258,    -1,   157,   312,    -1,   319,    -1,
01202      158,    -1,   157,   318,   158,    -1,     1,   158,    -1,    -1,
01203       45,   179,   159,   179,    -1,    45,    54,    54,    -1,    45,
01204       54,    64,    -1,    45,    54,    63,    -1,     6,   180,    -1,
01205      158,    40,   161,    -1,   158,    41,   161,    -1,   158,    42,
01206      161,    -1,   158,    43,   161,    -1,   158,    44,   158,    -1,
01207       48,   136,   156,   137,    -1,   174,   109,   162,    -1,   167,
01208      109,   162,    -1,   284,    87,   162,    -1,   215,   138,   190,
01209      315,    87,   162,    -1,   215,   139,    52,    87,   162,    -1,
01210      215,   139,    56,    87,   162,    -1,   215,    85,    56,    87,
01211      162,    -1,   215,    85,    52,    87,   162,    -1,   285,    87,
01212      162,    -1,   174,   109,   197,    -1,   167,   109,   186,    -1,
01213      167,   109,   197,    -1,   160,    -1,   162,    -1,   160,    37,
01214      160,    -1,   160,    38,   160,    -1,    39,   313,   160,    -1,
01215      123,   162,    -1,   184,    -1,   160,    -1,   166,    -1,   163,
01216       -1,   248,    -1,   248,   139,   309,   192,    -1,   248,    85,
01217      309,   192,    -1,    -1,    94,   165,   236,   156,   137,    -1,
01218      308,   192,    -1,   308,   192,   164,    -1,   215,   139,   309,
01219      192,    -1,   215,   139,   309,   192,   164,    -1,   215,    85,
01220      309,   192,    -1,   215,    85,   309,   192,   164,    -1,    32,
01221      192,    -1,    31,   192,    -1,    30,   191,    -1,    21,   191,
01222       -1,    22,   191,    -1,   169,    -1,    89,   168,   314,    -1,
01223      169,    -1,    89,   168,   314,    -1,   171,    -1,   171,   170,
01224       -1,   171,    95,   173,    -1,   171,    95,   173,   140,   172,
01225       -1,   171,    95,    -1,   171,    95,   140,   172,    -1,    95,
01226      173,    -1,    95,   173,   140,   172,    -1,    95,    -1,    95,
01227      140,   172,    -1,   173,    -1,    89,   168,   314,    -1,   170,
01228      140,    -1,   171,   170,   140,    -1,   170,    -1,   172,   140,
01229      170,    -1,   282,    -1,   215,   138,   190,   315,    -1,   215,
01230      139,    52,    -1,   215,    85,    52,    -1,   215,   139,    56,
01231       -1,   215,    85,    56,    -1,    86,    56,    -1,   285,    -1,
01232      282,    -1,   215,   138,   190,   315,    -1,   215,   139,    52,
01233       -1,   215,    85,    52,    -1,   215,   139,    56,    -1,   215,
01234       85,    56,    -1,    86,    56,    -1,   285,    -1,    52,    -1,
01235       56,    -1,    86,   175,    -1,   175,    -1,   215,    85,   175,
01236       -1,    52,    -1,    56,    -1,    53,    -1,   182,    -1,   183,
01237       -1,   177,    -1,   278,    -1,   178,    -1,   280,    -1,   179,
01238       -1,    -1,   180,   140,   181,   179,    -1,   114,    -1,   115,
01239       -1,   116,    -1,    69,    -1,    70,    -1,    71,    -1,    77,
01240       -1,    78,    -1,   112,    -1,    73,    -1,   113,    -1,    74,
01241       -1,    72,    -1,    83,    -1,    84,    -1,   117,    -1,   118,
01242       -1,   119,    -1,    95,    -1,   120,    -1,   121,    -1,    68,
01243       -1,   123,    -1,   124,    -1,    66,    -1,    67,    -1,    81,
01244       -1,    82,    -1,   141,    -1,    49,    -1,    50,    -1,    51,
01245       -1,    47,    -1,    48,    -1,    45,    -1,    37,    -1,     7,
01246       -1,    21,    -1,    16,    -1,     3,    -1,     5,    -1,    46,
01247       -1,    26,    -1,    15,    -1,    14,    -1,    10,    -1,     9,
01248       -1,    36,    -1,    20,    -1,    25,    -1,     4,    -1,    22,
01249       -1,    34,    -1,    39,    -1,    38,    -1,    23,    -1,     8,
01250       -1,    24,    -1,    30,    -1,    33,    -1,    32,    -1,    13,
01251       -1,    35,    -1,     6,    -1,    17,    -1,    31,    -1,    11,
01252       -1,    12,    -1,    18,    -1,    19,    -1,   174,   109,   184,
01253       -1,   174,   109,   184,    44,   184,    -1,   284,    87,   184,
01254       -1,   284,    87,   184,    44,   184,    -1,   215,   138,   190,
01255      315,    87,   184,    -1,   215,   139,    52,    87,   184,    -1,
01256      215,   139,    56,    87,   184,    -1,   215,    85,    52,    87,
01257      184,    -1,   215,    85,    56,    87,   184,    -1,    86,    56,
01258       87,   184,    -1,   285,    87,   184,    -1,   184,    79,   184,
01259       -1,   184,    80,   184,    -1,   184,   117,   184,    -1,   184,
01260      118,   184,    -1,   184,   119,   184,    -1,   184,   120,   184,
01261       -1,   184,   121,   184,    -1,   184,    68,   184,    -1,   122,
01262       59,    68,   184,    -1,   122,    60,    68,   184,    -1,    66,
01263      184,    -1,    67,   184,    -1,   184,   114,   184,    -1,   184,
01264      115,   184,    -1,   184,   116,   184,    -1,   184,    69,   184,
01265       -1,   184,   112,   184,    -1,   184,    73,   184,    -1,   184,
01266      113,   184,    -1,   184,    74,   184,    -1,   184,    70,   184,
01267       -1,   184,    71,   184,    -1,   184,    72,   184,    -1,   184,
01268       77,   184,    -1,   184,    78,   184,    -1,   123,   184,    -1,
01269      124,   184,    -1,   184,    83,   184,    -1,   184,    84,   184,
01270       -1,   184,    75,   184,    -1,   184,    76,   184,    -1,    -1,
01271       46,   313,   185,   184,    -1,   184,   110,   184,   313,   111,
01272      184,    -1,   198,    -1,   184,    -1,   319,    -1,   196,   316,
01273       -1,   196,   140,   306,   316,    -1,   306,   316,    -1,   142,
01274      190,   314,    -1,   319,    -1,   188,    -1,   319,    -1,   191,
01275       -1,   166,    -1,   196,   195,    -1,   306,   195,    -1,   196,
01276      140,   306,   195,    -1,   194,    -1,    -1,   193,   191,    -1,
01277       96,   186,    -1,   140,   194,    -1,   140,    -1,   319,    -1,
01278      186,    -1,    95,   186,    -1,   196,   140,   186,    -1,   196,
01279      140,    95,   186,    -1,   196,   140,   186,    -1,   196,   140,
01280       95,   186,    -1,    95,   186,    -1,   259,    -1,   260,    -1,
01281      263,    -1,   264,    -1,   265,    -1,   268,    -1,   283,    -1,
01282      285,    -1,    53,    -1,    -1,   216,   199,   155,   226,    -1,
01283       -1,    90,   160,   200,   314,    -1,    89,   156,   143,    -1,
01284      215,    85,    56,    -1,    86,    56,    -1,    92,   187,   144,
01285       -1,    93,   305,   137,    -1,    30,    -1,    31,   142,   191,
01286      314,    -1,    31,   142,   314,    -1,    31,    -1,    -1,    46,
01287      313,   142,   201,   160,   314,    -1,    39,   142,   160,   314,
01288       -1,    39,   142,   314,    -1,   308,   250,    -1,   249,    -1,
01289      249,   250,    -1,    97,   241,    -1,   217,   161,   227,   156,
01290      229,   226,    -1,   218,   161,   227,   156,   230,   226,    -1,
01291       -1,    -1,   219,   202,   161,   228,   203,   156,   226,    -1,
01292       -1,    -1,   220,   204,   161,   228,   205,   156,   226,    -1,
01293      221,   161,   312,   253,   226,    -1,   221,   312,   253,   226,
01294       -1,    -1,    -1,   222,   231,    25,   206,   161,   228,   207,
01295      156,   226,    -1,    -1,   223,   176,   286,   208,   155,   226,
01296       -1,    -1,    -1,   223,    83,   160,   209,   317,   210,   155,
01297      226,    -1,    -1,   224,   176,   211,   155,   226,    -1,    -1,
01298      225,   177,   212,   288,   155,   226,    -1,    -1,    -1,   225,
01299      303,   311,   213,   177,   214,   288,   155,   226,    -1,    21,
01300       -1,    22,    -1,    23,    -1,    24,    -1,   198,    -1,     7,
01301       -1,    11,    -1,    12,    -1,    18,    -1,    19,    -1,    16,
01302       -1,    20,    -1,     3,    -1,     4,    -1,     5,    -1,    10,
01303       -1,   317,    -1,    13,    -1,   317,    13,    -1,   317,    -1,
01304       27,    -1,   230,    -1,    14,   161,   227,   156,   229,    -1,
01305      319,    -1,    15,   156,    -1,   174,    -1,   167,    -1,   291,
01306       -1,    89,   234,   314,    -1,   232,    -1,   233,   140,   232,
01307       -1,   233,    -1,   233,   140,    95,   291,    -1,   233,   140,
01308       95,   291,   140,   233,    -1,   233,   140,    95,    -1,   233,
01309      140,    95,   140,   233,    -1,    95,   291,    -1,    95,   291,
01310      140,   233,    -1,    95,    -1,    95,   140,   233,    -1,   293,
01311      140,   296,   140,   299,   302,    -1,   293,   140,   296,   140,
01312      299,   140,   293,   302,    -1,   293,   140,   296,   302,    -1,
01313      293,   140,   296,   140,   293,   302,    -1,   293,   140,   299,
01314      302,    -1,   293,   140,    -1,   293,   140,   299,   140,   293,
01315      302,    -1,   293,   302,    -1,   296,   140,   299,   302,    -1,
01316      296,   140,   299,   140,   293,   302,    -1,   296,   302,    -1,
01317      296,   140,   293,   302,    -1,   299,   302,    -1,   299,   140,
01318      293,   302,    -1,   301,    -1,   319,    -1,   237,    -1,   114,
01319      238,   114,    -1,    76,    -1,   114,   235,   238,   114,    -1,
01320      319,    -1,   145,   239,    -1,   240,    -1,   239,   140,   240,
01321       -1,    52,    -1,   290,    -1,    -1,    -1,   242,   243,   244,
01322      245,    -1,   142,   289,   238,   314,    -1,   289,    -1,   107,
01323      156,   137,    -1,    29,   156,    10,    -1,    -1,    28,   247,
01324      236,   156,    10,    -1,   166,   246,    -1,   248,   139,   309,
01325      189,    -1,   248,    85,   309,   189,    -1,   308,   188,    -1,
01326      215,   139,   309,   189,    -1,   215,    85,   309,   188,    -1,
01327      215,    85,   310,    -1,   215,   139,   188,    -1,   215,    85,
01328      188,    -1,    32,   188,    -1,    32,    -1,   215,   138,   190,
01329      315,    -1,    -1,   136,   251,   236,   156,   137,    -1,    -1,
01330       26,   252,   236,   156,    10,    -1,    17,   196,   227,   156,
01331      254,    -1,   230,    -1,   253,    -1,     8,   256,   257,   227,
01332      156,   255,    -1,   319,    -1,   186,    -1,   197,    -1,   319,
01333       -1,    88,   174,    -1,   319,    -1,     9,   156,    -1,   319,
01334       -1,   281,    -1,   278,    -1,   280,    -1,   261,    -1,    62,
01335       -1,   262,    -1,   261,   262,    -1,    99,   270,   106,    -1,
01336      100,   271,   106,    -1,   101,   272,    65,    -1,   102,   146,
01337      106,    -1,   102,   266,   106,    -1,    -1,   266,   267,   146,
01338       -1,   273,    -1,   267,   273,    -1,   103,   146,   106,    -1,
01339      103,   269,   106,    -1,    -1,   269,    61,   146,    -1,    -1,
01340      270,   273,    -1,    -1,   271,   273,    -1,    -1,   272,   273,
01341       -1,    61,    -1,    -1,   105,   274,   277,    -1,    -1,    -1,
01342      104,   275,   276,   156,   137,    -1,    54,    -1,    55,    -1,
01343       57,    -1,   285,    -1,    98,   279,    -1,   177,    -1,    55,
01344       -1,    54,    -1,    57,    -1,    98,   271,   106,    -1,    59,
01345       -1,    60,    -1,   122,    59,    -1,   122,    60,    -1,    52,
01346       -1,    55,    -1,    54,    -1,    56,    -1,    57,    -1,    34,
01347       -1,    33,    -1,    35,    -1,    36,    -1,    50,    -1,    49,
01348       -1,    51,    -1,   282,    -1,   282,    -1,    63,    -1,    64,
01349       -1,   317,    -1,    -1,   113,   287,   161,   317,    -1,     1,
01350      317,    -1,   142,   289,   314,    -1,   289,   317,    -1,   293,
01351      140,   297,   140,   299,   302,    -1,   293,   140,   297,   140,
01352      299,   140,   293,   302,    -1,   293,   140,   297,   302,    -1,
01353      293,   140,   297,   140,   293,   302,    -1,   293,   140,   299,
01354      302,    -1,   293,   140,   299,   140,   293,   302,    -1,   293,
01355      302,    -1,   297,   140,   299,   302,    -1,   297,   140,   299,
01356      140,   293,   302,    -1,   297,   302,    -1,   297,   140,   293,
01357      302,    -1,   299,   302,    -1,   299,   140,   293,   302,    -1,
01358      301,    -1,    -1,    56,    -1,    55,    -1,    54,    -1,    57,
01359       -1,   290,    -1,    52,    -1,   291,    -1,    89,   234,   314,
01360       -1,   292,    -1,   293,   140,   292,    -1,    52,   109,   186,
01361       -1,    52,   109,   215,    -1,   295,    -1,   296,   140,   295,
01362       -1,   294,    -1,   297,   140,   294,    -1,   119,    -1,    95,
01363       -1,   298,    52,    -1,   298,    -1,   116,    -1,    96,    -1,
01364      300,    52,    -1,   140,   301,    -1,   319,    -1,   283,    -1,
01365       -1,   142,   304,   160,   314,    -1,   319,    -1,   306,   316,
01366       -1,   307,    -1,   306,   140,   307,    -1,   186,    88,   186,
01367       -1,    58,   186,    -1,    52,    -1,    56,    -1,    53,    -1,
01368       52,    -1,    56,    -1,    53,    -1,   182,    -1,    52,    -1,
01369       53,    -1,   182,    -1,   139,    -1,    85,    -1,    -1,   318,
01370       -1,    -1,   147,    -1,   313,   143,    -1,   313,   144,    -1,
01371       -1,   147,    -1,   140,    -1,   145,    -1,   147,    -1,   317,
01372       -1,   318,   145,    -1,    -1
01373 };
01374 
01375 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01376 static const yytype_uint16 yyrline[] =
01377 {
01378        0,   786,   786,   786,   817,   828,   837,   845,   853,   859,
01379      861,   860,   884,   917,   928,   937,   945,   953,   959,   959,
01380      967,   975,   986,   996,  1004,  1013,  1022,  1035,  1048,  1057,
01381     1069,  1078,  1088,  1117,  1138,  1155,  1172,  1183,  1200,  1210,
01382     1219,  1228,  1237,  1240,  1241,  1249,  1257,  1265,  1273,  1276,
01383     1288,  1289,  1292,  1293,  1302,  1314,  1313,  1335,  1344,  1356,
01384     1365,  1377,  1386,  1398,  1407,  1416,  1424,  1432,  1442,  1443,
01385     1453,  1454,  1464,  1472,  1480,  1488,  1497,  1505,  1514,  1522,
01386     1531,  1539,  1550,  1551,  1561,  1569,  1579,  1587,  1597,  1601,
01387     1609,  1617,  1625,  1633,  1645,  1655,  1667,  1676,  1684,  1692,
01388     1700,  1708,  1721,  1734,  1745,  1753,  1756,  1764,  1772,  1782,
01389     1783,  1784,  1785,  1790,  1801,  1802,  1805,  1813,  1816,  1824,
01390     1824,  1834,  1835,  1836,  1837,  1838,  1839,  1840,  1841,  1842,
01391     1843,  1844,  1845,  1846,  1847,  1848,  1849,  1850,  1851,  1852,
01392     1853,  1854,  1855,  1856,  1857,  1858,  1859,  1860,  1861,  1862,
01393     1865,  1865,  1865,  1866,  1866,  1867,  1867,  1867,  1868,  1868,
01394     1868,  1868,  1869,  1869,  1869,  1869,  1870,  1870,  1870,  1871,
01395     1871,  1871,  1871,  1872,  1872,  1872,  1872,  1873,  1873,  1873,
01396     1873,  1874,  1874,  1874,  1874,  1875,  1875,  1875,  1875,  1876,
01397     1876,  1879,  1888,  1898,  1927,  1958,  1984,  2001,  2018,  2035,
01398     2046,  2057,  2068,  2082,  2096,  2104,  2112,  2120,  2128,  2136,
01399     2144,  2153,  2162,  2170,  2178,  2186,  2194,  2202,  2210,  2218,
01400     2226,  2234,  2242,  2250,  2258,  2266,  2277,  2285,  2293,  2301,
01401     2309,  2317,  2325,  2333,  2333,  2343,  2353,  2359,  2371,  2372,
01402     2376,  2384,  2394,  2404,  2405,  2408,  2409,  2412,  2421,  2429,
01403     2439,  2448,  2457,  2457,  2469,  2479,  2483,  2487,  2493,  2501,
01404     2509,  2523,  2539,  2553,  2568,  2578,  2579,  2580,  2581,  2582,
01405     2583,  2584,  2585,  2586,  2595,  2594,  2619,  2619,  2628,  2636,
01406     2644,  2652,  2665,  2673,  2681,  2689,  2697,  2705,  2705,  2715,
01407     2723,  2731,  2742,  2743,  2754,  2758,  2770,  2782,  2782,  2782,
01408     2793,  2793,  2793,  2804,  2815,  2824,  2826,  2823,  2890,  2889,
01409     2911,  2916,  2910,  2935,  2934,  2956,  2955,  2978,  2979,  2978,
01410     2999,  3007,  3015,  3023,  3033,  3045,  3051,  3057,  3063,  3069,
01411     3075,  3081,  3087,  3093,  3099,  3109,  3115,  3120,  3121,  3128,
01412     3133,  3136,  3137,  3150,  3151,  3161,  3162,  3165,  3173,  3183,
01413     3191,  3201,  3209,  3218,  3227,  3235,  3243,  3252,  3264,  3272,
01414     3282,  3290,  3298,  3306,  3314,  3322,  3331,  3339,  3347,  3355,
01415     3363,  3371,  3379,  3387,  3395,  3405,  3406,  3412,  3421,  3430,
01416     3441,  3442,  3452,  3459,  3468,  3476,  3482,  3485,  3482,  3503,
01417     3511,  3521,  3525,  3532,  3531,  3552,  3568,  3577,  3588,  3597,
01418     3607,  3617,  3625,  3636,  3647,  3655,  3663,  3678,  3677,  3697,
01419     3696,  3717,  3729,  3730,  3733,  3752,  3755,  3763,  3771,  3774,
01420     3778,  3781,  3789,  3792,  3793,  3801,  3804,  3821,  3822,  3823,
01421     3833,  3843,  3870,  3935,  3944,  3955,  3962,  3972,  3980,  3990,
01422     3999,  4010,  4017,  4028,  4035,  4046,  4053,  4064,  4071,  4100,
01423     4102,  4101,  4118,  4124,  4117,  4143,  4151,  4159,  4167,  4170,
01424     4181,  4182,  4183,  4184,  4187,  4217,  4218,  4219,  4227,  4237,
01425     4238,  4239,  4240,  4241,  4242,  4243,  4244,  4245,  4246,  4247,
01426     4248,  4251,  4261,  4271,  4272,  4275,  4284,  4283,  4291,  4303,
01427     4313,  4319,  4327,  4335,  4343,  4351,  4359,  4367,  4375,  4383,
01428     4391,  4399,  4407,  4415,  4423,  4432,  4441,  4450,  4459,  4468,
01429     4479,  4480,  4487,  4496,  4515,  4522,  4535,  4547,  4559,  4567,
01430     4583,  4591,  4607,  4608,  4611,  4624,  4635,  4636,  4639,  4656,
01431     4660,  4670,  4680,  4680,  4709,  4710,  4720,  4727,  4737,  4745,
01432     4755,  4756,  4757,  4760,  4761,  4762,  4763,  4766,  4767,  4768,
01433     4771,  4776,  4783,  4784,  4787,  4788,  4791,  4794,  4797,  4798,
01434     4799,  4802,  4803,  4806,  4807,  4811
01435 };
01436 #endif
01437 
01438 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01439 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01440    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01441 static const char *const yytname[] =
01442 {
01443   "$end", "error", "$undefined", "keyword_class", "keyword_module",
01444   "keyword_def", "keyword_undef", "keyword_begin", "keyword_rescue",
01445   "keyword_ensure", "keyword_end", "keyword_if", "keyword_unless",
01446   "keyword_then", "keyword_elsif", "keyword_else", "keyword_case",
01447   "keyword_when", "keyword_while", "keyword_until", "keyword_for",
01448   "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
01449   "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
01450   "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
01451   "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
01452   "keyword_and", "keyword_or", "keyword_not", "modifier_if",
01453   "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
01454   "keyword_alias", "keyword_defined", "keyword_BEGIN", "keyword_END",
01455   "keyword__LINE__", "keyword__FILE__", "keyword__ENCODING__",
01456   "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", "tCONSTANT", "tCVAR", "tLABEL",
01457   "tINTEGER", "tFLOAT", "tSTRING_CONTENT", "tCHAR", "tNTH_REF",
01458   "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", "tCMP", "tEQ",
01459   "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", "tMATCH", "tNMATCH",
01460   "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", "tRSHFT", "tCOLON2",
01461   "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", "tLPAREN_ARG", "tRPAREN",
01462   "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", "tAMPER", "tLAMBDA",
01463   "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", "tWORDS_BEG",
01464   "tQWORDS_BEG", "tSTRING_DBEG", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
01465   "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
01466   "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "idNULL",
01467   "idRespond_to", "idIFUNC", "idCFUNC", "id_core_set_method_alias",
01468   "id_core_set_variable_alias", "id_core_undef_method",
01469   "id_core_define_method", "id_core_define_singleton_method",
01470   "id_core_set_postexe", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','",
01471   "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
01472   "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt",
01473   "compstmt", "stmts", "stmt", "$@3", "expr", "expr_value", "command_call",
01474   "block_command", "cmd_brace_block", "@4", "command", "mlhs",
01475   "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head", "mlhs_post",
01476   "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "fitem",
01477   "undef_list", "$@5", "op", "reswords", "arg", "$@6", "arg_value",
01478   "aref_args", "paren_args", "opt_paren_args", "opt_call_args",
01479   "call_args", "command_args", "@7", "block_arg", "opt_block_arg", "args",
01480   "mrhs", "primary", "@8", "$@9", "$@10", "$@11", "$@12", "$@13", "$@14",
01481   "$@15", "$@16", "@17", "@18", "@19", "@20", "@21", "$@22", "$@23",
01482   "primary_value", "k_begin", "k_if", "k_unless", "k_while", "k_until",
01483   "k_case", "k_for", "k_class", "k_module", "k_def", "k_end", "then", "do",
01484   "if_tail", "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
01485   "block_param", "opt_block_param", "block_param_def", "opt_bv_decl",
01486   "bv_decls", "bvar", "lambda", "@24", "@25", "f_larglist", "lambda_body",
01487   "do_block", "@26", "block_call", "method_call", "brace_block", "@27",
01488   "@28", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
01489   "opt_ensure", "literal", "strings", "string", "string1", "xstring",
01490   "regexp", "words", "word_list", "word", "qwords", "qword_list",
01491   "string_contents", "xstring_contents", "regexp_contents",
01492   "string_content", "@29", "@30", "@31", "string_dvar", "symbol", "sym",
01493   "dsym", "numeric", "variable", "var_ref", "var_lhs", "backref",
01494   "superclass", "$@32", "f_arglist", "f_args", "f_bad_arg", "f_norm_arg",
01495   "f_arg_item", "f_arg", "f_opt", "f_block_opt", "f_block_optarg",
01496   "f_optarg", "restarg_mark", "f_rest_arg", "blkarg_mark", "f_block_arg",
01497   "opt_f_block_arg", "singleton", "$@33", "assoc_list", "assocs", "assoc",
01498   "operation", "operation2", "operation3", "dot_or_colon", "opt_terms",
01499   "opt_nl", "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01500 };
01501 #endif
01502 
01503 # ifdef YYPRINT
01504 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01505    token YYLEX-NUM.  */
01506 static const yytype_uint16 yytoknum[] =
01507 {
01508        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01509      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01510      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01511      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01512      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01513      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01514      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
01515      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
01516      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
01517      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
01518      355,   356,   357,   358,   359,   360,   361,   362,   363,    61,
01519       63,    58,    62,    60,   124,    94,    38,    43,    45,    42,
01520       47,    37,   364,    33,   126,   365,   366,   367,   368,   369,
01521      370,   371,   372,   373,   374,   375,   123,   125,    91,    46,
01522       44,    96,    40,    41,    93,    59,    32,    10
01523 };
01524 # endif
01525 
01526 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01527 static const yytype_uint16 yyr1[] =
01528 {
01529        0,   148,   150,   149,   151,   152,   152,   152,   152,   153,
01530      154,   153,   155,   156,   157,   157,   157,   157,   159,   158,
01531      158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
01532      158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
01533      158,   158,   158,   160,   160,   160,   160,   160,   160,   161,
01534      162,   162,   163,   163,   163,   165,   164,   166,   166,   166,
01535      166,   166,   166,   166,   166,   166,   166,   166,   167,   167,
01536      168,   168,   169,   169,   169,   169,   169,   169,   169,   169,
01537      169,   169,   170,   170,   171,   171,   172,   172,   173,   173,
01538      173,   173,   173,   173,   173,   173,   174,   174,   174,   174,
01539      174,   174,   174,   174,   175,   175,   176,   176,   176,   177,
01540      177,   177,   177,   177,   178,   178,   179,   179,   180,   181,
01541      180,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01542      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01543      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01544      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01545      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01546      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01547      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01548      183,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01549      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01550      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01551      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01552      184,   184,   184,   185,   184,   184,   184,   186,   187,   187,
01553      187,   187,   188,   189,   189,   190,   190,   191,   191,   191,
01554      191,   191,   193,   192,   194,   195,   195,   195,   196,   196,
01555      196,   196,   197,   197,   197,   198,   198,   198,   198,   198,
01556      198,   198,   198,   198,   199,   198,   200,   198,   198,   198,
01557      198,   198,   198,   198,   198,   198,   198,   201,   198,   198,
01558      198,   198,   198,   198,   198,   198,   198,   202,   203,   198,
01559      204,   205,   198,   198,   198,   206,   207,   198,   208,   198,
01560      209,   210,   198,   211,   198,   212,   198,   213,   214,   198,
01561      198,   198,   198,   198,   215,   216,   217,   218,   219,   220,
01562      221,   222,   223,   224,   225,   226,   227,   227,   227,   228,
01563      228,   229,   229,   230,   230,   231,   231,   232,   232,   233,
01564      233,   234,   234,   234,   234,   234,   234,   234,   234,   234,
01565      235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
01566      235,   235,   235,   235,   235,   236,   236,   237,   237,   237,
01567      238,   238,   239,   239,   240,   240,   242,   243,   241,   244,
01568      244,   245,   245,   247,   246,   248,   248,   248,   249,   249,
01569      249,   249,   249,   249,   249,   249,   249,   251,   250,   252,
01570      250,   253,   254,   254,   255,   255,   256,   256,   256,   257,
01571      257,   258,   258,   259,   259,   259,   260,   261,   261,   261,
01572      262,   263,   264,   265,   265,   266,   266,   267,   267,   268,
01573      268,   269,   269,   270,   270,   271,   271,   272,   272,   273,
01574      274,   273,   275,   276,   273,   277,   277,   277,   277,   278,
01575      279,   279,   279,   279,   280,   281,   281,   281,   281,   282,
01576      282,   282,   282,   282,   282,   282,   282,   282,   282,   282,
01577      282,   283,   284,   285,   285,   286,   287,   286,   286,   288,
01578      288,   289,   289,   289,   289,   289,   289,   289,   289,   289,
01579      289,   289,   289,   289,   289,   289,   290,   290,   290,   290,
01580      291,   291,   292,   292,   293,   293,   294,   295,   296,   296,
01581      297,   297,   298,   298,   299,   299,   300,   300,   301,   302,
01582      302,   303,   304,   303,   305,   305,   306,   306,   307,   307,
01583      308,   308,   308,   309,   309,   309,   309,   310,   310,   310,
01584      311,   311,   312,   312,   313,   313,   314,   315,   316,   316,
01585      316,   317,   317,   318,   318,   319
01586 };
01587 
01588 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01589 static const yytype_uint8 yyr2[] =
01590 {
01591        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01592        0,     5,     4,     2,     1,     1,     3,     2,     0,     4,
01593        3,     3,     3,     2,     3,     3,     3,     3,     3,     4,
01594        3,     3,     3,     6,     5,     5,     5,     5,     3,     3,
01595        3,     3,     1,     1,     3,     3,     3,     2,     1,     1,
01596        1,     1,     1,     4,     4,     0,     5,     2,     3,     4,
01597        5,     4,     5,     2,     2,     2,     2,     2,     1,     3,
01598        1,     3,     1,     2,     3,     5,     2,     4,     2,     4,
01599        1,     3,     1,     3,     2,     3,     1,     3,     1,     4,
01600        3,     3,     3,     3,     2,     1,     1,     4,     3,     3,
01601        3,     3,     2,     1,     1,     1,     2,     1,     3,     1,
01602        1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
01603        4,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01604        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01605        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01606        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01607        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01608        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01609        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01610        1,     3,     5,     3,     5,     6,     5,     5,     5,     5,
01611        4,     3,     3,     3,     3,     3,     3,     3,     3,     3,
01612        4,     4,     2,     2,     3,     3,     3,     3,     3,     3,
01613        3,     3,     3,     3,     3,     3,     3,     2,     2,     3,
01614        3,     3,     3,     0,     4,     6,     1,     1,     1,     2,
01615        4,     2,     3,     1,     1,     1,     1,     1,     2,     2,
01616        4,     1,     0,     2,     2,     2,     1,     1,     1,     2,
01617        3,     4,     3,     4,     2,     1,     1,     1,     1,     1,
01618        1,     1,     1,     1,     0,     4,     0,     4,     3,     3,
01619        2,     3,     3,     1,     4,     3,     1,     0,     6,     4,
01620        3,     2,     1,     2,     2,     6,     6,     0,     0,     7,
01621        0,     0,     7,     5,     4,     0,     0,     9,     0,     6,
01622        0,     0,     8,     0,     5,     0,     6,     0,     0,     9,
01623        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01624        1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
01625        1,     1,     5,     1,     2,     1,     1,     1,     3,     1,
01626        3,     1,     4,     6,     3,     5,     2,     4,     1,     3,
01627        6,     8,     4,     6,     4,     2,     6,     2,     4,     6,
01628        2,     4,     2,     4,     1,     1,     1,     3,     1,     4,
01629        1,     2,     1,     3,     1,     1,     0,     0,     4,     4,
01630        1,     3,     3,     0,     5,     2,     4,     4,     2,     4,
01631        4,     3,     3,     3,     2,     1,     4,     0,     5,     0,
01632        5,     5,     1,     1,     6,     1,     1,     1,     1,     2,
01633        1,     2,     1,     1,     1,     1,     1,     1,     1,     2,
01634        3,     3,     3,     3,     3,     0,     3,     1,     2,     3,
01635        3,     0,     3,     0,     2,     0,     2,     0,     2,     1,
01636        0,     3,     0,     0,     5,     1,     1,     1,     1,     2,
01637        1,     1,     1,     1,     3,     1,     1,     2,     2,     1,
01638        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01639        1,     1,     1,     1,     1,     1,     0,     4,     2,     3,
01640        2,     6,     8,     4,     6,     4,     6,     2,     4,     6,
01641        2,     4,     2,     4,     1,     0,     1,     1,     1,     1,
01642        1,     1,     1,     3,     1,     3,     3,     3,     1,     3,
01643        1,     3,     1,     1,     2,     1,     1,     1,     2,     2,
01644        1,     1,     0,     4,     1,     2,     1,     3,     3,     2,
01645        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01646        1,     1,     0,     1,     0,     1,     2,     2,     0,     1,
01647        1,     1,     1,     1,     2,     0
01648 };
01649 
01650 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
01651    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
01652    means the default is an error.  */
01653 static const yytype_uint16 yydefact[] =
01654 {
01655        2,     0,     0,     1,     0,   332,   333,   334,     0,   325,
01656      326,   327,   330,   328,   329,   331,   320,   321,   322,   323,
01657      283,   252,   252,   475,   474,   476,   477,   554,     0,   554,
01658       10,     0,   479,   478,   480,   469,   542,   471,   470,   472,
01659      473,   465,   466,   427,   483,   484,     0,     0,     0,     0,
01660        0,   565,   565,    80,   386,   445,   443,   445,   447,   435,
01661      441,     0,     0,     0,     3,   552,     6,     9,    42,    43,
01662       51,    50,     0,    68,     0,    72,    82,     0,    48,   236,
01663        0,   274,     0,     0,   297,   300,   552,     0,     0,     0,
01664        0,    52,   292,   265,   266,   426,   428,   267,   268,   269,
01665      270,   424,   425,   423,   481,   271,     0,   272,   252,     5,
01666        8,   160,   171,   161,   184,   157,   177,   167,   166,   187,
01667      188,   182,   165,   164,   159,   185,   189,   190,   169,   158,
01668      172,   176,   178,   170,   163,   179,   186,   181,   180,   173,
01669      183,   168,   156,   175,   174,   155,   162,   153,   154,   150,
01670      151,   152,   109,   111,   110,   145,   146,   142,   124,   125,
01671      126,   133,   130,   132,   127,   128,   147,   148,   134,   135,
01672      139,   129,   131,   121,   122,   123,   136,   137,   138,   140,
01673      141,   143,   144,   149,   114,   116,   118,    23,   112,   113,
01674      115,   117,     0,     0,     0,     0,     0,     0,     0,   247,
01675        0,   237,   258,    66,   251,   565,     0,   481,     0,   272,
01676      565,   536,    67,    65,   554,    64,     0,   565,   404,    63,
01677      554,   555,     0,     0,    18,   233,     0,     0,   320,   321,
01678      283,   286,   405,   212,     0,     0,   213,   280,     0,     0,
01679        0,   552,    15,   554,    70,    14,   276,     0,   558,   558,
01680      238,     0,     0,   558,   534,   554,     0,     0,     0,    78,
01681      324,     0,    88,    95,   294,   387,   462,   461,   463,   460,
01682        0,   459,     0,     0,     0,     0,     0,     0,     0,   467,
01683      468,    47,   227,   228,   561,   562,     4,   563,   553,     0,
01684        0,     0,     0,     0,     0,     0,   393,   395,     0,    84,
01685        0,    76,    73,     0,     0,     0,     0,     0,     0,     0,
01686        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01687        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01688        0,   565,     0,     0,    49,     0,     0,     0,     0,   552,
01689        0,   553,     0,   346,   345,     0,     0,   481,   272,   104,
01690      105,     0,     0,   107,     0,     0,   481,   272,   313,   180,
01691      173,   183,   168,   150,   151,   152,   109,   110,   532,   315,
01692      531,     0,     0,     0,   409,   407,   293,   429,     0,     0,
01693      398,    57,   291,   119,   539,   280,   259,   254,     0,     0,
01694      256,   248,   257,     0,   565,     0,     0,     0,   256,   249,
01695      554,     0,   285,   253,   554,   246,   245,   554,   290,    46,
01696       20,    22,    21,     0,   287,     0,     0,     0,     0,     0,
01697        0,    17,   554,   278,    13,   553,    69,   554,   281,   560,
01698      559,   239,   560,   241,   282,   535,     0,    94,   467,   468,
01699       86,    81,     0,     0,   565,     0,   505,   449,   452,   450,
01700      464,   446,   430,   444,   431,   432,   448,   433,   434,     0,
01701      437,   439,     0,   440,     0,     0,   564,     7,    24,    25,
01702       26,    27,    28,    44,    45,   565,     0,    31,    40,     0,
01703       41,   554,     0,    74,    85,    30,   191,   258,    39,   209,
01704      217,   222,   223,   224,   219,   221,   231,   232,   225,   226,
01705      202,   203,   229,   230,   554,   218,   220,   214,   215,   216,
01706      204,   205,   206,   207,   208,   543,   548,   544,   549,   403,
01707      252,   401,   554,   543,   545,   544,   546,   402,   252,     0,
01708      565,   337,     0,   336,     0,     0,     0,     0,     0,     0,
01709      280,     0,   565,     0,   305,   310,   104,   105,   106,     0,
01710      486,   308,   485,     0,   565,     0,     0,     0,   505,   551,
01711      550,   317,   543,   544,   252,   252,   565,   565,    32,   193,
01712       38,   201,    55,    58,     0,   191,   538,     0,   260,   255,
01713      565,   547,   544,   554,   543,   544,   537,   284,   556,   242,
01714      289,    19,     0,   234,     0,    29,     0,   565,   200,    71,
01715       16,   277,   558,     0,    79,    91,    93,   554,   543,   544,
01716      511,   508,   507,   506,   509,     0,   523,   527,   526,   522,
01717      505,     0,   390,   510,   512,   514,   565,   520,   565,   525,
01718      565,     0,   504,   453,     0,   436,   438,   442,   210,   211,
01719      378,   565,     0,   376,   375,   264,     0,    83,    77,     0,
01720        0,     0,     0,     0,   400,    61,     0,   406,     0,     0,
01721      244,   399,    59,   243,   335,   275,   565,   565,   415,   565,
01722      338,   565,   340,   298,   339,   301,     0,     0,   304,   547,
01723      279,   554,   543,   544,     0,     0,   488,     0,     0,   104,
01724      105,   108,   554,     0,   554,   505,     0,     0,     0,   397,
01725       54,   396,    53,     0,     0,     0,   565,   120,   261,   250,
01726        0,     0,   406,     0,     0,   554,    11,   240,    87,    89,
01727        0,   511,     0,   358,   349,   351,   554,   347,   565,     0,
01728        0,   388,     0,   497,   530,     0,   500,   524,     0,   502,
01729      528,     0,   455,   456,   457,   451,   458,   511,     0,   565,
01730        0,   565,   518,   565,   565,   374,   380,     0,     0,   262,
01731       75,   192,     0,    37,   198,    36,   199,    62,   557,     0,
01732       34,   196,    35,   197,    60,   416,   417,   565,   418,     0,
01733      565,   343,     0,     0,   341,     0,     0,     0,   303,     0,
01734        0,   406,     0,   311,     0,     0,   406,   314,   533,   554,
01735        0,   490,   318,     0,     0,   194,     0,     0,   288,   516,
01736      554,     0,   356,     0,   513,   554,     0,     0,   515,   565,
01737      565,   529,   565,   521,   565,   565,     0,     0,   384,   381,
01738      382,   385,     0,   377,   365,   367,     0,   370,     0,   372,
01739      394,   263,   235,    33,   195,     0,     0,   420,   344,     0,
01740       12,   422,     0,   295,   296,     0,     0,   260,   565,   306,
01741        0,   487,   309,   489,   316,   505,   410,   408,     0,   348,
01742      359,     0,   354,   350,   389,   392,   391,     0,   493,     0,
01743      495,     0,   501,     0,   498,   503,   454,     0,   517,     0,
01744      379,   565,   565,   565,   519,   565,   565,     0,   419,     0,
01745       96,   103,     0,   421,     0,   299,   302,   412,   413,   411,
01746        0,     0,     0,    56,     0,   357,     0,   352,   565,   565,
01747      565,   565,   280,     0,   383,     0,   362,     0,   364,   371,
01748        0,   368,   373,   102,     0,   565,     0,   565,   565,     0,
01749      312,     0,   355,     0,   494,     0,   491,   496,   499,   547,
01750      279,   565,   565,   565,   565,   547,   101,   554,   543,   544,
01751      414,   342,   307,   319,   353,   565,   363,     0,   360,   366,
01752      369,   406,   492,   565,   361
01753 };
01754 
01755 /* YYDEFGOTO[NTERM-NUM].  */
01756 static const yytype_int16 yydefgoto[] =
01757 {
01758       -1,     1,     2,    64,    65,    66,   226,   529,   530,   241,
01759      242,   413,    68,   335,    69,    70,   573,   706,    71,    72,
01760      243,    73,    74,    75,   441,    76,   200,   353,   354,   184,
01761      185,   186,   187,   574,   526,   189,    78,   415,   202,   247,
01762      519,   661,   404,   405,   215,   216,   204,   391,   205,   480,
01763       79,   333,   427,   592,   337,   786,   338,   787,   684,   910,
01764      688,   685,   860,   556,   558,   698,   865,   234,    81,    82,
01765       83,    84,    85,    86,    87,    88,    89,    90,   665,   532,
01766      673,   783,   784,   346,   724,   725,   726,   749,   642,   643,
01767      750,   829,   830,   264,   265,   446,   621,   731,   297,   475,
01768       91,    92,   382,   567,   566,   539,   909,   667,   777,   846,
01769      850,    93,    94,    95,    96,    97,    98,    99,   276,   459,
01770      100,   278,   272,   270,   274,   451,   634,   633,   741,   745,
01771      101,   271,   102,   103,   207,   105,   208,   209,   551,   687,
01772      696,   697,   623,   624,   625,   626,   627,   752,   753,   628,
01773      629,   630,   631,   821,   733,   371,   557,   252,   210,   211,
01774      108,   596,   521,   561,   286,   401,   402,   657,   431,   533,
01775      341,   245
01776 };
01777 
01778 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01779    STATE-NUM.  */
01780 #define YYPACT_NINF -778
01781 static const yytype_int16 yypact[] =
01782 {
01783     -778,   133,  2394,  -778,  7010,  -778,  -778,  -778,  6523,  -778,
01784     -778,  -778,  -778,  -778,  -778,  -778,  7228,  7228,  -778,  -778,
01785     7228,  3145,  2722,  -778,  -778,  -778,  -778,   164,  6384,   -11,
01786     -778,    69,  -778,  -778,  -778,  5623,  2863,  -778,  -778,  5750,
01787     -778,  -778,  -778,  -778,  -778,  -778,  8427,  8427,    96,  4342,
01788     8536,  7446,  7773,  6786,  -778,  6245,  -778,  -778,  -778,    74,
01789       93,   122,  8645,  8427,  -778,   187,  -778,   698,   288,  -778,
01790     -778,   230,   167,  -778,   180,  8754,  -778,   234,  2846,   273,
01791      310,  -778,  8536,  8536,  -778,  -778,  4986,  8859,  8964,  9069,
01792     5496,    16,    60,  -778,  -778,   174,  -778,  -778,  -778,  -778,
01793     -778,  -778,  -778,  -778,   201,  -778,   258,   282,   206,  -778,
01794     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01795     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01796     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01797     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01798     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01799     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01800     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01801     -778,  -778,  -778,  -778,  -778,  -778,  -778,   212,  -778,  -778,
01802     -778,  -778,   215,  8427,   303,  4472,  8427,  8427,  8427,  -778,
01803      257,  2846,   285,  -778,  -778,   281,   343,    38,   337,   263,
01804      290,  -778,  -778,  -778,  4877,  -778,  7228,  7228,  -778,  -778,
01805     5116,  -778,  8536,   599,  -778,   296,   315,  4602,  -778,  -778,
01806     -778,   311,   328,  -778,   347,   206,   396,   446,  7119,  4342,
01807      329,   187,   698,   -11,   370,  -778,   288,   339,   -30,    30,
01808     -778,   285,   356,    30,  -778,   -11,   442,   375,  9174,   390,
01809     -778,   351,   373,   383,  -778,  -778,  -778,  -778,  -778,  -778,
01810      515,  -778,   552,   587,   620,   397,   607,   407,    34,   473,
01811      474,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  5225,  8536,
01812     8536,  8536,  8536,  7119,  8536,  8536,  -778,  -778,  7882,  -778,
01813     4342,  6898,   413,  7882,  8427,  8427,  8427,  8427,  8427,  8427,
01814     8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,
01815     8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,
01816     1712,  7228,  2060,  3517,   288,    80,    80,  8536,  8536,   187,
01817      534,   416,   516,  -778,  -778,   386,   568,    50,    72,   301,
01818      321,  8536,   363,  -778,    66,   393,  -778,  -778,  -778,    36,
01819       41,   103,   224,   259,   266,   322,   348,   369,  -778,  -778,
01820     -778,   377, 10211, 10211,  -778,  -778,  -778,  -778,  8645,  8645,
01821     -778,   483,  -778,  -778,  -778,   268,  -778,  -778,  8427,  8427,
01822     7337,  -778,  -778,  2216,  7228,  9441,  8427,  8427,  7555,  -778,
01823      -11,   454,  -778,  -778,   -11,  -778,  -778,    70,  -778,  -778,
01824     -778,  -778,  -778,  6523,  -778,  8427,  3937,   463,  2216,  9441,
01825     8427,   698,   -11,  -778,  -778,  5353,   462,   -11,  -778,  7664,
01826     -778,  -778,  7773,  -778,  -778,  -778,   296,   411,  -778,  -778,
01827     -778,   467,  9174,  9518,  7228,  9595,  1033,  -778,  -778,  -778,
01828     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,    39,
01829     -778,  -778,   472,  -778,  8427,  8427,  -778,  -778,  -778,  -778,
01830     -778,  -778,  -778,  -778,  -778,    28,  8427,  -778,   468,   487,
01831     -778,   -11,  9174,   496,  -778,  -778,  1576,  -778,  -778,   396,
01832     1512,  1512,  1512,  1512,  1223,  1223,  1879,  2079,  1512,  1512,
01833     2146,  2146,   582,   582,  2705,  1223,  1223,  1098,  1098,   790,
01834      514,   514,   396,   396,   396,  3286,  5991,  3372,  6105,  -778,
01835      328,  -778,   -11,   448,  -778,   451,  -778,  -778,  3004,   639,
01836      644,  -778,  3662,   646,  4082,    42,    42,   534,  7991,   639,
01837      109,  9672,  7228,  9749,  -778,   288,  -778,   411,  -778,   187,
01838     -778,  -778,  -778,  9826,  7228,  9903,  3517,  8536,  1115,  -778,
01839     -778,  -778,  -778,  -778,  1235,  1235,    28,    28,  -778, 10270,
01840     -778,  2846,  -778,  -778,  6523, 10289,  -778,  8427,   285,  -778,
01841      290,  5877,  2581,   -11,   410,   529,  -778,  -778,  -778,  -778,
01842     -778,  -778,  8536,  2846,   535,  -778,   328,   328,  2846,    20,
01843      698,  -778,    30,  9174,   467,   338,   271,   -11,   228,   261,
01844      557,  -778,  -778,  -778,  -778,   666,  -778,  -778,  -778,  -778,
01845      923,    43,  -778,  -778,  -778,  -778,   543,  -778,   544,   623,
01846      547,   642,  -778,  -778,   722,  -778,  -778,  -778,   396,   396,
01847     -778,   904,  4747,  -778,  -778,   555,  8100,  -778,   467,  9174,
01848     8427,   598,  8645,  8645,  -778,   483,   570,   538,  8645,  8645,
01849     -778,  -778,   483,  -778,  -778,  -778,  8209,   701,  -778,   441,
01850     -778,   701,  -778,  -778,  -778,  -778,   639,    31,  -778,   110,
01851      132,   -11,   126,   144,  8536,   187,  -778,  8536,  3517,   338,
01852      271,  -778,   -11,   639,    70,   923,  3517,   187,  6662,  -778,
01853     -778,  -778,  -778,  4747,  4602,  8427,    28,  -778,  -778,  -778,
01854     8427,  8427,   536,  8427,  8427,    70,  -778,  -778,  -778,   251,
01855     8427,  -778,   666,   450,  -778,   579,   -11,  -778,   583,  4747,
01856     4602,  -778,   923,  -778,  -778,   923,  -778,  -778,   779,  -778,
01857     -778,  4602,  -778,  -778,  -778,  -778,  -778,   625,   809,   583,
01858      615,   595,  -778,   604,   605,  -778,  -778,   740,  8427,   619,
01859      467,  2846,  8427,  -778,  2846,  -778,  2846,  -778,  -778,  8645,
01860     -778,  2846,  -778,  2846,  -778,   468,  -778,   675,  -778,  4212,
01861      757,  -778,  8536,   639,  -778,   639,  4747,  4747,  -778,  8318,
01862     3807,   147,    42,  -778,   187,   639,  -778,  -778,  -778,   -11,
01863      639,  -778,  -778,   759,   630,  2846,  4602,  8427,  -778,  -778,
01864      -11,   845,   632,   826,  -778,   -11,   760,   637,  -778,   640,
01865      643,  -778,   647,  -778,   651,   647,   656,  9279,  -778,   657,
01866     -778,  -778,   682,  -778,  1199,  -778,  1199,  -778,   779,  -778,
01867     -778,   658,  2846,  -778,  2846,  9384,    80,  -778,  -778,  4747,
01868     -778,  -778,    80,  -778,  -778,   639,   639,  -778,   115,  -778,
01869     3517,  -778,  -778,  -778,  -778,  1115,  -778,  -778,   664,  -778,
01870      662,   845,   491,  -778,  -778,  -778,  -778,   923,  -778,   779,
01871     -778,   779,  -778,   779,  -778,  -778,  -778,   751,   429,   809,
01872     -778,   672,   673,   647,  -778,   679,   647,   765,  -778,   432,
01873      373,   383,  3517,  -778,  3662,  -778,  -778,  -778,  -778,  -778,
01874     4747,   639,  3517,  -778,   845,   662,   845,   685,   647,   686,
01875      647,   647,  -778,  9980,  -778,  1199,  -778,   779,  -778,  -778,
01876      779,  -778,  -778,   411, 10057,  7228, 10134,   644,   441,   639,
01877     -778,   639,   662,   845,  -778,   779,  -778,  -778,  -778,   688,
01878      690,   647,   687,   647,   647,    81,   271,   -11,    86,   118,
01879     -778,  -778,  -778,  -778,   662,   647,  -778,   779,  -778,  -778,
01880     -778,   124,  -778,   647,  -778
01881 };
01882 
01883 /* YYPGOTO[NTERM-NUM].  */
01884 static const yytype_int16 yypgoto[] =
01885 {
01886     -778,  -778,  -778,   399,  -778,    33,  -778,  -530,   -33,  -778,
01887      159,  -778,    23,   -55,    21,  -778,  -462,  -778,   -15,   741,
01888     -136,    -1,   -66,  -778,  -403,   -26,  1181,  -306,   750,   -52,
01889     -778,   -20,  -778,  -778,    32,  -778,   748,  -778,   540,  -778,
01890       46,   -98,  -298,    54,    76,  -778,  -278,  -196,   -44,  -283,
01891       27,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01892     -778,  -778,  -778,  -778,  -778,  -778,  -778,     2,  -778,  -778,
01893     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,   298,  -323,
01894     -512,   -97,  -610,  -778,  -755,  -748,   120,  -778,  -485,  -778,
01895     -636,  -778,   -49,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01896     -778,  -778,   752,  -778,  -778,  -520,  -778,   -92,  -778,  -778,
01897     -778,  -778,  -778,  -778,   753,  -778,  -778,  -778,  -778,  -778,
01898     -778,  -778,  -778,   792,  -778,  -229,  -778,  -778,  -778,  -778,
01899        7,  -778,    13,  -778,  1031,   762,  1198,  1109,  -778,  -778,
01900      -12,  -416,  -706,  -549,  -667,  -121,  -679,  -777,    25,   128,
01901     -778,  -579,  -778,  -434,   531,  -778,  -778,  -778,   -41,  -287,
01902     1927,  -254,  -778,  -778,   -32,    -4,    88,  -554,  -217,    63,
01903      -31,    -2
01904 };
01905 
01906 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
01907    positive, shift that token.  If negative, reduce the rule which
01908    number is the opposite.  If zero, do what YYDEFACT says.
01909    If YYTABLE_NINF, syntax error.  */
01910 #define YYTABLE_NINF -566
01911 static const yytype_int16 yytable[] =
01912 {
01913      109,   199,   199,   269,    80,   199,    80,   248,   224,   302,
01914      249,   253,   632,   534,   399,   190,   240,   676,   206,   206,
01915      488,   191,   206,   222,   675,   225,   693,   259,   336,   712,
01916      622,   339,   433,   522,   288,   190,   435,   110,   369,   604,
01917      188,   191,   831,   453,   531,   456,   548,   460,   244,   250,
01918      254,    80,   206,   719,   340,   261,   823,   780,   873,   894,
01919      188,   785,   754,   870,   206,   818,   727,   549,   218,   672,
01920      203,   212,   729,   246,   213,   -96,   520,   261,   528,   648,
01921      260,   703,   704,   281,   206,   206,   374,   188,   206,   345,
01922      355,   355,   815,   531,   -99,   462,   583,  -103,   219,   -98,
01923      447,   372,   260,   422,   640,   334,   334,   294,   295,   334,
01924      429,   586,   579,   832,   260,   260,   260,   430,   564,   565,
01925      579,  -475,   188,   915,   632,  -482,  -474,   791,   287,   -69,
01926      779,  -100,   538,     3,  -102,   -99,   221,   -97,   796,   520,
01927      463,   528,   641,   448,   449,   586,   607,   -96,   894,   287,
01928      730,   -98,   237,   820,   380,   373,   824,  -101,   795,   873,
01929      -83,    67,   240,    67,   481,   597,   800,   818,   942,  -100,
01930      432,   789,   -97,   727,   812,  -475,   284,   430,   285,   550,
01931     -474,   279,   280,   831,   381,   635,   632,   284,  -476,   285,
01932      -88,   597,   440,   767,   417,   964,   375,    80,   823,   199,
01933      774,   199,   199,   392,   728,   227,   240,   755,   392,   424,
01934      425,   284,   -95,   285,   818,   406,   206,   221,   206,   206,
01935      275,   806,   206,  -543,   206,   284,   -99,   285,   -99,    80,
01936      636,   -98,   374,   -98,   468,   469,   470,   471,   244,   277,
01937       80,    80,  -476,   407,   681,   409,   760,   691,   907,   -94,
01938      -91,   436,  -543,   -90,   479,   892,   692,   895,   296,   479,
01939      261,   632,   727,  -100,   727,  -100,   -90,   240,   400,   -97,
01940      403,   -97,   -93,    56,  -544,   483,   298,  -406,   218,   799,
01941      859,   380,   535,   536,   -92,   260,   -92,   -89,  -482,   597,
01942       80,   206,   206,   206,   206,    80,   206,   206,   919,   244,
01943      206,   597,    80,   261,   287,   206,   220,   537,   408,  -477,
01944      -96,   221,   334,   334,   334,   334,   199,   473,   474,   477,
01945      299,   467,   727,   917,   485,   294,   295,  -540,   260,   406,
01946      911,   426,   284,   206,   285,    80,  -406,   -90,   908,   206,
01947      206,   -88,   375,   303,  -479,   378,   952,  -541,   217,   580,
01948      397,  -478,   383,   206,   790,   420,  -279,   220,  -324,   385,
01949      334,   334,   518,  -477,  -547,   727,   388,   727,   -90,   379,
01950      -92,   -90,  -103,   389,   545,   -90,   440,  -102,   527,   199,
01951      206,   206,   941,   776,   709,   717,  -469,  -406,   602,  -406,
01952     -406,  -103,   406,   591,   727,   330,   206,   421,  -479,   568,
01953      570,   -92,   287,   971,   -92,  -478,  -472,  -480,   -92,  -279,
01954     -279,  -324,  -324,  -544,   109,   546,   440,   552,    80,   547,
01955      190,   390,   -95,  -547,   396,   518,   191,    80,   393,   199,
01956      398,   632,   418,  -469,   438,   439,   443,  -540,   414,  -469,
01957     -469,   527,   406,  -540,   261,   188,   206,    67,   331,   332,
01958      518,   416,   472,   214,  -472,   782,   779,  -541,  -481,  -472,
01959     -472,  -480,   559,  -541,   304,   527,   699,   701,  -272,   260,
01960      217,   541,   423,   644,  -547,   518,  -547,  -547,   553,   -68,
01961     -543,   394,   395,   428,   261,   394,   419,  -469,   587,   444,
01962      445,   527,   589,   434,   677,   590,  -280,   713,   437,   669,
01963      651,   671,   721,   457,   611,   612,   613,   614,  -472,   260,
01964      599,  -481,  -481,   461,   923,   601,   560,   934,   656,   -98,
01965      751,  -272,  -272,   902,   542,   543,   663,   199,   668,   904,
01966      442,   554,   555,   420,    80,   658,    80,   718,   659,   199,
01967      406,   464,   465,   721,   206,   611,   612,   613,   614,  -280,
01968     -280,   538,   406,   484,   707,  -102,   206,   -98,    80,   206,
01969     -100,   466,   663,   663,   644,   644,   654,   554,   555,   647,
01970      935,   936,   540,   518,   660,    67,   447,   572,   392,   656,
01971      694,   190,   304,   440,   600,   518,   -94,   191,   -90,   527,
01972      811,   -92,   251,   544,   206,   663,   655,   588,   674,   674,
01973      595,   527,   -83,   656,   662,   261,   188,   603,  -258,   757,
01974      660,   660,   686,   447,   822,   715,   714,   825,   637,   448,
01975      449,   450,   479,   807,   734,   769,   734,   646,   734,   792,
01976      260,   916,   794,   327,   328,   329,   649,   957,  -100,   756,
01977      700,   702,   654,   660,    80,   -97,   802,   -97,   447,   664,
01978      304,   261,   666,   410,   206,   206,   448,   449,   452,   670,
01979      206,   206,   411,   412,   778,   781,   720,   781,   447,   781,
01980      803,   804,   716,   763,   765,   737,   260,   656,   -89,   770,
01981      772,   447,   597,   732,   735,   455,   206,   738,   656,   206,
01982       80,   448,   449,   454,   740,  -259,   816,   817,    80,   325,
01983      326,   327,   328,   329,   644,    80,    80,   334,   826,   762,
01984      334,   448,   449,   458,   768,   893,   779,   896,   721,   813,
01985      611,   612,   613,   614,   448,   449,   756,   852,   748,   833,
01986      188,    80,    80,   384,   827,   834,   386,   387,   289,   290,
01987      291,   292,   293,    80,   836,   838,   848,   756,   793,   734,
01988      840,   734,   734,   855,   856,   722,   918,   858,   920,  -260,
01989      801,   723,   921,   845,   201,   201,   849,   867,   201,   866,
01990      875,   206,   871,   868,   876,   847,   742,   743,   851,   744,
01991      877,    80,   798,   879,   206,    44,    45,   881,    80,    80,
01992      843,   883,    80,   886,   233,   236,   890,   889,  -261,   201,
01993      201,   913,   914,   808,   951,   334,   953,   922,    80,   954,
01994      282,   283,   925,   927,   814,   594,   903,   734,   734,   930,
01995      734,   933,   734,   734,   965,   943,   945,   967,   343,   888,
01996     -543,   721,  -544,   611,   612,   613,   614,   678,   478,   358,
01997      924,   961,   810,   487,   376,   960,   973,   899,   377,   273,
01998        0,    80,   370,   912,   260,   674,   781,   861,   304,   891,
01999      819,   828,    80,   611,   612,   613,   614,     0,   615,   937,
02000        0,   938,   260,   317,   318,   617,     0,   939,   721,     0,
02001      611,   612,   613,   614,     0,     0,     0,   863,     0,   734,
02002      734,   734,     0,   734,   734,   618,     0,   721,   869,   611,
02003      612,   613,   614,   874,    80,     0,    80,   325,   326,   327,
02004      328,   329,    80,     0,    80,   722,   734,   734,   734,   734,
02005      199,   872,     0,     0,     0,     0,     0,     0,     0,   576,
02006      578,     0,     0,   406,   722,   668,   781,   206,   251,     0,
02007        0,   201,     0,     0,   201,   201,   282,     0,     0,   734,
02008      734,   734,   734,   656,     0,   518,   747,     0,   611,   612,
02009      613,   614,   201,   734,   201,   201,   518,     0,     0,   578,
02010        0,   734,   251,     0,   788,   610,     0,   611,   612,   613,
02011      614,     0,   527,     0,     0,     0,     0,     0,     0,     0,
02012        0,   797,     0,   615,     0,     0,     0,     0,     0,   616,
02013      617,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02014        0,     0,   615,     0,     0,     0,   645,     0,   616,   617,
02015      618,     0,     0,   619,     0,     0,     0,     0,     0,     0,
02016        0,     0,     0,   104,     0,   104,     0,     0,     0,   618,
02017        0,     0,   619,     0,     0,     0,   201,     0,     0,   748,
02018        0,   486,   489,   490,   491,   492,   493,   494,   495,   496,
02019      497,   498,   499,   500,   501,   502,   503,   504,   505,   506,
02020      507,   508,   509,   510,   511,   512,   513,   514,   487,   201,
02021      104,   853,     0,   854,   262,   610,     0,   611,   612,   613,
02022      614,     0,     0,   862,     0,     0,     0,     0,   864,     0,
02023        0,     0,     0,     0,     0,     0,   262,     0,     0,     0,
02024        0,   107,     0,   107,     0,     0,     0,   708,   347,   356,
02025      356,   356,   615,     0,     0,     0,   569,   571,   616,   617,
02026        0,     0,     0,     0,     0,     0,   575,   201,   201,     0,
02027        0,     0,   201,     0,   569,   571,   201,     0,     0,   618,
02028        0,     0,   619,   905,   906,     0,     0,     0,   107,   736,
02029        0,   739,   263,   593,     0,     0,   304,   610,   598,   611,
02030      612,   613,   614,     0,     0,   620,     0,   201,     0,     0,
02031      201,   317,   318,    77,   263,    77,   759,     0,     0,     0,
02032        0,     0,   201,     0,     0,     0,   348,   357,   357,     0,
02033      106,     0,   106,     0,   615,     0,   775,     0,     0,   940,
02034      616,   617,   638,   639,   324,   325,   326,   327,   328,   329,
02035        0,     0,     0,     0,   201,     0,   104,     0,     0,     0,
02036       77,   618,     0,     0,   619,  -565,     0,   962,     0,   963,
02037        0,     0,     0,  -565,  -565,  -565,     0,   106,  -565,  -565,
02038     -565,   747,  -565,   611,   612,   613,   614,   695,   104,     0,
02039      809,     0,  -565,     0,     0,     0,     0,     0,   344,   104,
02040      104,     0,  -565,  -565,     0,  -565,  -565,  -565,  -565,  -565,
02041        0,     0,   835,     0,   837,   839,   201,     0,   615,   262,
02042      201,   304,     0,     0,   616,   617,     0,     0,   841,     0,
02043        0,     0,   201,     0,   107,     0,   317,   318,     0,     0,
02044        0,     0,     0,     0,     0,   618,     0,     0,   619,   104,
02045     -565,     0,     0,     0,   104,   201,     0,     0,     0,   857,
02046        0,   104,   262,     0,     0,     0,   107,   322,   323,   324,
02047      325,   326,   327,   328,   329,     0,     0,   107,   107,     0,
02048      878,   880,     0,   882,     0,   884,   885,     0,     0,     0,
02049        0,     0,     0,     0,   104,     0,     0,   263,     0,     0,
02050        0,     0,  -565,     0,  -565,     0,    77,   217,  -565,     0,
02051     -565,     0,  -565,     0,     0,     0,     0,     0,     0,     0,
02052        0,     0,     0,   106,   201,     0,     0,   107,   761,     0,
02053      764,   766,   107,     0,     0,     0,   771,   773,    77,   107,
02054      263,     0,     0,     0,   201,     0,     0,     0,     0,    77,
02055       77,     0,   926,   928,   929,   106,   931,   932,     0,     0,
02056        0,     0,     0,     0,     0,     0,   106,   106,     0,     0,
02057        0,     0,   107,     0,     0,     0,     0,   104,     0,   944,
02058      946,   947,   948,   805,     0,     0,   104,     0,   764,   766,
02059        0,   771,   773,     0,     0,     0,     0,     0,   201,    77,
02060        0,     0,     0,   262,    77,     0,     0,     0,     0,     0,
02061        0,    77,   966,   968,   969,   970,   106,     0,     0,     0,
02062        0,   106,     0,     0,     0,     0,   972,     0,   106,     0,
02063        0,     0,     0,     0,   974,     0,   201,     0,     0,     0,
02064      842,     0,     0,   262,    77,     0,     0,   844,     0,     0,
02065        0,     0,     0,     0,     0,   107,     0,     0,     0,     0,
02066        0,   106,     0,     0,   107,     0,     0,   201,     0,     0,
02067        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02068        0,   263,     0,     0,     0,   844,     0,     0,     0,     0,
02069        0,     0,     0,   104,     0,   104,     0,     0,     0,     0,
02070        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02071      304,  -566,  -566,  -566,  -566,   309,   310,   104,     0,  -566,
02072     -566,   263,     0,     0,     0,   317,   318,    77,     0,     0,
02073        0,     0,     0,     0,     0,     0,    77,     0,     0,     0,
02074        0,     0,     0,     0,   106,     0,     0,     0,     0,     0,
02075      650,     0,     0,   106,   320,   321,   322,   323,   324,   325,
02076      326,   327,   328,   329,   262,     0,     0,     0,     0,     0,
02077        0,   107,     0,   107,   304,   305,   306,   307,   308,   309,
02078      310,   311,   312,   313,   314,   315,   316,     0,     0,   317,
02079      318,     0,     0,     0,     0,   107,     0,     0,     0,     0,
02080        0,     0,     0,   104,     0,     0,     0,     0,     0,     0,
02081      262,     0,     0,   201,     0,     0,   319,     0,   320,   321,
02082      322,   323,   324,   325,   326,   327,   328,   329,     0,     0,
02083        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02084        0,     0,   263,    77,     0,    77,  -237,     0,     0,   104,
02085        0,     0,     0,     0,     0,     0,     0,   104,     0,     0,
02086      106,     0,   106,     0,   104,   104,     0,    77,     0,     0,
02087        0,     0,     0,   746,     0,     0,     0,     0,     0,     0,
02088        0,   107,     0,     0,   106,     0,     0,     0,   263,     0,
02089      104,   104,     0,     0,   515,   516,     0,     0,   517,     0,
02090        0,     0,   104,     0,     0,     0,     0,     0,   155,   156,
02091      157,   158,   159,   160,   161,   162,   163,     0,     0,   164,
02092      165,     0,     0,   166,   167,   168,   169,   107,     0,     0,
02093        0,     0,     0,     0,     0,   107,     0,   170,     0,     0,
02094      104,     0,   107,   107,     0,     0,     0,   104,   104,     0,
02095        0,   104,     0,    77,   171,   172,   173,   174,   175,   176,
02096      177,   178,   179,   180,     0,   181,   182,   104,   107,   107,
02097      106,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02098      107,     0,     0,   183,   217,     0,     0,     0,   356,     0,
02099        0,     0,     0,     0,     0,     0,     0,     0,     0,    77,
02100        0,     0,     0,     0,     0,     0,   900,    77,     0,     0,
02101      104,     0,     0,     0,    77,    77,   106,     0,   107,     0,
02102        0,   104,     0,     0,   106,   107,   107,     0,     0,   107,
02103        0,   106,   106,     0,     0,     0,     0,     0,     0,     0,
02104       77,    77,     0,     0,     0,   107,     0,     0,     0,     0,
02105        0,     0,    77,     0,     0,     0,     0,   106,   106,     0,
02106        0,     0,     0,   104,     0,   104,   357,     0,     0,   106,
02107        0,   104,     0,   104,     0,     0,     0,   304,   305,   306,
02108      307,   308,   309,   310,   901,     0,   313,   314,   107,     0,
02109       77,     0,   317,   318,     0,     0,     0,    77,    77,   107,
02110        0,    77,     0,   235,   235,     0,     0,   106,   235,   235,
02111      235,     0,     0,     0,   106,   106,     0,    77,   106,     0,
02112      235,   320,   321,   322,   323,   324,   325,   326,   327,   328,
02113      329,     0,   235,     0,   106,     0,     0,     0,     0,     0,
02114        0,   107,     0,   107,   235,   235,   235,     0,     0,   107,
02115        0,   107,     0,     0,     0,     0,   898,     0,     0,     0,
02116       77,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02117        0,    77,     0,     0,     0,     0,     0,   106,     0,     0,
02118        0,     0,     0,     0,     0,     0,     0,     0,   106,     0,
02119        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02120        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02121        0,     0,     0,    77,     0,    77,     0,     0,     0,     0,
02122        0,    77,     0,    77,     0,     0,     0,     0,     0,     0,
02123      106,     0,   106,     0,     0,     0,     0,     0,   106,     0,
02124      106,     0,   523,   524,     0,     0,   525,     0,     0,     0,
02125      235,     0,     0,   235,   235,   235,   155,   156,   157,   158,
02126      159,   160,   161,   162,   163,     0,     0,   164,   165,     0,
02127        0,   166,   167,   168,   169,     0,     0,   304,   305,   306,
02128      307,   308,   309,   310,   311,   170,   313,   314,     0,     0,
02129        0,     0,   317,   318,     0,     0,     0,     0,     0,     0,
02130        0,     0,   171,   172,   173,   174,   175,   176,   177,   178,
02131      179,   180,     0,   181,   182,   235,     0,     0,     0,     0,
02132        0,   320,   321,   322,   323,   324,   325,   326,   327,   328,
02133      329,   183,   217,     0,     0,     0,     0,     0,     0,     0,
02134        0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
02135      310,   311,   312,   313,   314,  -566,  -566,     0,   235,   317,
02136      318,   235,   235,   235,   235,   235,   235,   235,   235,   235,
02137      235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
02138      235,   235,   235,   235,   235,   235,   235,     0,   320,   321,
02139      322,   323,   324,   325,   326,   327,   328,   329,   581,   516,
02140        0,     0,   582,     0,     0,     0,     0,     0,     0,     0,
02141        0,     0,   155,   156,   157,   158,   159,   160,   161,   162,
02142      163,     0,     0,   164,   165,     0,     0,   166,   167,   168,
02143      169,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02144        0,   170,     0,     0,     0,   235,   235,   235,     0,     0,
02145        0,     0,     0,   235,   235,   235,     0,     0,   171,   172,
02146      173,   174,   175,   176,   177,   178,   179,   180,     0,   181,
02147      182,     0,   235,     0,     0,     0,     0,   235,     0,     0,
02148        0,     0,     0,     0,     0,     0,   235,   183,   217,   235,
02149        0,     0,     0,     0,     0,     0,     0,     0,     0,   235,
02150        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02151        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02152        0,   235,   235,     0,  -565,     4,     0,     5,     6,     7,
02153        8,     9,     0,   235,     0,    10,    11,     0,     0,   235,
02154       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02155        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02156       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02157       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
02158       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02159       46,    47,     0,     0,     0,   235,     0,     0,     0,     0,
02160        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02161       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02162        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02163        0,     0,     0,     0,   235,     0,     0,     0,     0,     0,
02164        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02165        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02166      235,     0,     0,     0,     0,     0,     0,     0,     0,  -565,
02167        0,  -565,     0,     0,     0,     0,     0,     0,     0,     0,
02168        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02169        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02170        0,     0,     0,   235,     0,     0,   235,   235,     0,     0,
02171        0,  -279,     0,     0,     0,     0,     0,     0,     0,  -279,
02172     -279,  -279,     0,   235,  -279,  -279,  -279,     0,  -279,     0,
02173        0,     0,     0,     0,     0,     0,     0,     0,  -279,  -279,
02174     -279,     0,     0,     0,     0,     0,     0,     0,  -279,  -279,
02175        0,  -279,  -279,  -279,  -279,  -279,     0,     0,     0,     0,
02176        0,     0,   235,     0,     0,     0,     0,   235,   235,     0,
02177      235,   235,     0,     0,     0,     0,     0,   235,     0,  -279,
02178     -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02179     -279,  -279,     0,     0,  -279,  -279,  -279,     0,   711,  -279,
02180        0,     0,     0,     0,     0,  -279,     0,     0,     0,     0,
02181        0,     0,     0,     0,     0,   235,     0,     0,  -279,   235,
02182     -101,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02183     -279,  -279,  -279,     0,     0,     0,     0,     0,     0,     0,
02184        0,     0,     0,     0,     0,     0,   235,     0,  -279,  -279,
02185     -279,  -279,  -405,     0,  -279,  -279,  -279,     0,  -279,     0,
02186     -405,  -405,  -405,     0,   235,  -405,  -405,  -405,     0,  -405,
02187        0,     0,     0,     0,     0,     0,     0,     0,  -405,  -405,
02188     -405,     0,     0,     0,   235,     0,     0,     0,     0,  -405,
02189     -405,     0,  -405,  -405,  -405,  -405,  -405,     0,     0,     0,
02190        0,     0,   235,   304,   305,   306,   307,   308,   309,   310,
02191      311,   312,   313,   314,   315,   316,     0,     0,   317,   318,
02192     -405,  -405,  -405,  -405,  -405,  -405,  -405,  -405,  -405,  -405,
02193     -405,  -405,  -405,     0,     0,  -405,  -405,  -405,     0,     0,
02194     -405,     0,     0,     0,     0,   319,  -405,   320,   321,   322,
02195      323,   324,   325,   326,   327,   328,   329,     0,     0,     0,
02196        0,     0,  -405,     0,  -405,  -405,  -405,  -405,  -405,  -405,
02197     -405,  -405,  -405,  -405,     0,     0,     0,     0,     0,     0,
02198        0,     0,   221,     0,     0,     0,     0,     0,  -405,  -405,
02199     -405,  -405,  -405,  -273,   217,  -405,  -405,  -405,     0,  -405,
02200        0,  -273,  -273,  -273,     0,     0,  -273,  -273,  -273,     0,
02201     -273,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02202     -273,  -273,  -273,     0,     0,     0,     0,     0,     0,     0,
02203     -273,  -273,     0,  -273,  -273,  -273,  -273,  -273,     0,     0,
02204        0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
02205      310,   311,   312,   313,   314,   315,   316,     0,     0,   317,
02206      318,  -273,  -273,  -273,  -273,  -273,  -273,  -273,  -273,  -273,
02207     -273,  -273,  -273,  -273,     0,     0,  -273,  -273,  -273,     0,
02208        0,  -273,     0,     0,     0,     0,   319,  -273,   320,   321,
02209      322,   323,   324,   325,   326,   327,   328,   329,     0,     0,
02210     -273,     0,     0,  -273,  -273,  -273,  -273,  -273,  -273,  -273,
02211     -273,  -273,  -273,  -273,  -273,     0,     0,     0,     0,     0,
02212        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02213     -273,  -273,  -273,  -273,  -565,     0,  -273,  -273,  -273,     0,
02214     -273,     0,  -565,  -565,  -565,     0,     0,  -565,  -565,  -565,
02215        0,  -565,     0,     0,     0,     0,     0,     0,     0,     0,
02216     -565,  -565,  -565,     0,     0,     0,     0,     0,     0,     0,
02217        0,  -565,  -565,     0,  -565,  -565,  -565,  -565,  -565,     0,
02218        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02219        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02220        0,     0,  -565,  -565,  -565,  -565,  -565,  -565,  -565,  -565,
02221     -565,  -565,  -565,  -565,  -565,     0,     0,  -565,  -565,  -565,
02222        0,     0,  -565,     0,     0,     0,     0,     0,  -565,     0,
02223        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02224        0,     0,     0,     0,  -565,     0,  -565,  -565,  -565,  -565,
02225     -565,  -565,  -565,  -565,  -565,  -565,     0,     0,     0,     0,
02226        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02227     -565,  -565,  -565,  -565,  -565,  -286,   217,  -565,  -565,  -565,
02228        0,  -565,     0,  -286,  -286,  -286,     0,     0,  -286,  -286,
02229     -286,     0,  -286,     0,     0,     0,     0,     0,     0,     0,
02230        0,     0,  -286,  -286,     0,     0,     0,     0,     0,     0,
02231        0,     0,  -286,  -286,     0,  -286,  -286,  -286,  -286,  -286,
02232        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02233        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02234        0,     0,     0,  -286,  -286,  -286,  -286,  -286,  -286,  -286,
02235     -286,  -286,  -286,  -286,  -286,  -286,     0,     0,  -286,  -286,
02236     -286,     0,     0,  -286,     0,     0,     0,     0,     0,  -286,
02237        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02238        0,     0,     0,     0,     0,  -286,     0,  -286,  -286,  -286,
02239     -286,  -286,  -286,  -286,  -286,  -286,  -286,     0,     0,     0,
02240        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02241        0,     0,  -286,  -286,  -286,  -286,  -547,   214,  -286,  -286,
02242     -286,     0,  -286,     0,  -547,  -547,  -547,     0,     0,     0,
02243     -547,  -547,     0,  -547,     0,     0,     0,     0,     0,     0,
02244        0,     0,  -547,     0,     0,     0,     0,     0,     0,     0,
02245        0,     0,     0,  -547,  -547,     0,  -547,  -547,  -547,  -547,
02246     -547,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02247        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02248        0,     0,     0,     0,  -547,  -547,  -547,  -547,  -547,  -547,
02249     -547,  -547,  -547,  -547,  -547,  -547,  -547,     0,     0,  -547,
02250     -547,  -547,  -279,   652,     0,     0,     0,     0,     0,     0,
02251     -279,  -279,  -279,     0,     0,     0,  -279,  -279,     0,  -279,
02252        0,     0,     0,     0,     0,   -99,  -547,     0,  -547,  -547,
02253     -547,  -547,  -547,  -547,  -547,  -547,  -547,  -547,     0,  -279,
02254     -279,     0,  -279,  -279,  -279,  -279,  -279,     0,     0,     0,
02255        0,     0,  -547,  -547,  -547,  -547,   -91,     0,     0,  -547,
02256        0,  -547,     0,  -547,     0,     0,     0,     0,     0,     0,
02257     -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02258     -279,  -279,  -279,     0,     0,  -279,  -279,  -279,     0,   653,
02259        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02260        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02261        0,  -101,  -279,     0,  -279,  -279,  -279,  -279,  -279,  -279,
02262     -279,  -279,  -279,  -279,     0,     0,     0,     0,     0,     0,
02263        0,     0,     0,     0,     0,     0,     0,     0,     0,  -279,
02264     -279,  -279,   -93,     0,     0,  -279,     0,  -279,   238,  -279,
02265        5,     6,     7,     8,     9,  -565,  -565,  -565,    10,    11,
02266        0,     0,  -565,    12,     0,    13,    14,    15,    16,    17,
02267       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02268       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02269        0,     0,    28,    29,     0,    31,    32,    33,    34,    35,
02270       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02271       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02272        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02273        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02274       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02275       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02276        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02277       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02278        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02279        0,     0,  -565,   238,  -565,     5,     6,     7,     8,     9,
02280        0,     0,  -565,    10,    11,     0,  -565,  -565,    12,     0,
02281       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02282        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02283        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02284       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02285        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02286        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02287        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02288        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02289       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02290        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02291        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02292        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02293        0,     0,     0,     0,     0,     0,     0,  -565,   238,  -565,
02294        5,     6,     7,     8,     9,     0,     0,  -565,    10,    11,
02295        0,     0,  -565,    12,  -565,    13,    14,    15,    16,    17,
02296       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02297       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02298        0,     0,    28,    29,     0,    31,    32,    33,    34,    35,
02299       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02300       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02301        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02302        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02303       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02304       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02305        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02306       62,    63,     0,     0,     0,     0,     0,     0,     4,     0,
02307        5,     6,     7,     8,     9,     0,     0,     0,    10,    11,
02308        0,     0,  -565,    12,  -565,    13,    14,    15,    16,    17,
02309       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02310       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02311        0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
02312       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02313       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02314        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02315        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02316       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02317       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02318        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02319       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02320        0,     0,     0,     0,  -565,     0,     0,     0,     0,     0,
02321        0,     0,  -565,   238,  -565,     5,     6,     7,     8,     9,
02322        0,     0,  -565,    10,    11,     0,     0,  -565,    12,     0,
02323       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02324        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02325        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02326       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02327        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02328        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02329        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02330        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02331       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02332        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02333        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02334        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02335        0,  -565,  -565,    10,    11,     0,     0,  -565,    12,  -565,
02336       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02337        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02338        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02339       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02340        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02341        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02342        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02343        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02344       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02345        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02346        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02347        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02348        0,     0,     0,    10,    11,     0,     0,  -565,    12,  -565,
02349       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02350        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02351        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02352       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02353        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02354        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02355        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02356        0,   239,    50,     0,    51,    52,     0,    53,     0,    54,
02357       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02358        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02359        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02360        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02361        0,     0,     0,    10,    11,  -565,     0,  -565,    12,  -565,
02362       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02363        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02364        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02365       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02366        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02367        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02368        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02369        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02370       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02371        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02372        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02373        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02374        0,     0,     0,    10,    11,  -565,     0,  -565,    12,  -565,
02375       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02376        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02377        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02378       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02379        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02380        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02381        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02382        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02383       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02384        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02385        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02386        0,     0,     0,     0,     0,     0,     0,     0,     0,  -565,
02387        0,     0,     0,     0,     0,     0,     0,  -565,   238,  -565,
02388        5,     6,     7,     8,     9,     0,     0,  -565,    10,    11,
02389        0,     0,     0,    12,     0,    13,    14,    15,    16,    17,
02390       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02391       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02392        0,     0,    28,    29,     0,    31,    32,    33,    34,    35,
02393       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02394       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02395        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02396        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02397       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02398       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02399        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02400       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02401        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02402        0,     0,  -565,    12,  -565,    13,    14,    15,    16,    17,
02403       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02404       23,    24,    25,    26,     0,     0,   192,     0,     0,     0,
02405        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02406       36,    37,    38,    39,    40,   193,    41,    42,     0,    43,
02407       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02408        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02409        0,     0,     0,   194,     0,     0,   195,    50,     0,    51,
02410       52,     0,   196,   197,    54,    55,    56,    57,    58,    59,
02411       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02412        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02413      198,    63,    12,     0,    13,    14,    15,    16,    17,    18,
02414       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02415       24,    25,    26,     0,   221,    27,     0,     0,     0,     0,
02416        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02417       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02418       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02419        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02420        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02421        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02422        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02423        0,     0,     0,     0,     0,     0,     0,     0,    61,    62,
02424       63,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02425        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02426        0,   284,    12,   285,    13,    14,    15,    16,    17,    18,
02427       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02428       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02429        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02430       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02431       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02432        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02433        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02434        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02435        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02436        7,     8,     9,     0,     0,     0,    10,    11,    61,    62,
02437       63,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02438        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02439       25,    26,     0,   221,    27,     0,     0,     0,     0,     0,
02440       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02441       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02442        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02443        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02444        0,    48,     0,     0,    49,    50,     0,    51,    52,     0,
02445       53,     0,    54,    55,    56,    57,    58,    59,    60,     0,
02446        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02447        0,     0,     0,     0,     0,     0,     0,    61,    62,    63,
02448        0,     0,     0,     0,     0,     0,     5,     6,     7,     8,
02449        9,     0,     0,     0,    10,    11,     0,     0,     0,    12,
02450      466,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02451        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02452        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02453        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02454       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02455       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02456        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02457        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02458       54,    55,    56,    57,    58,    59,    60,     0,     0,     0,
02459        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02460        0,     0,     0,     0,     0,    61,    62,    63,     0,     0,
02461        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02462        0,     0,     0,     0,     0,     0,     0,     0,   466,   111,
02463      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
02464      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02465      132,   133,   134,     0,     0,     0,   135,   136,   137,   359,
02466      360,   361,   362,   142,   143,   144,     0,     0,     0,     0,
02467        0,   145,   146,   147,   148,   363,   364,   365,   366,   153,
02468       37,    38,   367,    40,     0,     0,     0,     0,     0,     0,
02469        0,     0,   155,   156,   157,   158,   159,   160,   161,   162,
02470      163,     0,     0,   164,   165,     0,     0,   166,   167,   168,
02471      169,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02472        0,   170,     0,     0,     0,     0,     0,     0,     0,     0,
02473        0,     0,     0,     0,     0,     0,     0,     0,   171,   172,
02474      173,   174,   175,   176,   177,   178,   179,   180,     0,   181,
02475      182,     0,     0,     0,     0,     0,  -540,  -540,  -540,     0,
02476     -540,     0,     0,     0,  -540,  -540,     0,   183,   368,  -540,
02477        0,  -540,  -540,  -540,  -540,  -540,  -540,  -540,     0,  -540,
02478        0,     0,     0,  -540,  -540,  -540,  -540,  -540,  -540,  -540,
02479        0,     0,  -540,     0,     0,     0,     0,     0,     0,  -540,
02480        0,     0,  -540,  -540,  -540,  -540,  -540,  -540,  -540,  -540,
02481     -540,  -540,  -540,  -540,     0,  -540,  -540,  -540,     0,  -540,
02482     -540,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02483        0,     0,     0,     0,     0,     0,     0,     0,     0,  -540,
02484        0,     0,  -540,  -540,     0,  -540,  -540,     0,  -540,  -540,
02485     -540,  -540,  -540,  -540,  -540,  -540,  -540,     0,     0,     0,
02486        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02487        0,     0,     0,     0,     0,  -540,  -540,  -540,     0,     0,
02488        0,     0,     0,  -541,  -541,  -541,     0,  -541,     0,  -540,
02489        0,  -541,  -541,     0,     0,  -540,  -541,     0,  -541,  -541,
02490     -541,  -541,  -541,  -541,  -541,     0,  -541,     0,     0,     0,
02491     -541,  -541,  -541,  -541,  -541,  -541,  -541,     0,     0,  -541,
02492        0,     0,     0,     0,     0,     0,  -541,     0,     0,  -541,
02493     -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
02494     -541,     0,  -541,  -541,  -541,     0,  -541,  -541,     0,     0,
02495        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02496        0,     0,     0,     0,     0,     0,  -541,     0,     0,  -541,
02497     -541,     0,  -541,  -541,     0,  -541,  -541,  -541,  -541,  -541,
02498     -541,  -541,  -541,  -541,     0,     0,     0,     0,     0,     0,
02499        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02500        0,     0,  -541,  -541,  -541,     0,     0,     0,     0,     0,
02501     -543,  -543,  -543,     0,  -543,     0,  -541,     0,  -543,  -543,
02502        0,     0,  -541,  -543,     0,  -543,  -543,  -543,  -543,  -543,
02503     -543,  -543,     0,     0,     0,     0,     0,  -543,  -543,  -543,
02504     -543,  -543,  -543,  -543,     0,     0,  -543,     0,     0,     0,
02505        0,     0,     0,  -543,     0,     0,  -543,  -543,  -543,  -543,
02506     -543,  -543,  -543,  -543,  -543,  -543,  -543,  -543,     0,  -543,
02507     -543,  -543,     0,  -543,  -543,     0,     0,     0,     0,     0,
02508        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02509        0,     0,     0,  -543,   710,     0,  -543,  -543,     0,  -543,
02510     -543,     0,  -543,  -543,  -543,  -543,  -543,  -543,  -543,  -543,
02511     -543,     0,     0,     0,     0,     0,   -99,     0,     0,     0,
02512        0,     0,     0,     0,  -545,  -545,  -545,     0,  -545,  -543,
02513     -543,  -543,  -545,  -545,     0,     0,     0,  -545,     0,  -545,
02514     -545,  -545,  -545,  -545,  -545,  -545,     0,     0,     0,  -543,
02515        0,  -545,  -545,  -545,  -545,  -545,  -545,  -545,     0,     0,
02516     -545,     0,     0,     0,     0,     0,     0,  -545,     0,     0,
02517     -545,  -545,  -545,  -545,  -545,  -545,  -545,  -545,  -545,  -545,
02518     -545,  -545,     0,  -545,  -545,  -545,     0,  -545,  -545,     0,
02519        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02520        0,     0,     0,     0,     0,     0,     0,  -545,     0,     0,
02521     -545,  -545,     0,  -545,  -545,     0,  -545,  -545,  -545,  -545,
02522     -545,  -545,  -545,  -545,  -545,     0,     0,     0,     0,     0,
02523        0,     0,     0,     0,     0,     0,     0,     0,  -546,  -546,
02524     -546,     0,  -546,  -545,  -545,  -545,  -546,  -546,     0,     0,
02525        0,  -546,     0,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
02526        0,     0,     0,  -545,     0,  -546,  -546,  -546,  -546,  -546,
02527     -546,  -546,     0,     0,  -546,     0,     0,     0,     0,     0,
02528        0,  -546,     0,     0,  -546,  -546,  -546,  -546,  -546,  -546,
02529     -546,  -546,  -546,  -546,  -546,  -546,     0,  -546,  -546,  -546,
02530        0,  -546,  -546,     0,     0,     0,     0,     0,     0,     0,
02531        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02532        0,  -546,     0,     0,  -546,  -546,     0,  -546,  -546,     0,
02533     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,     0,
02534        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02535        0,     0,     0,     0,     0,     0,     0,  -546,  -546,  -546,
02536        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02537        0,     0,     0,     0,     0,     0,     0,  -546,   111,   112,
02538      113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
02539      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02540      133,   134,     0,     0,     0,   135,   136,   137,   138,   139,
02541      140,   141,   142,   143,   144,     0,     0,     0,     0,     0,
02542      145,   146,   147,   148,   149,   150,   151,   152,   153,   266,
02543      267,   154,   268,     0,     0,     0,     0,     0,     0,     0,
02544        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02545        0,     0,   164,   165,     0,     0,   166,   167,   168,   169,
02546        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02547      170,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02548        0,     0,     0,     0,     0,     0,     0,   171,   172,   173,
02549      174,   175,   176,   177,   178,   179,   180,     0,   181,   182,
02550        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02551        0,     0,     0,     0,     0,     0,   183,   111,   112,   113,
02552      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
02553      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02554      134,     0,     0,     0,   135,   136,   137,   138,   139,   140,
02555      141,   142,   143,   144,     0,     0,     0,     0,     0,   145,
02556      146,   147,   148,   149,   150,   151,   152,   153,   223,     0,
02557      154,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02558      155,   156,   157,   158,   159,   160,   161,   162,   163,     0,
02559        0,   164,   165,     0,     0,   166,   167,   168,   169,     0,
02560        0,     0,     0,     0,     0,     0,     0,     0,     0,   170,
02561        0,     0,    55,     0,     0,     0,     0,     0,     0,     0,
02562        0,     0,     0,     0,     0,     0,   171,   172,   173,   174,
02563      175,   176,   177,   178,   179,   180,     0,   181,   182,     0,
02564        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02565        0,     0,     0,     0,     0,   183,   111,   112,   113,   114,
02566      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
02567      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
02568        0,     0,     0,   135,   136,   137,   138,   139,   140,   141,
02569      142,   143,   144,     0,     0,     0,     0,     0,   145,   146,
02570      147,   148,   149,   150,   151,   152,   153,     0,     0,   154,
02571        0,     0,     0,     0,     0,     0,     0,     0,     0,   155,
02572      156,   157,   158,   159,   160,   161,   162,   163,     0,     0,
02573      164,   165,     0,     0,   166,   167,   168,   169,     0,     0,
02574        0,     0,     0,     0,     0,     0,     0,     0,   170,     0,
02575        0,    55,     0,     0,     0,     0,     0,     0,     0,     0,
02576        0,     0,     0,     0,     0,   171,   172,   173,   174,   175,
02577      176,   177,   178,   179,   180,     0,   181,   182,     0,     0,
02578        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02579        0,     0,     0,     0,   183,   111,   112,   113,   114,   115,
02580      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
02581      126,   127,   128,   129,   130,   131,   132,   133,   134,     0,
02582        0,     0,   135,   136,   137,   138,   139,   140,   141,   142,
02583      143,   144,     0,     0,     0,     0,     0,   145,   146,   147,
02584      148,   149,   150,   151,   152,   153,     0,     0,   154,     0,
02585        0,     0,     0,     0,     0,     0,     0,     0,   155,   156,
02586      157,   158,   159,   160,   161,   162,   163,     0,     0,   164,
02587      165,     0,     0,   166,   167,   168,   169,     0,     0,     0,
02588        0,     0,     0,     0,     0,     0,     0,   170,     0,     0,
02589        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02590        0,     0,     0,     0,   171,   172,   173,   174,   175,   176,
02591      177,   178,   179,   180,     0,   181,   182,     0,     0,     5,
02592        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02593        0,     0,    12,   183,    13,    14,    15,   228,   229,    18,
02594       19,     0,     0,     0,     0,     0,   230,   231,   232,    23,
02595       24,    25,    26,     0,     0,   192,     0,     0,     0,     0,
02596        0,     0,   255,     0,     0,    32,    33,    34,    35,    36,
02597       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02598       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02599        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02600        0,     0,   256,     0,     0,   195,    50,     0,    51,    52,
02601        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02602        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02603        0,     5,     6,     7,     0,     9,     0,     0,   257,    10,
02604       11,     0,     0,     0,    12,     0,    13,    14,    15,   228,
02605      229,    18,    19,     0,     0,     0,   258,     0,   230,   231,
02606      232,    23,    24,    25,    26,     0,     0,   192,     0,     0,
02607        0,     0,     0,     0,   255,     0,     0,    32,    33,    34,
02608       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02609       43,    44,    45,     0,     0,     0,     0,     0,     0,     0,
02610        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02611        0,     0,     0,     0,   256,     0,     0,   195,    50,     0,
02612       51,    52,     0,     0,     0,    54,    55,    56,    57,    58,
02613       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02614        0,     0,     0,     5,     6,     7,     8,     9,     0,     0,
02615      257,    10,    11,     0,     0,     0,    12,     0,    13,    14,
02616       15,    16,    17,    18,    19,     0,     0,     0,   482,     0,
02617       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02618        0,     0,     0,     0,     0,    28,    29,    30,    31,    32,
02619       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02620       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02621        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02622        0,     0,     0,     0,     0,     0,    48,     0,     0,    49,
02623       50,     0,    51,    52,     0,    53,     0,    54,    55,    56,
02624       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02625        0,     0,     5,     6,     7,     8,     9,     0,     0,     0,
02626       10,    11,    61,    62,    63,    12,     0,    13,    14,    15,
02627       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02628       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02629        0,     0,     0,     0,    28,    29,     0,    31,    32,    33,
02630       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02631        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02632        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02633        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02634        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02635       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02636        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02637       11,    61,    62,    63,    12,     0,    13,    14,    15,    16,
02638       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02639       22,    23,    24,    25,    26,     0,     0,   192,     0,     0,
02640        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02641       35,    36,    37,    38,    39,    40,   193,    41,    42,     0,
02642       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02643        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02644        0,     0,     0,     0,   194,     0,     0,   195,    50,     0,
02645       51,    52,     0,   196,   197,    54,    55,    56,    57,    58,
02646       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02647        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02648       61,   198,    63,    12,     0,    13,    14,    15,   228,   229,
02649       18,    19,     0,     0,     0,     0,     0,   230,   231,   232,
02650       23,    24,    25,    26,     0,     0,   192,     0,     0,     0,
02651        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02652       36,    37,    38,    39,    40,   193,    41,    42,     0,    43,
02653       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02654        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02655        0,     0,     0,   194,     0,     0,   195,    50,     0,    51,
02656       52,     0,   577,   197,    54,    55,    56,    57,    58,    59,
02657       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02658        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02659      198,    63,    12,     0,    13,    14,    15,   228,   229,    18,
02660       19,     0,     0,     0,     0,     0,   230,   231,   232,    23,
02661       24,    25,    26,     0,     0,   192,     0,     0,     0,     0,
02662        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02663       37,    38,    39,    40,   193,    41,    42,     0,    43,    44,
02664       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02665        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02666        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02667        0,   196,     0,    54,    55,    56,    57,    58,    59,    60,
02668        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02669        7,     0,     9,     0,     0,     0,    10,    11,    61,   198,
02670       63,    12,     0,    13,    14,    15,   228,   229,    18,    19,
02671        0,     0,     0,     0,     0,   230,   231,   232,    23,    24,
02672       25,    26,     0,     0,   192,     0,     0,     0,     0,     0,
02673        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02674       38,    39,    40,   193,    41,    42,     0,    43,    44,    45,
02675        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02676        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02677        0,   194,     0,     0,   195,    50,     0,    51,    52,     0,
02678        0,   197,    54,    55,    56,    57,    58,    59,    60,     0,
02679        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02680        0,     9,     0,     0,     0,    10,    11,    61,   198,    63,
02681       12,     0,    13,    14,    15,   228,   229,    18,    19,     0,
02682        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02683       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02684       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02685       39,    40,   193,    41,    42,     0,    43,    44,    45,     0,
02686       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02687        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02688      194,     0,     0,   195,    50,     0,    51,    52,     0,   577,
02689        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02690        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02691        9,     0,     0,     0,    10,    11,    61,   198,    63,    12,
02692        0,    13,    14,    15,   228,   229,    18,    19,     0,     0,
02693        0,     0,     0,   230,   231,   232,    23,    24,    25,    26,
02694        0,     0,   192,     0,     0,     0,     0,     0,     0,    29,
02695        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02696       40,   193,    41,    42,     0,    43,    44,    45,     0,    46,
02697       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02698        0,     0,     0,     0,     0,     0,     0,     0,     0,   194,
02699        0,     0,   195,    50,     0,    51,    52,     0,     0,     0,
02700       54,    55,    56,    57,    58,    59,    60,     0,     0,     0,
02701        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02702        0,     0,     0,    10,    11,    61,   198,    63,    12,     0,
02703       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02704        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02705        0,   192,     0,     0,     0,     0,     0,     0,    29,     0,
02706        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02707        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02708        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02709        0,     0,     0,     0,     0,     0,     0,     0,   194,     0,
02710        0,   195,    50,     0,    51,    52,     0,   476,     0,    54,
02711       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02712        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02713        0,     0,    10,    11,    61,   198,    63,    12,     0,    13,
02714       14,    15,   228,   229,    18,    19,     0,     0,     0,     0,
02715        0,   230,   231,   232,    23,    24,    25,    26,     0,     0,
02716      192,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02717       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02718       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02719        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02720        0,     0,     0,     0,     0,     0,     0,   194,     0,     0,
02721      195,    50,     0,    51,    52,     0,   196,     0,    54,    55,
02722       56,    57,    58,    59,    60,     0,     0,     0,     0,     0,
02723        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02724        0,    10,    11,    61,   198,    63,    12,     0,    13,    14,
02725       15,   228,   229,    18,    19,     0,     0,     0,     0,     0,
02726      230,   231,   232,    23,    24,    25,    26,     0,     0,   192,
02727        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02728       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02729       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02730        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02731        0,     0,     0,     0,     0,     0,   194,     0,     0,   195,
02732       50,     0,    51,    52,     0,   758,     0,    54,    55,    56,
02733       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02734        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02735       10,    11,    61,   198,    63,    12,     0,    13,    14,    15,
02736      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02737      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02738        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02739       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02740        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02741        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02742        0,     0,     0,     0,     0,   194,     0,     0,   195,    50,
02743        0,    51,    52,     0,   476,     0,    54,    55,    56,    57,
02744       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02745        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02746       11,    61,   198,    63,    12,     0,    13,    14,    15,   228,
02747      229,    18,    19,     0,     0,     0,     0,     0,   230,   231,
02748      232,    23,    24,    25,    26,     0,     0,   192,     0,     0,
02749        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02750       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02751       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02752        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02753        0,     0,     0,     0,   194,     0,     0,   195,    50,     0,
02754       51,    52,     0,   577,     0,    54,    55,    56,    57,    58,
02755       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02756        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02757       61,   198,    63,    12,     0,    13,    14,    15,   228,   229,
02758       18,    19,     0,     0,     0,     0,     0,   230,   231,   232,
02759       23,    24,    25,    26,     0,     0,   192,     0,     0,     0,
02760        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02761       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02762       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02763        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02764        0,     0,     0,   194,     0,     0,   195,    50,     0,    51,
02765       52,     0,     0,     0,    54,    55,    56,    57,    58,    59,
02766       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02767        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02768      198,    63,    12,     0,    13,    14,    15,    16,    17,    18,
02769       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02770       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02771        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02772       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02773       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02774        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02775        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02776        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02777        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02778        7,     0,     9,     0,     0,     0,    10,    11,    61,    62,
02779       63,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02780        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02781       25,    26,     0,     0,   192,     0,     0,     0,     0,     0,
02782        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02783       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02784        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02785        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02786        0,   194,     0,     0,   195,    50,     0,    51,    52,     0,
02787        0,     0,    54,    55,    56,    57,    58,    59,    60,     0,
02788        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02789        0,     9,     0,     0,     0,    10,    11,    61,   198,    63,
02790       12,     0,    13,    14,    15,   228,   229,    18,    19,     0,
02791        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02792       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02793      255,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02794       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02795        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02796        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02797      256,     0,     0,   300,    50,     0,    51,    52,     0,   301,
02798        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02799        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02800       10,    11,     0,     0,     0,    12,   257,    13,    14,    15,
02801      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02802      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02803        0,     0,     0,     0,     0,   255,     0,     0,    32,    33,
02804       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02805        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02806        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02807        0,     0,     0,     0,     0,   342,     0,     0,    49,    50,
02808        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02809       58,    59,    60,     0,     0,     0,     0,     5,     6,     7,
02810        0,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02811       12,   257,    13,    14,    15,   228,   229,    18,    19,     0,
02812        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02813       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02814      255,     0,     0,    32,    33,    34,   349,    36,    37,    38,
02815      350,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02816        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02817        0,     0,     0,     0,     0,     0,     0,   351,     0,     0,
02818      352,     0,     0,   195,    50,     0,    51,    52,     0,     0,
02819        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02820        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02821       10,    11,     0,     0,     0,    12,   257,    13,    14,    15,
02822      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02823      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02824        0,     0,     0,     0,     0,   255,     0,     0,    32,    33,
02825       34,   349,    36,    37,    38,   350,    40,     0,    41,    42,
02826        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02827        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02828        0,     0,     0,     0,     0,   352,     0,     0,   195,    50,
02829        0,    51,    52,     0,     0,     0,    54,    55,    56,    57,
02830       58,    59,    60,     0,     0,     0,     0,     5,     6,     7,
02831        0,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02832       12,   257,    13,    14,    15,   228,   229,    18,    19,     0,
02833        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02834       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02835      255,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02836       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02837        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02838        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02839      256,     0,     0,   300,    50,     0,    51,    52,     0,     0,
02840        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02841        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02842       10,    11,     0,     0,     0,    12,   257,    13,    14,    15,
02843      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02844      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02845        0,     0,     0,     0,     0,   255,     0,     0,    32,    33,
02846       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02847        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02848        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02849        0,     0,     0,     0,     0,   887,     0,     0,   195,    50,
02850        0,    51,    52,     0,     0,     0,    54,    55,    56,    57,
02851       58,    59,    60,     0,     0,     0,     0,     5,     6,     7,
02852        0,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02853       12,   257,    13,    14,    15,   228,   229,    18,    19,     0,
02854        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02855       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02856      255,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02857       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02858        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02859        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02860      897,     0,     0,   195,    50,     0,    51,    52,     0,     0,
02861        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02862        0,     0,     0,   584,   524,     0,     0,   585,     0,     0,
02863        0,     0,     0,     0,     0,     0,   257,   155,   156,   157,
02864      158,   159,   160,   161,   162,   163,     0,     0,   164,   165,
02865        0,     0,   166,   167,   168,   169,     0,     0,     0,     0,
02866        0,     0,     0,     0,     0,     0,   170,     0,     0,     0,
02867        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02868        0,     0,     0,   171,   172,   173,   174,   175,   176,   177,
02869      178,   179,   180,     0,   181,   182,     0,     0,     0,     0,
02870      605,   516,     0,     0,   606,     0,     0,     0,     0,     0,
02871        0,     0,   183,   217,   155,   156,   157,   158,   159,   160,
02872      161,   162,   163,     0,     0,   164,   165,     0,     0,   166,
02873      167,   168,   169,     0,     0,     0,     0,     0,     0,     0,
02874        0,     0,     0,   170,     0,     0,     0,     0,     0,     0,
02875        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02876      171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
02877        0,   181,   182,     0,     0,     0,     0,   608,   524,     0,
02878        0,   609,     0,     0,     0,     0,     0,     0,     0,   183,
02879      217,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02880        0,     0,   164,   165,     0,     0,   166,   167,   168,   169,
02881        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02882      170,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02883        0,     0,     0,     0,     0,     0,     0,   171,   172,   173,
02884      174,   175,   176,   177,   178,   179,   180,     0,   181,   182,
02885        0,     0,     0,     0,   679,   516,     0,     0,   680,     0,
02886        0,     0,     0,     0,     0,     0,   183,   217,   155,   156,
02887      157,   158,   159,   160,   161,   162,   163,     0,     0,   164,
02888      165,     0,     0,   166,   167,   168,   169,     0,     0,     0,
02889        0,     0,     0,     0,     0,     0,     0,   170,     0,     0,
02890        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02891        0,     0,     0,     0,   171,   172,   173,   174,   175,   176,
02892      177,   178,   179,   180,     0,   181,   182,     0,     0,     0,
02893        0,   682,   524,     0,     0,   683,     0,     0,     0,     0,
02894        0,     0,     0,   183,   217,   155,   156,   157,   158,   159,
02895      160,   161,   162,   163,     0,     0,   164,   165,     0,     0,
02896      166,   167,   168,   169,     0,     0,     0,     0,     0,     0,
02897        0,     0,     0,     0,   170,     0,     0,     0,     0,     0,
02898        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02899        0,   171,   172,   173,   174,   175,   176,   177,   178,   179,
02900      180,     0,   181,   182,     0,     0,     0,     0,   689,   516,
02901        0,     0,   690,     0,     0,     0,     0,     0,     0,     0,
02902      183,   217,   155,   156,   157,   158,   159,   160,   161,   162,
02903      163,     0,     0,   164,   165,     0,     0,   166,   167,   168,
02904      169,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02905        0,   170,     0,     0,     0,     0,     0,     0,     0,     0,
02906        0,     0,     0,     0,     0,     0,     0,     0,   171,   172,
02907      173,   174,   175,   176,   177,   178,   179,   180,     0,   181,
02908      182,     0,     0,     0,     0,   562,   524,     0,     0,   563,
02909        0,     0,     0,     0,     0,     0,     0,   183,   217,   155,
02910      156,   157,   158,   159,   160,   161,   162,   163,     0,     0,
02911      164,   165,     0,     0,   166,   167,   168,   169,     0,     0,
02912        0,     0,     0,     0,     0,     0,     0,     0,   170,     0,
02913        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02914        0,     0,     0,     0,     0,   171,   172,   173,   174,   175,
02915      176,   177,   178,   179,   180,     0,   181,   182,     0,     0,
02916        0,     0,   949,   516,     0,     0,   950,     0,     0,     0,
02917        0,     0,     0,     0,   183,   217,   155,   156,   157,   158,
02918      159,   160,   161,   162,   163,     0,     0,   164,   165,     0,
02919        0,   166,   167,   168,   169,     0,     0,     0,     0,     0,
02920        0,     0,     0,     0,     0,   170,     0,     0,     0,     0,
02921        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02922        0,     0,   171,   172,   173,   174,   175,   176,   177,   178,
02923      179,   180,     0,   181,   182,     0,     0,     0,     0,   955,
02924      516,     0,     0,   956,     0,     0,     0,     0,     0,     0,
02925        0,   183,   217,   155,   156,   157,   158,   159,   160,   161,
02926      162,   163,     0,     0,   164,   165,     0,     0,   166,   167,
02927      168,   169,     0,     0,     0,     0,     0,     0,     0,     0,
02928        0,     0,   170,     0,     0,     0,     0,     0,     0,     0,
02929        0,     0,     0,     0,     0,     0,     0,     0,     0,   171,
02930      172,   173,   174,   175,   176,   177,   178,   179,   180,     0,
02931      181,   182,     0,     0,     0,     0,   958,   524,     0,     0,
02932      959,     0,     0,     0,     0,     0,     0,     0,   183,   217,
02933      155,   156,   157,   158,   159,   160,   161,   162,   163,     0,
02934        0,   164,   165,     0,     0,   166,   167,   168,   169,     0,
02935        0,     0,     0,     0,     0,     0,     0,     0,     0,   170,
02936        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02937        0,     0,     0,     0,     0,     0,   171,   172,   173,   174,
02938      175,   176,   177,   178,   179,   180,     0,   181,   182,     0,
02939        0,     0,     0,   562,   524,     0,     0,   563,     0,     0,
02940        0,     0,     0,     0,     0,   183,   217,   155,   156,   157,
02941      158,   159,   160,   161,   162,   163,     0,     0,   164,   165,
02942        0,     0,   166,   167,   168,   169,     0,     0,     0,     0,
02943        0,     0,     0,     0,     0,     0,   170,     0,     0,     0,
02944        0,     0,     0,     0,   705,     0,     0,     0,     0,     0,
02945        0,     0,     0,   171,   172,   173,   174,   175,   176,   177,
02946      178,   179,   180,   650,   181,   182,     0,     0,   304,   305,
02947      306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
02948      316,     0,   183,   317,   318,     0,     0,   304,   305,   306,
02949      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
02950        0,     0,   317,   318,     0,     0,     0,     0,     0,     0,
02951      319,     0,   320,   321,   322,   323,   324,   325,   326,   327,
02952      328,   329,     0,     0,     0,     0,     0,     0,     0,   319,
02953        0,   320,   321,   322,   323,   324,   325,   326,   327,   328,
02954      329
02955 };
02956 
02957 static const yytype_int16 yycheck[] =
02958 {
02959        2,    16,    17,    55,     2,    20,     4,    51,    28,    75,
02960       51,    52,   446,   336,   210,     8,    49,   537,    16,    17,
02961      303,     8,    20,    27,   536,    29,   556,    53,    83,   583,
02962      446,    86,   249,   331,    65,    28,   253,     4,    90,   442,
02963        8,    28,   748,   272,    13,   274,   352,   276,    49,    51,
02964       52,    49,    50,   607,    86,    53,   735,   667,   813,   836,
02965       28,   671,   641,   811,    62,   732,   615,     1,    22,    27,
02966       16,    17,    29,    50,    20,    25,   330,    75,   332,   482,
02967       53,   566,   567,    62,    82,    83,    26,    55,    86,    87,
02968       88,    89,   728,    13,    13,    61,   394,    25,    22,    13,
02969       61,    85,    75,   239,    76,    82,    83,    37,    38,    86,
02970      140,   398,   390,   749,    87,    88,    89,   147,   372,   373,
02971      398,    85,    90,   871,   558,    87,    85,   681,    65,   109,
02972       15,    13,    17,     0,    25,    25,   147,    13,   692,   393,
02973      106,   395,   114,   104,   105,   432,   444,   109,   925,    86,
02974      107,    25,    56,   732,   108,   139,   735,    25,   688,   914,
02975      140,     2,   195,     4,   300,   419,   696,   834,   916,    25,
02976      140,   140,    25,   722,   723,   139,   145,   147,   147,   113,
02977      139,    59,    60,   889,   108,   146,   620,   145,    85,   147,
02978      140,   445,   258,   655,   227,   943,   136,   195,   877,   214,
02979      662,   216,   217,   205,   620,   136,   239,   641,   210,   241,
02980      241,   145,   140,   147,   881,   217,   214,   147,   216,   217,
02981      146,   706,   220,   142,   222,   145,   145,   147,   147,   227,
02982      459,   145,    26,   147,   289,   290,   291,   292,   239,   146,
02983      238,   239,   139,   220,   542,   222,   649,   553,   858,   140,
02984      140,   255,   142,    25,   298,   834,   554,   836,    28,   303,
02985      258,   695,   811,   145,   813,   147,   140,   300,   214,   145,
02986      216,   147,   140,    99,   142,   301,   109,    26,   232,   695,
02987      792,   235,   337,   338,   140,   258,    25,   140,    87,   543,
02988      288,   289,   290,   291,   292,   293,   294,   295,   877,   300,
02989      298,   555,   300,   301,   241,   303,   142,   339,   220,    85,
02990      109,   147,   289,   290,   291,   292,   331,   294,   295,   298,
02991      140,   288,   871,   872,   303,    37,    38,    26,   301,   331,
02992      860,   243,   145,   331,   147,   333,    85,   109,   858,   337,
02993      338,   140,   136,   109,    85,    87,   925,    26,   142,   390,
02994       87,    85,   140,   351,   677,    87,    85,   142,    85,    56,
02995      337,   338,   330,   139,    26,   914,   109,   916,   140,    87,
02996      109,   143,   109,    88,   351,   147,   442,   109,   332,   394,
02997      378,   379,   912,   666,   580,   602,    85,   136,   429,   138,
02998      139,   109,   394,   413,   943,    85,   394,   238,   139,   378,
02999      379,   140,   339,   957,   143,   139,    85,    85,   147,   138,
03000      139,   138,   139,   142,   416,    52,   482,   354,   416,    56,
03001      413,   140,   140,    85,    87,   393,   413,   425,    85,   444,
03002      140,   865,    85,    85,    59,    60,    85,   136,   142,   138,
03003      139,   395,   444,   142,   442,   413,   444,   288,   138,   139,
03004      418,   136,   293,   142,    85,    14,    15,   136,    85,   138,
03005      139,   139,    85,   142,    68,   419,   564,   565,    85,   442,
03006      142,    85,   143,   475,   136,   443,   138,   139,    85,   109,
03007      142,   138,   139,   144,   482,   138,   139,   139,   400,   138,
03008      139,   445,   404,   137,   538,   407,    85,    87,    56,   532,
03009      504,   534,    52,   106,    54,    55,    56,    57,   139,   482,
03010      422,   138,   139,   106,    85,   427,   139,    85,   522,   109,
03011      641,   138,   139,   846,   138,   139,   528,   542,   530,   852,
03012      140,   138,   139,    87,   532,    87,   534,   603,    87,   554,
03013      542,    68,    68,    52,   542,    54,    55,    56,    57,   138,
03014      139,    17,   554,   140,   574,   109,   554,   109,   556,   557,
03015      109,   145,   564,   565,   566,   567,   520,   138,   139,   481,
03016      138,   139,    56,   541,   528,   416,    61,    94,   580,   583,
03017      557,   574,    68,   649,   425,   553,   140,   574,   140,   543,
03018      140,   140,    52,    25,   592,   597,   520,   143,   535,   536,
03019      137,   555,   140,   607,   528,   603,   574,   140,   140,   642,
03020      564,   565,   549,    61,   735,   592,    87,   738,   146,   104,
03021      105,   106,   666,    87,   626,    87,   628,   140,   630,   684,
03022      603,   140,   687,   119,   120,   121,   140,   935,   109,   641,
03023      564,   565,   596,   597,   642,   109,   698,   109,    61,    10,
03024       68,   649,     8,    54,   652,   653,   104,   105,   106,    13,
03025      658,   659,    63,    64,   666,   667,   109,   669,    61,   671,
03026      703,   704,   137,   652,   653,    52,   649,   681,   140,   658,
03027      659,    61,   936,   140,   140,    65,   684,   140,   692,   687,
03028      688,   104,   105,   106,    52,   140,   729,   730,   696,   117,
03029      118,   119,   120,   121,   706,   703,   704,   684,   741,   111,
03030      687,   104,   105,   106,   144,   836,    15,   838,    52,   140,
03031       54,    55,    56,    57,   104,   105,   728,   782,   145,   114,
03032      698,   729,   730,   193,   109,   140,   196,   197,    40,    41,
03033       42,    43,    44,   741,   140,   140,   779,   749,   685,   751,
03034       10,   753,   754,   786,   787,    89,   877,   790,   879,   140,
03035      697,    95,   883,    88,    16,    17,     9,   137,    20,    10,
03036       10,   769,   140,   806,   137,   777,    54,    55,   780,    57,
03037      140,   779,   694,   140,   782,    63,    64,   140,   786,   787,
03038      769,   140,   790,   137,    46,    47,   114,   140,   140,    51,
03039       52,   137,   140,   715,   925,   782,   927,    56,   806,   930,
03040       62,    63,   140,   140,   726,   416,   849,   819,   820,   140,
03041      822,    56,   824,   825,   945,   140,   140,   140,    87,   827,
03042      142,    52,   142,    54,    55,    56,    57,   539,   298,    89,
03043      889,   938,   722,   303,    92,   937,   967,   845,    95,    57,
03044       -1,   849,    90,   865,   827,   792,   858,   794,    68,   834,
03045      732,    52,   860,    54,    55,    56,    57,    -1,    89,   902,
03046       -1,   904,   845,    83,    84,    96,    -1,   910,    52,    -1,
03047       54,    55,    56,    57,    -1,    -1,    -1,   799,    -1,   891,
03048      892,   893,    -1,   895,   896,   116,    -1,    52,   810,    54,
03049       55,    56,    57,   815,   902,    -1,   904,   117,   118,   119,
03050      120,   121,   910,    -1,   912,    89,   918,   919,   920,   921,
03051      935,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   389,
03052      390,    -1,    -1,   935,    89,   937,   938,   935,   398,    -1,
03053       -1,   193,    -1,    -1,   196,   197,   198,    -1,    -1,   951,
03054      952,   953,   954,   957,    -1,   923,    52,    -1,    54,    55,
03055       56,    57,   214,   965,   216,   217,   934,    -1,    -1,   429,
03056       -1,   973,   432,    -1,   676,    52,    -1,    54,    55,    56,
03057       57,    -1,   936,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03058       -1,   693,    -1,    89,    -1,    -1,    -1,    -1,    -1,    95,
03059       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03060       -1,    -1,    89,    -1,    -1,    -1,   476,    -1,    95,    96,
03061      116,    -1,    -1,   119,    -1,    -1,    -1,    -1,    -1,    -1,
03062       -1,    -1,    -1,     2,    -1,     4,    -1,    -1,    -1,   116,
03063       -1,    -1,   119,    -1,    -1,    -1,   298,    -1,    -1,   145,
03064       -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
03065      312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
03066      322,   323,   324,   325,   326,   327,   328,   329,   538,   331,
03067       49,   783,    -1,   785,    53,    52,    -1,    54,    55,    56,
03068       57,    -1,    -1,   795,    -1,    -1,    -1,    -1,   800,    -1,
03069       -1,    -1,    -1,    -1,    -1,    -1,    75,    -1,    -1,    -1,
03070       -1,     2,    -1,     4,    -1,    -1,    -1,   577,    87,    88,
03071       89,    90,    89,    -1,    -1,    -1,   378,   379,    95,    96,
03072       -1,    -1,    -1,    -1,    -1,    -1,   388,   389,   390,    -1,
03073       -1,    -1,   394,    -1,   396,   397,   398,    -1,    -1,   116,
03074       -1,    -1,   119,   855,   856,    -1,    -1,    -1,    49,   628,
03075       -1,   630,    53,   415,    -1,    -1,    68,    52,   420,    54,
03076       55,    56,    57,    -1,    -1,   142,    -1,   429,    -1,    -1,
03077      432,    83,    84,     2,    75,     4,   646,    -1,    -1,    -1,
03078       -1,    -1,   444,    -1,    -1,    -1,    87,    88,    89,    -1,
03079        2,    -1,     4,    -1,    89,    -1,   666,    -1,    -1,   911,
03080       95,    96,   464,   465,   116,   117,   118,   119,   120,   121,
03081       -1,    -1,    -1,    -1,   476,    -1,   195,    -1,    -1,    -1,
03082       49,   116,    -1,    -1,   119,     0,    -1,   939,    -1,   941,
03083       -1,    -1,    -1,     8,     9,    10,    -1,    49,    13,    14,
03084       15,    52,    17,    54,    55,    56,    57,   142,   227,    -1,
03085      720,    -1,    27,    -1,    -1,    -1,    -1,    -1,    87,   238,
03086      239,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03087       -1,    -1,   751,    -1,   753,   754,   538,    -1,    89,   258,
03088      542,    68,    -1,    -1,    95,    96,    -1,    -1,   758,    -1,
03089       -1,    -1,   554,    -1,   195,    -1,    83,    84,    -1,    -1,
03090       -1,    -1,    -1,    -1,    -1,   116,    -1,    -1,   119,   288,
03091       85,    -1,    -1,    -1,   293,   577,    -1,    -1,    -1,   789,
03092       -1,   300,   301,    -1,    -1,    -1,   227,   114,   115,   116,
03093      117,   118,   119,   120,   121,    -1,    -1,   238,   239,    -1,
03094      819,   820,    -1,   822,    -1,   824,   825,    -1,    -1,    -1,
03095       -1,    -1,    -1,    -1,   333,    -1,    -1,   258,    -1,    -1,
03096       -1,    -1,   137,    -1,   139,    -1,   195,   142,   143,    -1,
03097      145,    -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03098       -1,    -1,    -1,   195,   646,    -1,    -1,   288,   650,    -1,
03099      652,   653,   293,    -1,    -1,    -1,   658,   659,   227,   300,
03100      301,    -1,    -1,    -1,   666,    -1,    -1,    -1,    -1,   238,
03101      239,    -1,   891,   892,   893,   227,   895,   896,    -1,    -1,
03102       -1,    -1,    -1,    -1,    -1,    -1,   238,   239,    -1,    -1,
03103       -1,    -1,   333,    -1,    -1,    -1,    -1,   416,    -1,   918,
03104      919,   920,   921,   705,    -1,    -1,   425,    -1,   710,   711,
03105       -1,   713,   714,    -1,    -1,    -1,    -1,    -1,   720,   288,
03106       -1,    -1,    -1,   442,   293,    -1,    -1,    -1,    -1,    -1,
03107       -1,   300,   951,   952,   953,   954,   288,    -1,    -1,    -1,
03108       -1,   293,    -1,    -1,    -1,    -1,   965,    -1,   300,    -1,
03109       -1,    -1,    -1,    -1,   973,    -1,   758,    -1,    -1,    -1,
03110      762,    -1,    -1,   482,   333,    -1,    -1,   769,    -1,    -1,
03111       -1,    -1,    -1,    -1,    -1,   416,    -1,    -1,    -1,    -1,
03112       -1,   333,    -1,    -1,   425,    -1,    -1,   789,    -1,    -1,
03113       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03114       -1,   442,    -1,    -1,    -1,   807,    -1,    -1,    -1,    -1,
03115       -1,    -1,    -1,   532,    -1,   534,    -1,    -1,    -1,    -1,
03116       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03117       68,    69,    70,    71,    72,    73,    74,   556,    -1,    77,
03118       78,   482,    -1,    -1,    -1,    83,    84,   416,    -1,    -1,
03119       -1,    -1,    -1,    -1,    -1,    -1,   425,    -1,    -1,    -1,
03120       -1,    -1,    -1,    -1,   416,    -1,    -1,    -1,    -1,    -1,
03121       44,    -1,    -1,   425,   112,   113,   114,   115,   116,   117,
03122      118,   119,   120,   121,   603,    -1,    -1,    -1,    -1,    -1,
03123       -1,   532,    -1,   534,    68,    69,    70,    71,    72,    73,
03124       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03125       84,    -1,    -1,    -1,    -1,   556,    -1,    -1,    -1,    -1,
03126       -1,    -1,    -1,   642,    -1,    -1,    -1,    -1,    -1,    -1,
03127      649,    -1,    -1,   935,    -1,    -1,   110,    -1,   112,   113,
03128      114,   115,   116,   117,   118,   119,   120,   121,    -1,    -1,
03129       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03130       -1,    -1,   603,   532,    -1,   534,   140,    -1,    -1,   688,
03131       -1,    -1,    -1,    -1,    -1,    -1,    -1,   696,    -1,    -1,
03132      532,    -1,   534,    -1,   703,   704,    -1,   556,    -1,    -1,
03133       -1,    -1,    -1,   634,    -1,    -1,    -1,    -1,    -1,    -1,
03134       -1,   642,    -1,    -1,   556,    -1,    -1,    -1,   649,    -1,
03135      729,   730,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,
03136       -1,    -1,   741,    -1,    -1,    -1,    -1,    -1,    66,    67,
03137       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03138       78,    -1,    -1,    81,    82,    83,    84,   688,    -1,    -1,
03139       -1,    -1,    -1,    -1,    -1,   696,    -1,    95,    -1,    -1,
03140      779,    -1,   703,   704,    -1,    -1,    -1,   786,   787,    -1,
03141       -1,   790,    -1,   642,   112,   113,   114,   115,   116,   117,
03142      118,   119,   120,   121,    -1,   123,   124,   806,   729,   730,
03143      642,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03144      741,    -1,    -1,   141,   142,    -1,    -1,    -1,   827,    -1,
03145       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   688,
03146       -1,    -1,    -1,    -1,    -1,    -1,   845,   696,    -1,    -1,
03147      849,    -1,    -1,    -1,   703,   704,   688,    -1,   779,    -1,
03148       -1,   860,    -1,    -1,   696,   786,   787,    -1,    -1,   790,
03149       -1,   703,   704,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03150      729,   730,    -1,    -1,    -1,   806,    -1,    -1,    -1,    -1,
03151       -1,    -1,   741,    -1,    -1,    -1,    -1,   729,   730,    -1,
03152       -1,    -1,    -1,   902,    -1,   904,   827,    -1,    -1,   741,
03153       -1,   910,    -1,   912,    -1,    -1,    -1,    68,    69,    70,
03154       71,    72,    73,    74,   845,    -1,    77,    78,   849,    -1,
03155      779,    -1,    83,    84,    -1,    -1,    -1,   786,   787,   860,
03156       -1,   790,    -1,    46,    47,    -1,    -1,   779,    51,    52,
03157       53,    -1,    -1,    -1,   786,   787,    -1,   806,   790,    -1,
03158       63,   112,   113,   114,   115,   116,   117,   118,   119,   120,
03159      121,    -1,    75,    -1,   806,    -1,    -1,    -1,    -1,    -1,
03160       -1,   902,    -1,   904,    87,    88,    89,    -1,    -1,   910,
03161       -1,   912,    -1,    -1,    -1,    -1,   845,    -1,    -1,    -1,
03162      849,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03163       -1,   860,    -1,    -1,    -1,    -1,    -1,   849,    -1,    -1,
03164       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   860,    -1,
03165       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03166       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03167       -1,    -1,    -1,   902,    -1,   904,    -1,    -1,    -1,    -1,
03168       -1,   910,    -1,   912,    -1,    -1,    -1,    -1,    -1,    -1,
03169      902,    -1,   904,    -1,    -1,    -1,    -1,    -1,   910,    -1,
03170      912,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,
03171      193,    -1,    -1,   196,   197,   198,    66,    67,    68,    69,
03172       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
03173       -1,    81,    82,    83,    84,    -1,    -1,    68,    69,    70,
03174       71,    72,    73,    74,    75,    95,    77,    78,    -1,    -1,
03175       -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
03176       -1,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
03177      120,   121,    -1,   123,   124,   258,    -1,    -1,    -1,    -1,
03178       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
03179      121,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03180       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03181       74,    75,    76,    77,    78,    79,    80,    -1,   301,    83,
03182       84,   304,   305,   306,   307,   308,   309,   310,   311,   312,
03183      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
03184      323,   324,   325,   326,   327,   328,   329,    -1,   112,   113,
03185      114,   115,   116,   117,   118,   119,   120,   121,    52,    53,
03186       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03187       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
03188       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03189       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03190       -1,    95,    -1,    -1,    -1,   388,   389,   390,    -1,    -1,
03191       -1,    -1,    -1,   396,   397,   398,    -1,    -1,   112,   113,
03192      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03193      124,    -1,   415,    -1,    -1,    -1,    -1,   420,    -1,    -1,
03194       -1,    -1,    -1,    -1,    -1,    -1,   429,   141,   142,   432,
03195       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   442,
03196       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03197       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03198       -1,   464,   465,    -1,     0,     1,    -1,     3,     4,     5,
03199        6,     7,    -1,   476,    -1,    11,    12,    -1,    -1,   482,
03200       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03201       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03202       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03203       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03204       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03205       66,    67,    -1,    -1,    -1,   538,    -1,    -1,    -1,    -1,
03206       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03207       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03208       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03209       -1,    -1,    -1,    -1,   577,    -1,    -1,    -1,    -1,    -1,
03210       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03211       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03212      603,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,
03213       -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03214       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03215       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03216       -1,    -1,    -1,   646,    -1,    -1,   649,   650,    -1,    -1,
03217       -1,     0,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,
03218        9,    10,    -1,   666,    13,    14,    15,    -1,    17,    -1,
03219       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    27,    28,
03220       29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,
03221       -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
03222       -1,    -1,   705,    -1,    -1,    -1,    -1,   710,   711,    -1,
03223      713,   714,    -1,    -1,    -1,    -1,    -1,   720,    -1,    68,
03224       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
03225       79,    80,    -1,    -1,    83,    84,    85,    -1,    87,    88,
03226       -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,
03227       -1,    -1,    -1,    -1,    -1,   758,    -1,    -1,   107,   762,
03228      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
03229      119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03230       -1,    -1,    -1,    -1,    -1,    -1,   789,    -1,   137,   138,
03231      139,   140,     0,    -1,   143,   144,   145,    -1,   147,    -1,
03232        8,     9,    10,    -1,   807,    13,    14,    15,    -1,    17,
03233       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    26,    27,
03234       28,    -1,    -1,    -1,   827,    -1,    -1,    -1,    -1,    37,
03235       38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
03236       -1,    -1,   845,    68,    69,    70,    71,    72,    73,    74,
03237       75,    76,    77,    78,    79,    80,    -1,    -1,    83,    84,
03238       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03239       78,    79,    80,    -1,    -1,    83,    84,    85,    -1,    -1,
03240       88,    -1,    -1,    -1,    -1,   110,    94,   112,   113,   114,
03241      115,   116,   117,   118,   119,   120,   121,    -1,    -1,    -1,
03242       -1,    -1,   110,    -1,   112,   113,   114,   115,   116,   117,
03243      118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
03244       -1,    -1,   147,    -1,    -1,    -1,    -1,    -1,   136,   137,
03245      138,   139,   140,     0,   142,   143,   144,   145,    -1,   147,
03246       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03247       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03248       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03249       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03250       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03251       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03252       84,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03253       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03254       -1,    88,    -1,    -1,    -1,    -1,   110,    94,   112,   113,
03255      114,   115,   116,   117,   118,   119,   120,   121,    -1,    -1,
03256      107,    -1,    -1,   110,   111,   112,   113,   114,   115,   116,
03257      117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,
03258       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03259      137,   138,   139,   140,     0,    -1,   143,   144,   145,    -1,
03260      147,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03261       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03262       26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03263       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03264       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03265       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03266       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03267       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03268       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,
03269       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03270       -1,    -1,    -1,    -1,   110,    -1,   112,   113,   114,   115,
03271      116,   117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,
03272       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03273      136,   137,   138,   139,   140,     0,   142,   143,   144,   145,
03274       -1,   147,    -1,     8,     9,    10,    -1,    -1,    13,    14,
03275       15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03276       -1,    -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
03277       -1,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03278       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03279       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03280       -1,    -1,    -1,    68,    69,    70,    71,    72,    73,    74,
03281       75,    76,    77,    78,    79,    80,    -1,    -1,    83,    84,
03282       85,    -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,
03283       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03284       -1,    -1,    -1,    -1,    -1,   110,    -1,   112,   113,   114,
03285      115,   116,   117,   118,   119,   120,   121,    -1,    -1,    -1,
03286       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03287       -1,    -1,   137,   138,   139,   140,     0,   142,   143,   144,
03288      145,    -1,   147,    -1,     8,     9,    10,    -1,    -1,    -1,
03289       14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,
03290       -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03291       -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03292       44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03293       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03294       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03295       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03296       84,    85,     0,    87,    -1,    -1,    -1,    -1,    -1,    -1,
03297        8,     9,    10,    -1,    -1,    -1,    14,    15,    -1,    17,
03298       -1,    -1,    -1,    -1,    -1,   109,   110,    -1,   112,   113,
03299      114,   115,   116,   117,   118,   119,   120,   121,    -1,    37,
03300       38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
03301       -1,    -1,   136,   137,   138,   139,   140,    -1,    -1,   143,
03302       -1,   145,    -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,
03303       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03304       78,    79,    80,    -1,    -1,    83,    84,    85,    -1,    87,
03305       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03306       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03307       -1,   109,   110,    -1,   112,   113,   114,   115,   116,   117,
03308      118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
03309       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   137,
03310      138,   139,   140,    -1,    -1,   143,    -1,   145,     1,   147,
03311        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
03312       -1,    -1,    15,    16,    -1,    18,    19,    20,    21,    22,
03313       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03314       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03315       -1,    -1,    45,    46,    -1,    48,    49,    50,    51,    52,
03316       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03317       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03318       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03319       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03320       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03321      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03322       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03323      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03324       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03325       -1,    -1,   145,     1,   147,     3,     4,     5,     6,     7,
03326       -1,    -1,    10,    11,    12,    -1,    14,    15,    16,    -1,
03327       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03328       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03329       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03330       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03331       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03332       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03333       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03334       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03335       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03336       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03337       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03338       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03339       -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,     1,   147,
03340        3,     4,     5,     6,     7,    -1,    -1,    10,    11,    12,
03341       -1,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
03342       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03343       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03344       -1,    -1,    45,    46,    -1,    48,    49,    50,    51,    52,
03345       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03346       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03347       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03348       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03349       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03350      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03351       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03352      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,
03353        3,     4,     5,     6,     7,    -1,    -1,    -1,    11,    12,
03354       -1,    -1,   145,    16,   147,    18,    19,    20,    21,    22,
03355       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03356       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03357       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03358       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03359       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03360       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03361       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03362       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03363      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03364       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03365      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03366       -1,    -1,    -1,    -1,   137,    -1,    -1,    -1,    -1,    -1,
03367       -1,    -1,   145,     1,   147,     3,     4,     5,     6,     7,
03368       -1,    -1,    10,    11,    12,    -1,    -1,    15,    16,    -1,
03369       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03370       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03371       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03372       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03373       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03374       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03375       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03376       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03377       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03378       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03379       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03380       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03381       -1,     9,    10,    11,    12,    -1,    -1,   145,    16,   147,
03382       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03383       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03384       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03385       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03386       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03387       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03388       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03389       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03390       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03391       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03392       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03393       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03394       -1,    -1,    -1,    11,    12,    -1,    -1,   145,    16,   147,
03395       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03396       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03397       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03398       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03399       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03400       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03401       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03402       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03403       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03404       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03405       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03406       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03407       -1,    -1,    -1,    11,    12,   143,    -1,   145,    16,   147,
03408       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03409       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03410       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03411       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03412       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03413       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03414       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03415       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03416       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03417       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03418       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03419       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03420       -1,    -1,    -1,    11,    12,   143,    -1,   145,    16,   147,
03421       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03422       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03423       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03424       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03425       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03426       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03427       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03428       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03429       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03430       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03431       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03432       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   137,
03433       -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,     1,   147,
03434        3,     4,     5,     6,     7,    -1,    -1,    10,    11,    12,
03435       -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,    22,
03436       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03437       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03438       -1,    -1,    45,    46,    -1,    48,    49,    50,    51,    52,
03439       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03440       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03441       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03442       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03443       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03444      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03445       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03446      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03447        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03448       -1,    -1,   145,    16,   147,    18,    19,    20,    21,    22,
03449       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03450       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03451       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03452       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03453       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03454       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03455       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03456       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03457      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03458        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03459      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03460       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03461       34,    35,    36,    -1,   147,    39,    -1,    -1,    -1,    -1,
03462       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03463       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03464       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03465       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03466       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03467       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03468       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03469       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,
03470      124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03471        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03472       -1,   145,    16,   147,    18,    19,    20,    21,    22,    23,
03473       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03474       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03475       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03476       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03477       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03478       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03479       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03480       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03481       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03482        5,     6,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03483      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03484       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03485       35,    36,    -1,   147,    39,    -1,    -1,    -1,    -1,    -1,
03486       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03487       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03488       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03489       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03490       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03491       95,    -1,    97,    98,    99,   100,   101,   102,   103,    -1,
03492       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03493       -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
03494       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
03495        7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,
03496      145,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03497       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03498       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03499       -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03500       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03501       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03502       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03503       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03504       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03505       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03506       -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,
03507       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03508       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,     3,
03509        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03510       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03511       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03512       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03513       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03514       54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,
03515       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
03516       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03517       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03518       -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03519       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,
03520      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03521      124,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03522        7,    -1,    -1,    -1,    11,    12,    -1,   141,   142,    16,
03523       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    26,
03524       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03525       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03526       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03527       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03528       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03529       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03530       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    96,
03531       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03532       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03533       -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,
03534       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,   136,
03535       -1,    11,    12,    -1,    -1,   142,    16,    -1,    18,    19,
03536       20,    21,    22,    23,    24,    -1,    26,    -1,    -1,    -1,
03537       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03538       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03539       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03540       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03541       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03542       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03543       90,    -1,    92,    93,    -1,    95,    96,    97,    98,    99,
03544      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03545       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03546       -1,    -1,   122,   123,   124,    -1,    -1,    -1,    -1,    -1,
03547        3,     4,     5,    -1,     7,    -1,   136,    -1,    11,    12,
03548       -1,    -1,   142,    16,    -1,    18,    19,    20,    21,    22,
03549       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03550       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03551       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03552       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03553       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03554       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03555       -1,    -1,    -1,    86,    87,    -1,    89,    90,    -1,    92,
03556       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03557      103,    -1,    -1,    -1,    -1,    -1,   109,    -1,    -1,    -1,
03558       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,   122,
03559      123,   124,    11,    12,    -1,    -1,    -1,    16,    -1,    18,
03560       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,   142,
03561       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03562       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03563       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03564       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03565       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03566       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03567       89,    90,    -1,    92,    93,    -1,    95,    96,    97,    98,
03568       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
03569       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03570        5,    -1,     7,   122,   123,   124,    11,    12,    -1,    -1,
03571       -1,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03572       -1,    -1,    -1,   142,    -1,    30,    31,    32,    33,    34,
03573       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03574       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03575       55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
03576       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03577       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03578       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03579       95,    96,    97,    98,    99,   100,   101,   102,   103,    -1,
03580       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03581       -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
03582       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03583       -1,    -1,    -1,    -1,    -1,    -1,    -1,   142,     3,     4,
03584        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03585       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03586       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03587       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03588       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03589       55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03590       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03591       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03592       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03593       95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03594       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
03595      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
03596       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03597       -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,     5,
03598        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03599       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03600       26,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03601       36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    45,
03602       46,    47,    48,    49,    50,    51,    52,    53,    54,    -1,
03603       56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03604       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
03605       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
03606       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
03607       -1,    -1,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03608       -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,
03609      116,   117,   118,   119,   120,   121,    -1,   123,   124,    -1,
03610       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03611       -1,    -1,    -1,    -1,    -1,   141,     3,     4,     5,     6,
03612        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
03613       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
03614       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03615       37,    38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03616       47,    48,    49,    50,    51,    52,    53,    -1,    -1,    56,
03617       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,
03618       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
03619       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
03620       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,
03621       -1,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03622       -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,
03623      117,   118,   119,   120,   121,    -1,   123,   124,    -1,    -1,
03624       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03625       -1,    -1,    -1,    -1,   141,     3,     4,     5,     6,     7,
03626        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03627       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
03628       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
03629       38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03630       48,    49,    50,    51,    52,    53,    -1,    -1,    56,    -1,
03631       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03632       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03633       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03634       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,
03635       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03636       -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
03637      118,   119,   120,   121,    -1,   123,   124,    -1,    -1,     3,
03638        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03639       -1,    -1,    16,   141,    18,    19,    20,    21,    22,    23,
03640       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03641       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03642       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03643       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03644       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03645       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03646       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03647       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03648       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03649       -1,     3,     4,     5,    -1,     7,    -1,    -1,   122,    11,
03650       12,    -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,
03651       22,    23,    24,    -1,    -1,    -1,   140,    -1,    30,    31,
03652       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03653       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03654       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03655       62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03656       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03657       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03658       92,    93,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03659      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03660       -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,    -1,
03661      122,    11,    12,    -1,    -1,    -1,    16,    -1,    18,    19,
03662       20,    21,    22,    23,    24,    -1,    -1,    -1,   140,    -1,
03663       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03664       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03665       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03666       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03667       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03668       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03669       90,    -1,    92,    93,    -1,    95,    -1,    97,    98,    99,
03670      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03671       -1,    -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,
03672       11,    12,   122,   123,   124,    16,    -1,    18,    19,    20,
03673       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03674       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03675       -1,    -1,    -1,    -1,    45,    46,    -1,    48,    49,    50,
03676       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03677       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03678       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03679       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03680       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03681      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03682       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03683       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03684       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03685       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03686       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03687       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03688       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03689       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03690       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03691       92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
03692      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03693        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03694      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03695       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03696       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03697       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03698       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03699       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03700       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03701       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03702       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03703      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03704        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03705      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03706       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03707       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03708       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03709       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03710       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03711       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03712       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03713       -1,    95,    -1,    97,    98,    99,   100,   101,   102,   103,
03714       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03715        5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03716      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03717       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03718       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03719       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03720       55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
03721       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03722       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03723       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03724       -1,    96,    97,    98,    99,   100,   101,   102,   103,    -1,
03725       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03726       -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,   124,
03727       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03728       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03729       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03730       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03731       56,    57,    58,    59,    60,    -1,    62,    63,    64,    -1,
03732       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03733       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03734       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03735       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03736       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03737        7,    -1,    -1,    -1,    11,    12,   122,   123,   124,    16,
03738       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03739       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03740       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03741       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03742       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03743       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03744       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03745       -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,    -1,
03746       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03747       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03748       -1,    -1,    -1,    11,    12,   122,   123,   124,    16,    -1,
03749       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03750       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03751       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03752       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03753       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03754       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03755       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03756       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03757       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03758       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03759       -1,    -1,    11,    12,   122,   123,   124,    16,    -1,    18,
03760       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03761       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03762       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03763       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03764       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03765       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03766       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03767       89,    90,    -1,    92,    93,    -1,    95,    -1,    97,    98,
03768       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
03769       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03770       -1,    11,    12,   122,   123,   124,    16,    -1,    18,    19,
03771       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03772       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03773       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03774       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03775       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03776       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03777       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03778       90,    -1,    92,    93,    -1,    95,    -1,    97,    98,    99,
03779      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03780       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03781       11,    12,   122,   123,   124,    16,    -1,    18,    19,    20,
03782       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03783       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03784       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03785       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03786       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03787       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03788       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03789       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03790      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03791       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03792       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03793       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03794       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03795       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03796       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03797       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03798       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03799       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03800       92,    93,    -1,    95,    -1,    97,    98,    99,   100,   101,
03801      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03802        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03803      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03804       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03805       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03806       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03807       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03808       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03809       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03810       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03811       93,    -1,    -1,    -1,    97,    98,    99,   100,   101,   102,
03812      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03813        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03814      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03815       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03816       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03817       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03818       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03819       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03820       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03821       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03822       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03823       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03824        5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03825      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03826       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03827       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03828       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03829       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03830       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03831       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03832       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03833       -1,    -1,    97,    98,    99,   100,   101,   102,   103,    -1,
03834       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03835       -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,   124,
03836       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03837       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03838       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03839       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03840       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03841       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03842       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03843       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03844       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03845       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03846       11,    12,    -1,    -1,    -1,    16,   122,    18,    19,    20,
03847       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03848       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03849       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03850       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03851       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
03852       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03853       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03854       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03855      101,   102,   103,    -1,    -1,    -1,    -1,     3,     4,     5,
03856       -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03857       16,   122,    18,    19,    20,    21,    22,    23,    24,    -1,
03858       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03859       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03860       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03861       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03862       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03863       -1,    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,    -1,
03864       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03865       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03866       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03867       11,    12,    -1,    -1,    -1,    16,   122,    18,    19,    20,
03868       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03869       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03870       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03871       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03872       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
03873       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03874       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03875       -1,    92,    93,    -1,    -1,    -1,    97,    98,    99,   100,
03876      101,   102,   103,    -1,    -1,    -1,    -1,     3,     4,     5,
03877       -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03878       16,   122,    18,    19,    20,    21,    22,    23,    24,    -1,
03879       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03880       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03881       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03882       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03883       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03884       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03885       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03886       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03887       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03888       11,    12,    -1,    -1,    -1,    16,   122,    18,    19,    20,
03889       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03890       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03891       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03892       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03893       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
03894       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03895       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03896       -1,    92,    93,    -1,    -1,    -1,    97,    98,    99,   100,
03897      101,   102,   103,    -1,    -1,    -1,    -1,     3,     4,     5,
03898       -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03899       16,   122,    18,    19,    20,    21,    22,    23,    24,    -1,
03900       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03901       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03902       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03903       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03904       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03905       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03906       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03907       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03908       -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,
03909       -1,    -1,    -1,    -1,    -1,    -1,   122,    66,    67,    68,
03910       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03911       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03912       -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
03913       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03914       -1,    -1,    -1,   112,   113,   114,   115,   116,   117,   118,
03915      119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,    -1,
03916       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
03917       -1,    -1,   141,   142,    66,    67,    68,    69,    70,    71,
03918       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03919       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03920       -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,
03921       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03922      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03923       -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,
03924       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,
03925      142,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03926       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03927       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03928       95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03929       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
03930      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
03931       -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,
03932       -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,
03933       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03934       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03935       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,
03936       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03937       -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
03938      118,   119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,
03939       -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,
03940       -1,    -1,    -1,   141,   142,    66,    67,    68,    69,    70,
03941       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
03942       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
03943       -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,
03944       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03945       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
03946      121,    -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,
03947       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03948      141,   142,    66,    67,    68,    69,    70,    71,    72,    73,
03949       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03950       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03951       -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03952       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,
03953      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03954      124,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,
03955       -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,
03956       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
03957       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
03958       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,
03959       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03960       -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,
03961      117,   118,   119,   120,   121,    -1,   123,   124,    -1,    -1,
03962       -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,
03963       -1,    -1,    -1,    -1,   141,   142,    66,    67,    68,    69,
03964       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
03965       -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,
03966       -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,
03967       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03968       -1,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
03969      120,   121,    -1,   123,   124,    -1,    -1,    -1,    -1,    52,
03970       53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,
03971       -1,   141,   142,    66,    67,    68,    69,    70,    71,    72,
03972       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
03973       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03974       -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03975       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,
03976      113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
03977      123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,
03978       56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,
03979       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
03980       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
03981       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
03982       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03983       -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,
03984      116,   117,   118,   119,   120,   121,    -1,   123,   124,    -1,
03985       -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,
03986       -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,    68,
03987       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03988       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03989       -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
03990       -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,
03991       -1,    -1,    -1,   112,   113,   114,   115,   116,   117,   118,
03992      119,   120,   121,    44,   123,   124,    -1,    -1,    68,    69,
03993       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03994       80,    -1,   141,    83,    84,    -1,    -1,    68,    69,    70,
03995       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
03996       -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
03997      110,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
03998      120,   121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
03999       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
04000      121
04001 };
04002 
04003 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04004    symbol of state STATE-NUM.  */
04005 static const yytype_uint16 yystos[] =
04006 {
04007        0,   149,   150,     0,     1,     3,     4,     5,     6,     7,
04008       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04009       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04010       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04011       57,    59,    60,    62,    63,    64,    66,    67,    86,    89,
04012       90,    92,    93,    95,    97,    98,    99,   100,   101,   102,
04013      103,   122,   123,   124,   151,   152,   153,   158,   160,   162,
04014      163,   166,   167,   169,   170,   171,   173,   174,   184,   198,
04015      215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
04016      225,   248,   249,   259,   260,   261,   262,   263,   264,   265,
04017      268,   278,   280,   281,   282,   283,   284,   285,   308,   319,
04018      153,     3,     4,     5,     6,     7,     8,     9,    10,    11,
04019       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
04020       22,    23,    24,    25,    26,    30,    31,    32,    33,    34,
04021       35,    36,    37,    38,    39,    45,    46,    47,    48,    49,
04022       50,    51,    52,    53,    56,    66,    67,    68,    69,    70,
04023       71,    72,    73,    74,    77,    78,    81,    82,    83,    84,
04024       95,   112,   113,   114,   115,   116,   117,   118,   119,   120,
04025      121,   123,   124,   141,   177,   178,   179,   180,   182,   183,
04026      278,   280,    39,    58,    86,    89,    95,    96,   123,   166,
04027      174,   184,   186,   191,   194,   196,   215,   282,   284,   285,
04028      306,   307,   191,   191,   142,   192,   193,   142,   188,   192,
04029      142,   147,   313,    54,   179,   313,   154,   136,    21,    22,
04030       30,    31,    32,   184,   215,   308,   184,    56,     1,    89,
04031      156,   157,   158,   168,   169,   319,   160,   187,   196,   306,
04032      319,   186,   305,   306,   319,    46,    86,   122,   140,   173,
04033      198,   215,   282,   285,   241,   242,    54,    55,    57,   177,
04034      271,   279,   270,   271,   272,   146,   266,   146,   269,    59,
04035       60,   162,   184,   184,   145,   147,   312,   317,   318,    40,
04036       41,    42,    43,    44,    37,    38,    28,   246,   109,   140,
04037       89,    95,   170,   109,    68,    69,    70,    71,    72,    73,
04038       74,    75,    76,    77,    78,    79,    80,    83,    84,   110,
04039      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
04040       85,   138,   139,   199,   160,   161,   161,   202,   204,   161,
04041      312,   318,    86,   167,   174,   215,   231,   282,   285,    52,
04042       56,    83,    86,   175,   176,   215,   282,   285,   176,    33,
04043       34,    35,    36,    49,    50,    51,    52,    56,   142,   177,
04044      283,   303,    85,   139,    26,   136,   250,   262,    87,    87,
04045      188,   192,   250,   140,   186,    56,   186,   186,   109,    88,
04046      140,   195,   319,    85,   138,   139,    87,    87,   140,   195,
04047      191,   313,   314,   191,   190,   191,   319,   160,   314,   160,
04048       54,    63,    64,   159,   142,   185,   136,   156,    85,   139,
04049       87,   158,   168,   143,   312,   318,   314,   200,   144,   140,
04050      147,   316,   140,   316,   137,   316,   313,    56,    59,    60,
04051      170,   172,   140,    85,   138,   139,   243,    61,   104,   105,
04052      106,   273,   106,   273,   106,    65,   273,   106,   106,   267,
04053      273,   106,    61,   106,    68,    68,   145,   153,   161,   161,
04054      161,   161,   158,   160,   160,   247,    95,   162,   186,   196,
04055      197,   168,   140,   173,   140,   162,   184,   186,   197,   184,
04056      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04057      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04058      184,   184,   184,   184,   184,    52,    53,    56,   182,   188,
04059      309,   310,   190,    52,    53,    56,   182,   188,   309,   155,
04060      156,    13,   227,   317,   227,   161,   161,   312,    17,   253,
04061       56,    85,   138,   139,    25,   160,    52,    56,   175,     1,
04062      113,   286,   317,    85,   138,   139,   211,   304,   212,    85,
04063      139,   311,    52,    56,   309,   309,   252,   251,   162,   184,
04064      162,   184,    94,   164,   181,   184,   186,    95,   186,   194,
04065      306,    52,    56,   190,    52,    56,   307,   314,   143,   314,
04066      314,   179,   201,   184,   151,   137,   309,   309,   184,   314,
04067      158,   314,   306,   140,   172,    52,    56,   190,    52,    56,
04068       52,    54,    55,    56,    57,    89,    95,    96,   116,   119,
04069      142,   244,   289,   290,   291,   292,   293,   294,   297,   298,
04070      299,   300,   301,   275,   274,   146,   273,   146,   184,   184,
04071       76,   114,   236,   237,   319,   186,   140,   314,   172,   140,
04072       44,   313,    87,    87,   188,   192,   313,   315,    87,    87,
04073      188,   189,   192,   319,    10,   226,     8,   255,   319,   156,
04074       13,   156,    27,   228,   317,   228,   253,   196,   226,    52,
04075       56,   190,    52,    56,   206,   209,   317,   287,   208,    52,
04076       56,   175,   190,   155,   160,   142,   288,   289,   213,   189,
04077      192,   189,   192,   236,   236,    44,   165,   179,   186,   195,
04078       87,    87,   315,    87,    87,   160,   137,   316,   170,   315,
04079      109,    52,    89,    95,   232,   233,   234,   291,   289,    29,
04080      107,   245,   140,   302,   319,   140,   302,    52,   140,   302,
04081       52,   276,    54,    55,    57,   277,   285,    52,   145,   235,
04082      238,   293,   295,   296,   299,   301,   319,   156,    95,   186,
04083      172,   184,   111,   162,   184,   162,   184,   164,   144,    87,
04084      162,   184,   162,   184,   164,   186,   197,   256,   319,    15,
04085      230,   319,    14,   229,   230,   230,   203,   205,   226,   140,
04086      227,   315,   161,   317,   161,   155,   315,   226,   314,   289,
04087      155,   317,   177,   156,   156,   184,   236,    87,   314,   186,
04088      234,   140,   291,   140,   314,   238,   156,   156,   292,   297,
04089      299,   301,   293,   294,   299,   293,   156,   109,    52,   239,
04090      240,   290,   238,   114,   140,   302,   140,   302,   140,   302,
04091       10,   186,   184,   162,   184,    88,   257,   319,   156,     9,
04092      258,   319,   161,   226,   226,   156,   156,   186,   156,   228,
04093      210,   317,   226,   314,   226,   214,    10,   137,   156,   314,
04094      233,   140,    95,   232,   314,    10,   137,   140,   302,   140,
04095      302,   140,   302,   140,   302,   302,   137,    86,   215,   140,
04096      114,   296,   299,   293,   295,   299,   293,    86,   174,   215,
04097      282,   285,   227,   156,   227,   226,   226,   230,   253,   254,
04098      207,   155,   288,   137,   140,   233,   140,   291,   293,   299,
04099      293,   293,    56,    85,   240,   140,   302,   140,   302,   302,
04100      140,   302,   302,    56,    85,   138,   139,   156,   156,   156,
04101      226,   155,   233,   140,   302,   140,   302,   302,   302,    52,
04102       56,   293,   299,   293,   293,    52,    56,   190,    52,    56,
04103      255,   229,   226,   226,   233,   293,   302,   140,   302,   302,
04104      302,   315,   302,   293,   302
04105 };
04106 
04107 #define yyerrok         (yyerrstatus = 0)
04108 #define yyclearin       (yychar = YYEMPTY)
04109 #define YYEMPTY         (-2)
04110 #define YYEOF           0
04111 
04112 #define YYACCEPT        goto yyacceptlab
04113 #define YYABORT         goto yyabortlab
04114 #define YYERROR         goto yyerrorlab
04115 
04116 
04117 /* Like YYERROR except do call yyerror.  This remains here temporarily
04118    to ease the transition to the new meaning of YYERROR, for GCC.
04119    Once GCC version 2 has supplanted version 1, this can go.  However,
04120    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04121    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04122    discussed.  */
04123 
04124 #define YYFAIL          goto yyerrlab
04125 #if defined YYFAIL
04126   /* This is here to suppress warnings from the GCC cpp's
04127      -Wunused-macros.  Normally we don't worry about that warning, but
04128      some users do, and we want to make it easy for users to remove
04129      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04130 #endif
04131 
04132 #define YYRECOVERING()  (!!yyerrstatus)
04133 
04134 #define YYBACKUP(Token, Value)                                  \
04135 do                                                              \
04136   if (yychar == YYEMPTY && yylen == 1)                          \
04137     {                                                           \
04138       yychar = (Token);                                         \
04139       yylval = (Value);                                         \
04140       yytoken = YYTRANSLATE (yychar);                           \
04141       YYPOPSTACK (1);                                           \
04142       goto yybackup;                                            \
04143     }                                                           \
04144   else                                                          \
04145     {                                                           \
04146       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04147       YYERROR;                                                  \
04148     }                                                           \
04149 while (YYID (0))
04150 
04151 
04152 #define YYTERROR        1
04153 #define YYERRCODE       256
04154 
04155 
04156 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04157    If N is 0, then set CURRENT to the empty location which ends
04158    the previous symbol: RHS[0] (always defined).  */
04159 
04160 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04161 #ifndef YYLLOC_DEFAULT
04162 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04163     do                                                                  \
04164       if (YYID (N))                                                    \
04165         {                                                               \
04166           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04167           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04168           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04169           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04170         }                                                               \
04171       else                                                              \
04172         {                                                               \
04173           (Current).first_line   = (Current).last_line   =              \
04174             YYRHSLOC (Rhs, 0).last_line;                                \
04175           (Current).first_column = (Current).last_column =              \
04176             YYRHSLOC (Rhs, 0).last_column;                              \
04177         }                                                               \
04178     while (YYID (0))
04179 #endif
04180 
04181 
04182 /* YY_LOCATION_PRINT -- Print the location on the stream.
04183    This macro was not mandated originally: define only if we know
04184    we won't break user code: when these are the locations we know.  */
04185 
04186 #ifndef YY_LOCATION_PRINT
04187 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
04188 #  define YY_LOCATION_PRINT(File, Loc)                  \
04189      fprintf (File, "%d.%d-%d.%d",                      \
04190               (Loc).first_line, (Loc).first_column,     \
04191               (Loc).last_line,  (Loc).last_column)
04192 # else
04193 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04194 # endif
04195 #endif
04196 
04197 
04198 /* YYLEX -- calling `yylex' with the right arguments.  */
04199 
04200 #ifdef YYLEX_PARAM
04201 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04202 #else
04203 # define YYLEX yylex (&yylval)
04204 #endif
04205 
04206 /* Enable debugging if requested.  */
04207 #if YYDEBUG
04208 
04209 # ifndef YYFPRINTF
04210 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04211 #  define YYFPRINTF fprintf
04212 # endif
04213 
04214 # define YYDPRINTF(Args)                        \
04215 do {                                            \
04216   if (yydebug)                                  \
04217     YYFPRINTF Args;                             \
04218 } while (YYID (0))
04219 
04220 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04221 do {                                                                      \
04222   if (yydebug)                                                            \
04223     {                                                                     \
04224       YYFPRINTF (stderr, "%s ", Title);                                   \
04225       yy_symbol_print (stderr,                                            \
04226                   Type, Value, parser); \
04227       YYFPRINTF (stderr, "\n");                                           \
04228     }                                                                     \
04229 } while (YYID (0))
04230 
04231 
04232 /*--------------------------------.
04233 | Print this symbol on YYOUTPUT.  |
04234 `--------------------------------*/
04235 
04236 /*ARGSUSED*/
04237 #if (defined __STDC__ || defined __C99__FUNC__ \
04238      || defined __cplusplus || defined _MSC_VER)
04239 static void
04240 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04241 #else
04242 static void
04243 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04244     FILE *yyoutput;
04245     int yytype;
04246     YYSTYPE const * const yyvaluep;
04247     struct parser_params *parser;
04248 #endif
04249 {
04250   if (!yyvaluep)
04251     return;
04252   YYUSE (parser);
04253 # ifdef YYPRINT
04254   if (yytype < YYNTOKENS)
04255     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04256 # else
04257   YYUSE (yyoutput);
04258 # endif
04259   switch (yytype)
04260     {
04261       default:
04262         break;
04263     }
04264 }
04265 
04266 
04267 /*--------------------------------.
04268 | Print this symbol on YYOUTPUT.  |
04269 `--------------------------------*/
04270 
04271 #if (defined __STDC__ || defined __C99__FUNC__ \
04272      || defined __cplusplus || defined _MSC_VER)
04273 static void
04274 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04275 #else
04276 static void
04277 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04278     FILE *yyoutput;
04279     int yytype;
04280     YYSTYPE const * const yyvaluep;
04281     struct parser_params *parser;
04282 #endif
04283 {
04284   if (yytype < YYNTOKENS)
04285     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04286   else
04287     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04288 
04289   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04290   YYFPRINTF (yyoutput, ")");
04291 }
04292 
04293 /*------------------------------------------------------------------.
04294 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04295 | TOP (included).                                                   |
04296 `------------------------------------------------------------------*/
04297 
04298 #if (defined __STDC__ || defined __C99__FUNC__ \
04299      || defined __cplusplus || defined _MSC_VER)
04300 static void
04301 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04302 #else
04303 static void
04304 yy_stack_print (yybottom, yytop)
04305     yytype_int16 *yybottom;
04306     yytype_int16 *yytop;
04307 #endif
04308 {
04309   YYFPRINTF (stderr, "Stack now");
04310   for (; yybottom <= yytop; yybottom++)
04311     {
04312       int yybot = *yybottom;
04313       YYFPRINTF (stderr, " %d", yybot);
04314     }
04315   YYFPRINTF (stderr, "\n");
04316 }
04317 
04318 # define YY_STACK_PRINT(Bottom, Top)                            \
04319 do {                                                            \
04320   if (yydebug)                                                  \
04321     yy_stack_print ((Bottom), (Top));                           \
04322 } while (YYID (0))
04323 
04324 
04325 /*------------------------------------------------.
04326 | Report that the YYRULE is going to be reduced.  |
04327 `------------------------------------------------*/
04328 
04329 #if (defined __STDC__ || defined __C99__FUNC__ \
04330      || defined __cplusplus || defined _MSC_VER)
04331 static void
04332 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04333 #else
04334 static void
04335 yy_reduce_print (yyvsp, yyrule, parser)
04336     YYSTYPE *yyvsp;
04337     int yyrule;
04338     struct parser_params *parser;
04339 #endif
04340 {
04341   int yynrhs = yyr2[yyrule];
04342   int yyi;
04343   unsigned long int yylno = yyrline[yyrule];
04344   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04345              yyrule - 1, yylno);
04346   /* The symbols being reduced.  */
04347   for (yyi = 0; yyi < yynrhs; yyi++)
04348     {
04349       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04350       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04351                        &(yyvsp[(yyi + 1) - (yynrhs)])
04352                                        , parser);
04353       YYFPRINTF (stderr, "\n");
04354     }
04355 }
04356 
04357 # define YY_REDUCE_PRINT(Rule)          \
04358 do {                                    \
04359   if (yydebug)                          \
04360     yy_reduce_print (yyvsp, Rule, parser); \
04361 } while (YYID (0))
04362 
04363 /* Nonzero means print parse trace.  It is left uninitialized so that
04364    multiple parsers can coexist.  */
04365 #ifndef yydebug
04366 int yydebug;
04367 #endif
04368 #else /* !YYDEBUG */
04369 # define YYDPRINTF(Args)
04370 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04371 # define YY_STACK_PRINT(Bottom, Top)
04372 # define YY_REDUCE_PRINT(Rule)
04373 #endif /* !YYDEBUG */
04374 
04375 
04376 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04377 #ifndef YYINITDEPTH
04378 # define YYINITDEPTH 200
04379 #endif
04380 
04381 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04382    if the built-in stack extension method is used).
04383 
04384    Do not make this value too large; the results are undefined if
04385    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04386    evaluated with infinite-precision integer arithmetic.  */
04387 
04388 #ifndef YYMAXDEPTH
04389 # define YYMAXDEPTH 10000
04390 #endif
04391 
04392 
04393 
04394 #if YYERROR_VERBOSE
04395 
04396 # ifndef yystrlen
04397 #  if defined __GLIBC__ && defined _STRING_H
04398 #   define yystrlen strlen
04399 #  else
04400 /* Return the length of YYSTR.  */
04401 #if (defined __STDC__ || defined __C99__FUNC__ \
04402      || defined __cplusplus || defined _MSC_VER)
04403 static YYSIZE_T
04404 yystrlen (const char *yystr)
04405 #else
04406 static YYSIZE_T
04407 yystrlen (yystr)
04408     const char *yystr;
04409 #endif
04410 {
04411   YYSIZE_T yylen;
04412   for (yylen = 0; yystr[yylen]; yylen++)
04413     continue;
04414   return yylen;
04415 }
04416 #  endif
04417 # endif
04418 
04419 # ifndef yystpcpy
04420 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04421 #   define yystpcpy stpcpy
04422 #  else
04423 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04424    YYDEST.  */
04425 #if (defined __STDC__ || defined __C99__FUNC__ \
04426      || defined __cplusplus || defined _MSC_VER)
04427 static char *
04428 yystpcpy (char *yydest, const char *yysrc)
04429 #else
04430 static char *
04431 yystpcpy (yydest, yysrc)
04432     char *yydest;
04433     const char *yysrc;
04434 #endif
04435 {
04436   char *yyd = yydest;
04437   const char *yys = yysrc;
04438 
04439   while ((*yyd++ = *yys++) != '\0')
04440     continue;
04441 
04442   return yyd - 1;
04443 }
04444 #  endif
04445 # endif
04446 
04447 # ifndef yytnamerr
04448 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04449    quotes and backslashes, so that it's suitable for yyerror.  The
04450    heuristic is that double-quoting is unnecessary unless the string
04451    contains an apostrophe, a comma, or backslash (other than
04452    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04453    null, do not copy; instead, return the length of what the result
04454    would have been.  */
04455 static YYSIZE_T
04456 yytnamerr (char *yyres, const char *yystr)
04457 {
04458   if (*yystr == '"')
04459     {
04460       YYSIZE_T yyn = 0;
04461       char const *yyp = yystr;
04462 
04463       for (;;)
04464         switch (*++yyp)
04465           {
04466           case '\'':
04467           case ',':
04468             goto do_not_strip_quotes;
04469 
04470           case '\\':
04471             if (*++yyp != '\\')
04472               goto do_not_strip_quotes;
04473             /* Fall through.  */
04474           default:
04475             if (yyres)
04476               yyres[yyn] = *yyp;
04477             yyn++;
04478             break;
04479 
04480           case '"':
04481             if (yyres)
04482               yyres[yyn] = '\0';
04483             return yyn;
04484           }
04485     do_not_strip_quotes: ;
04486     }
04487 
04488   if (! yyres)
04489     return yystrlen (yystr);
04490 
04491   return yystpcpy (yyres, yystr) - yyres;
04492 }
04493 # endif
04494 
04495 /* Copy into YYRESULT an error message about the unexpected token
04496    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
04497    including the terminating null byte.  If YYRESULT is null, do not
04498    copy anything; just return the number of bytes that would be
04499    copied.  As a special case, return 0 if an ordinary "syntax error"
04500    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
04501    size calculation.  */
04502 static YYSIZE_T
04503 yysyntax_error (char *yyresult, int yystate, int yychar)
04504 {
04505   int yyn = yypact[yystate];
04506 
04507   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
04508     return 0;
04509   else
04510     {
04511       int yytype = YYTRANSLATE (yychar);
04512       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
04513       YYSIZE_T yysize = yysize0;
04514       YYSIZE_T yysize1;
04515       int yysize_overflow = 0;
04516       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04517       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04518       int yyx;
04519 
04520 # if 0
04521       /* This is so xgettext sees the translatable formats that are
04522          constructed on the fly.  */
04523       YY_("syntax error, unexpected %s");
04524       YY_("syntax error, unexpected %s, expecting %s");
04525       YY_("syntax error, unexpected %s, expecting %s or %s");
04526       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
04527       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
04528 # endif
04529       char *yyfmt;
04530       char const *yyf;
04531       static char const yyunexpected[] = "syntax error, unexpected %s";
04532       static char const yyexpecting[] = ", expecting %s";
04533       static char const yyor[] = " or %s";
04534       char yyformat[sizeof yyunexpected
04535                     + sizeof yyexpecting - 1
04536                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
04537                        * (sizeof yyor - 1))];
04538       char const *yyprefix = yyexpecting;
04539 
04540       /* Start YYX at -YYN if negative to avoid negative indexes in
04541          YYCHECK.  */
04542       int yyxbegin = yyn < 0 ? -yyn : 0;
04543 
04544       /* Stay within bounds of both yycheck and yytname.  */
04545       int yychecklim = YYLAST - yyn + 1;
04546       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04547       int yycount = 1;
04548 
04549       yyarg[0] = yytname[yytype];
04550       yyfmt = yystpcpy (yyformat, yyunexpected);
04551 
04552       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04553         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
04554           {
04555             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04556               {
04557                 yycount = 1;
04558                 yysize = yysize0;
04559                 yyformat[sizeof yyunexpected - 1] = '\0';
04560                 break;
04561               }
04562             yyarg[yycount++] = yytname[yyx];
04563             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04564             yysize_overflow |= (yysize1 < yysize);
04565             yysize = yysize1;
04566             yyfmt = yystpcpy (yyfmt, yyprefix);
04567             yyprefix = yyor;
04568           }
04569 
04570       yyf = YY_(yyformat);
04571       yysize1 = yysize + yystrlen (yyf);
04572       yysize_overflow |= (yysize1 < yysize);
04573       yysize = yysize1;
04574 
04575       if (yysize_overflow)
04576         return YYSIZE_MAXIMUM;
04577 
04578       if (yyresult)
04579         {
04580           /* Avoid sprintf, as that infringes on the user's name space.
04581              Don't have undefined behavior even if the translation
04582              produced a string with the wrong number of "%s"s.  */
04583           char *yyp = yyresult;
04584           int yyi = 0;
04585           while ((*yyp = *yyf) != '\0')
04586             {
04587               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
04588                 {
04589                   yyp += yytnamerr (yyp, yyarg[yyi++]);
04590                   yyf += 2;
04591                 }
04592               else
04593                 {
04594                   yyp++;
04595                   yyf++;
04596                 }
04597             }
04598         }
04599       return yysize;
04600     }
04601 }
04602 #endif /* YYERROR_VERBOSE */
04603 
04604 
04605 /*-----------------------------------------------.
04606 | Release the memory associated to this symbol.  |
04607 `-----------------------------------------------*/
04608 
04609 /*ARGSUSED*/
04610 #if (defined __STDC__ || defined __C99__FUNC__ \
04611      || defined __cplusplus || defined _MSC_VER)
04612 static void
04613 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04614 #else
04615 static void
04616 yydestruct (yymsg, yytype, yyvaluep, parser)
04617     const char *yymsg;
04618     int yytype;
04619     YYSTYPE *yyvaluep;
04620     struct parser_params *parser;
04621 #endif
04622 {
04623   YYUSE (yyvaluep);
04624   YYUSE (parser);
04625 
04626   if (!yymsg)
04627     yymsg = "Deleting";
04628   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04629 
04630   switch (yytype)
04631     {
04632 
04633       default:
04634         break;
04635     }
04636 }
04637 
04638 /* Prevent warnings from -Wmissing-prototypes.  */
04639 #ifdef YYPARSE_PARAM
04640 #if defined __STDC__ || defined __cplusplus
04641 int yyparse (void *YYPARSE_PARAM);
04642 #else
04643 int yyparse ();
04644 #endif
04645 #else /* ! YYPARSE_PARAM */
04646 #if defined __STDC__ || defined __cplusplus
04647 int yyparse (struct parser_params *parser);
04648 #else
04649 int yyparse ();
04650 #endif
04651 #endif /* ! YYPARSE_PARAM */
04652 
04653 
04654 
04655 
04656 
04657 /*-------------------------.
04658 | yyparse or yypush_parse.  |
04659 `-------------------------*/
04660 
04661 #ifdef YYPARSE_PARAM
04662 #if (defined __STDC__ || defined __C99__FUNC__ \
04663      || defined __cplusplus || defined _MSC_VER)
04664 int
04665 yyparse (void *YYPARSE_PARAM)
04666 #else
04667 int
04668 yyparse (YYPARSE_PARAM)
04669     void *YYPARSE_PARAM;
04670 #endif
04671 #else /* ! YYPARSE_PARAM */
04672 #if (defined __STDC__ || defined __C99__FUNC__ \
04673      || defined __cplusplus || defined _MSC_VER)
04674 int
04675 yyparse (struct parser_params *parser)
04676 #else
04677 int
04678 yyparse (parser)
04679     struct parser_params *parser;
04680 #endif
04681 #endif
04682 {
04683 /* The lookahead symbol.  */
04684 int yychar;
04685 
04686 /* The semantic value of the lookahead symbol.  */
04687 YYSTYPE yylval;
04688 
04689     /* Number of syntax errors so far.  */
04690     int yynerrs;
04691 
04692     int yystate;
04693     /* Number of tokens to shift before error messages enabled.  */
04694     int yyerrstatus;
04695 
04696     /* The stacks and their tools:
04697        `yyss': related to states.
04698        `yyvs': related to semantic values.
04699 
04700        Refer to the stacks thru separate pointers, to allow yyoverflow
04701        to reallocate them elsewhere.  */
04702 
04703     /* The state stack.  */
04704     yytype_int16 yyssa[YYINITDEPTH];
04705     yytype_int16 *yyss;
04706     yytype_int16 *yyssp;
04707 
04708     /* The semantic value stack.  */
04709     YYSTYPE yyvsa[YYINITDEPTH];
04710     YYSTYPE *yyvs;
04711     YYSTYPE *yyvsp;
04712 
04713     YYSIZE_T yystacksize;
04714 
04715   int yyn;
04716   int yyresult;
04717   /* Lookahead token as an internal (translated) token number.  */
04718   int yytoken;
04719   /* The variables used to return semantic value and location from the
04720      action routines.  */
04721   YYSTYPE yyval;
04722 
04723 #if YYERROR_VERBOSE
04724   /* Buffer for error messages, and its allocated size.  */
04725   char yymsgbuf[128];
04726   char *yymsg = yymsgbuf;
04727   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
04728 #endif
04729 
04730 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
04731 
04732   /* The number of symbols on the RHS of the reduced rule.
04733      Keep to zero when no symbol should be popped.  */
04734   int yylen = 0;
04735 
04736   yytoken = 0;
04737   yyss = yyssa;
04738   yyvs = yyvsa;
04739   yystacksize = YYINITDEPTH;
04740 
04741   YYDPRINTF ((stderr, "Starting parse\n"));
04742 
04743   yystate = 0;
04744   yyerrstatus = 0;
04745   yynerrs = 0;
04746   yychar = YYEMPTY; /* Cause a token to be read.  */
04747 
04748   /* Initialize stack pointers.
04749      Waste one element of value and location stack
04750      so that they stay on the same level as the state stack.
04751      The wasted elements are never initialized.  */
04752   yyssp = yyss;
04753   yyvsp = yyvs;
04754 
04755   goto yysetstate;
04756 
04757 /*------------------------------------------------------------.
04758 | yynewstate -- Push a new state, which is found in yystate.  |
04759 `------------------------------------------------------------*/
04760  yynewstate:
04761   /* In all cases, when you get here, the value and location stacks
04762      have just been pushed.  So pushing a state here evens the stacks.  */
04763   yyssp++;
04764 
04765  yysetstate:
04766   *yyssp = yystate;
04767 
04768   if (yyss + yystacksize - 1 <= yyssp)
04769     {
04770       /* Get the current used size of the three stacks, in elements.  */
04771       YYSIZE_T yysize = yyssp - yyss + 1;
04772 
04773 #ifdef yyoverflow
04774       {
04775         /* Give user a chance to reallocate the stack.  Use copies of
04776            these so that the &'s don't force the real ones into
04777            memory.  */
04778         YYSTYPE *yyvs1 = yyvs;
04779         yytype_int16 *yyss1 = yyss;
04780 
04781         /* Each stack pointer address is followed by the size of the
04782            data in use in that stack, in bytes.  This used to be a
04783            conditional around just the two extra args, but that might
04784            be undefined if yyoverflow is a macro.  */
04785         yyoverflow (YY_("memory exhausted"),
04786                     &yyss1, yysize * sizeof (*yyssp),
04787                     &yyvs1, yysize * sizeof (*yyvsp),
04788                     &yystacksize);
04789 
04790         yyss = yyss1;
04791         yyvs = yyvs1;
04792       }
04793 #else /* no yyoverflow */
04794 # ifndef YYSTACK_RELOCATE
04795       goto yyexhaustedlab;
04796 # else
04797       /* Extend the stack our own way.  */
04798       if (YYMAXDEPTH <= yystacksize)
04799         goto yyexhaustedlab;
04800       yystacksize *= 2;
04801       if (YYMAXDEPTH < yystacksize)
04802         yystacksize = YYMAXDEPTH;
04803 
04804       {
04805         yytype_int16 *yyss1 = yyss;
04806         union yyalloc *yyptr =
04807           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
04808         if (! yyptr)
04809           goto yyexhaustedlab;
04810         YYSTACK_RELOCATE (yyss_alloc, yyss);
04811         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
04812 #  undef YYSTACK_RELOCATE
04813         if (yyss1 != yyssa)
04814           YYSTACK_FREE (yyss1);
04815       }
04816 # endif
04817 #endif /* no yyoverflow */
04818 
04819       yyssp = yyss + yysize - 1;
04820       yyvsp = yyvs + yysize - 1;
04821 
04822       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
04823                   (unsigned long int) yystacksize));
04824 
04825       if (yyss + yystacksize - 1 <= yyssp)
04826         YYABORT;
04827     }
04828 
04829   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
04830 
04831   if (yystate == YYFINAL)
04832     YYACCEPT;
04833 
04834   goto yybackup;
04835 
04836 /*-----------.
04837 | yybackup.  |
04838 `-----------*/
04839 yybackup:
04840 
04841   /* Do appropriate processing given the current state.  Read a
04842      lookahead token if we need one and don't already have one.  */
04843 
04844   /* First try to decide what to do without reference to lookahead token.  */
04845   yyn = yypact[yystate];
04846   if (yyn == YYPACT_NINF)
04847     goto yydefault;
04848 
04849   /* Not known => get a lookahead token if don't already have one.  */
04850 
04851   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
04852   if (yychar == YYEMPTY)
04853     {
04854       YYDPRINTF ((stderr, "Reading a token: "));
04855       yychar = YYLEX;
04856     }
04857 
04858   if (yychar <= YYEOF)
04859     {
04860       yychar = yytoken = YYEOF;
04861       YYDPRINTF ((stderr, "Now at end of input.\n"));
04862     }
04863   else
04864     {
04865       yytoken = YYTRANSLATE (yychar);
04866       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
04867     }
04868 
04869   /* If the proper action on seeing token YYTOKEN is to reduce or to
04870      detect an error, take that action.  */
04871   yyn += yytoken;
04872   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
04873     goto yydefault;
04874   yyn = yytable[yyn];
04875   if (yyn <= 0)
04876     {
04877       if (yyn == 0 || yyn == YYTABLE_NINF)
04878         goto yyerrlab;
04879       yyn = -yyn;
04880       goto yyreduce;
04881     }
04882 
04883   /* Count tokens shifted since error; after three, turn off error
04884      status.  */
04885   if (yyerrstatus)
04886     yyerrstatus--;
04887 
04888   /* Shift the lookahead token.  */
04889   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
04890 
04891   /* Discard the shifted token.  */
04892   yychar = YYEMPTY;
04893 
04894   yystate = yyn;
04895   *++yyvsp = yylval;
04896 
04897   goto yynewstate;
04898 
04899 
04900 /*-----------------------------------------------------------.
04901 | yydefault -- do the default action for the current state.  |
04902 `-----------------------------------------------------------*/
04903 yydefault:
04904   yyn = yydefact[yystate];
04905   if (yyn == 0)
04906     goto yyerrlab;
04907   goto yyreduce;
04908 
04909 
04910 /*-----------------------------.
04911 | yyreduce -- Do a reduction.  |
04912 `-----------------------------*/
04913 yyreduce:
04914   /* yyn is the number of a rule to reduce with.  */
04915   yylen = yyr2[yyn];
04916 
04917   /* If YYLEN is nonzero, implement the default value of the action:
04918      `$$ = $1'.
04919 
04920      Otherwise, the following line sets YYVAL to garbage.
04921      This behavior is undocumented and Bison
04922      users should not rely upon it.  Assigning to YYVAL
04923      unconditionally makes the parser a bit smaller, and it avoids a
04924      GCC warning that YYVAL may be used uninitialized.  */
04925   yyval = yyvsp[1-yylen];
04926 
04927 
04928   YY_REDUCE_PRINT (yyn);
04929   switch (yyn)
04930     {
04931         case 2:
04932 
04933 /* Line 1464 of yacc.c  */
04934 #line 786 "ripper.y"
04935     {
04936                         lex_state = EXPR_BEG;
04937 #if 0
04938                         local_push(compile_for_eval || rb_parse_in_main());
04939 #endif
04940                         local_push(0);
04941 
04942                     ;}
04943     break;
04944 
04945   case 3:
04946 
04947 /* Line 1464 of yacc.c  */
04948 #line 795 "ripper.y"
04949     {
04950 #if 0
04951                         if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
04952                             /* last expression should not be void */
04953                             if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
04954                             else {
04955                                 NODE *node = (yyvsp[(2) - (2)].val);
04956                                 while (node->nd_next) {
04957                                     node = node->nd_next;
04958                                 }
04959                                 void_expr(node->nd_head);
04960                             }
04961                         }
04962                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
04963 #endif
04964                         (yyval.val) = (yyvsp[(2) - (2)].val);
04965                         parser->result = dispatch1(program, (yyval.val));
04966 
04967                         local_pop();
04968                     ;}
04969     break;
04970 
04971   case 4:
04972 
04973 /* Line 1464 of yacc.c  */
04974 #line 818 "ripper.y"
04975     {
04976 #if 0
04977                         void_stmts((yyvsp[(1) - (2)].val));
04978                         fixup_nodes(&deferred_nodes);
04979 #endif
04980 
04981                         (yyval.val) = (yyvsp[(1) - (2)].val);
04982                     ;}
04983     break;
04984 
04985   case 5:
04986 
04987 /* Line 1464 of yacc.c  */
04988 #line 829 "ripper.y"
04989     {
04990 #if 0
04991                         (yyval.val) = NEW_BEGIN(0);
04992 #endif
04993                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
04994                                                   dispatch0(void_stmt));
04995 
04996                     ;}
04997     break;
04998 
04999   case 6:
05000 
05001 /* Line 1464 of yacc.c  */
05002 #line 838 "ripper.y"
05003     {
05004 #if 0
05005                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05006 #endif
05007                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05008 
05009                     ;}
05010     break;
05011 
05012   case 7:
05013 
05014 /* Line 1464 of yacc.c  */
05015 #line 846 "ripper.y"
05016     {
05017 #if 0
05018                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05019 #endif
05020                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05021 
05022                     ;}
05023     break;
05024 
05025   case 8:
05026 
05027 /* Line 1464 of yacc.c  */
05028 #line 854 "ripper.y"
05029     {
05030                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05031                     ;}
05032     break;
05033 
05034   case 10:
05035 
05036 /* Line 1464 of yacc.c  */
05037 #line 861 "ripper.y"
05038     {
05039                         if (in_def || in_single) {
05040                             yyerror("BEGIN in method");
05041                         }
05042 #if 0
05043                         /* local_push(0); */
05044 #endif
05045 
05046                     ;}
05047     break;
05048 
05049   case 11:
05050 
05051 /* Line 1464 of yacc.c  */
05052 #line 871 "ripper.y"
05053     {
05054 #if 0
05055                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05056                                                             (yyvsp[(4) - (5)].val));
05057                         /* NEW_PREEXE($4)); */
05058                         /* local_pop(); */
05059                         (yyval.val) = NEW_BEGIN(0);
05060 #endif
05061                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05062 
05063                     ;}
05064     break;
05065 
05066   case 12:
05067 
05068 /* Line 1464 of yacc.c  */
05069 #line 888 "ripper.y"
05070     {
05071 #if 0
05072                         (yyval.val) = (yyvsp[(1) - (4)].val);
05073                         if ((yyvsp[(2) - (4)].val)) {
05074                             (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05075                         }
05076                         else if ((yyvsp[(3) - (4)].val)) {
05077                             rb_warn0("else without rescue is useless");
05078                             (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
05079                         }
05080                         if ((yyvsp[(4) - (4)].val)) {
05081                             if ((yyval.val)) {
05082                                 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
05083                             }
05084                             else {
05085                                 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
05086                             }
05087                         }
05088                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05089 #endif
05090                         (yyval.val) = dispatch4(bodystmt,
05091                                        escape_Qundef((yyvsp[(1) - (4)].val)),
05092                                        escape_Qundef((yyvsp[(2) - (4)].val)),
05093                                        escape_Qundef((yyvsp[(3) - (4)].val)),
05094                                        escape_Qundef((yyvsp[(4) - (4)].val)));
05095 
05096                     ;}
05097     break;
05098 
05099   case 13:
05100 
05101 /* Line 1464 of yacc.c  */
05102 #line 918 "ripper.y"
05103     {
05104 #if 0
05105                         void_stmts((yyvsp[(1) - (2)].val));
05106                         fixup_nodes(&deferred_nodes);
05107 #endif
05108 
05109                         (yyval.val) = (yyvsp[(1) - (2)].val);
05110                     ;}
05111     break;
05112 
05113   case 14:
05114 
05115 /* Line 1464 of yacc.c  */
05116 #line 929 "ripper.y"
05117     {
05118 #if 0
05119                         (yyval.val) = NEW_BEGIN(0);
05120 #endif
05121                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05122                                                   dispatch0(void_stmt));
05123 
05124                     ;}
05125     break;
05126 
05127   case 15:
05128 
05129 /* Line 1464 of yacc.c  */
05130 #line 938 "ripper.y"
05131     {
05132 #if 0
05133                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05134 #endif
05135                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05136 
05137                     ;}
05138     break;
05139 
05140   case 16:
05141 
05142 /* Line 1464 of yacc.c  */
05143 #line 946 "ripper.y"
05144     {
05145 #if 0
05146                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05147 #endif
05148                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05149 
05150                     ;}
05151     break;
05152 
05153   case 17:
05154 
05155 /* Line 1464 of yacc.c  */
05156 #line 954 "ripper.y"
05157     {
05158                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05159                     ;}
05160     break;
05161 
05162   case 18:
05163 
05164 /* Line 1464 of yacc.c  */
05165 #line 959 "ripper.y"
05166     {lex_state = EXPR_FNAME;;}
05167     break;
05168 
05169   case 19:
05170 
05171 /* Line 1464 of yacc.c  */
05172 #line 960 "ripper.y"
05173     {
05174 #if 0
05175                         (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05176 #endif
05177                         (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05178 
05179                     ;}
05180     break;
05181 
05182   case 20:
05183 
05184 /* Line 1464 of yacc.c  */
05185 #line 968 "ripper.y"
05186     {
05187 #if 0
05188                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05189 #endif
05190                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05191 
05192                     ;}
05193     break;
05194 
05195   case 21:
05196 
05197 /* Line 1464 of yacc.c  */
05198 #line 976 "ripper.y"
05199     {
05200 #if 0
05201                         char buf[2];
05202                         buf[0] = '$';
05203                         buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
05204                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
05205 #endif
05206                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05207 
05208                     ;}
05209     break;
05210 
05211   case 22:
05212 
05213 /* Line 1464 of yacc.c  */
05214 #line 987 "ripper.y"
05215     {
05216 #if 0
05217                         yyerror("can't make alias for the number variables");
05218                         (yyval.val) = NEW_BEGIN(0);
05219 #endif
05220                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05221                         (yyval.val) = dispatch1(alias_error, (yyval.val));
05222 
05223                     ;}
05224     break;
05225 
05226   case 23:
05227 
05228 /* Line 1464 of yacc.c  */
05229 #line 997 "ripper.y"
05230     {
05231 #if 0
05232                         (yyval.val) = (yyvsp[(2) - (2)].val);
05233 #endif
05234                         (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
05235 
05236                     ;}
05237     break;
05238 
05239   case 24:
05240 
05241 /* Line 1464 of yacc.c  */
05242 #line 1005 "ripper.y"
05243     {
05244 #if 0
05245                         (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05246                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05247 #endif
05248                         (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05249 
05250                     ;}
05251     break;
05252 
05253   case 25:
05254 
05255 /* Line 1464 of yacc.c  */
05256 #line 1014 "ripper.y"
05257     {
05258 #if 0
05259                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05260                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05261 #endif
05262                         (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05263 
05264                     ;}
05265     break;
05266 
05267   case 26:
05268 
05269 /* Line 1464 of yacc.c  */
05270 #line 1023 "ripper.y"
05271     {
05272 #if 0
05273                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05274                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05275                         }
05276                         else {
05277                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05278                         }
05279 #endif
05280                         (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05281 
05282                     ;}
05283     break;
05284 
05285   case 27:
05286 
05287 /* Line 1464 of yacc.c  */
05288 #line 1036 "ripper.y"
05289     {
05290 #if 0
05291                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05292                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05293                         }
05294                         else {
05295                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05296                         }
05297 #endif
05298                         (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05299 
05300                     ;}
05301     break;
05302 
05303   case 28:
05304 
05305 /* Line 1464 of yacc.c  */
05306 #line 1049 "ripper.y"
05307     {
05308 #if 0
05309                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
05310                         (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
05311 #endif
05312                         (yyval.val) = dispatch2(rescue_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05313 
05314                     ;}
05315     break;
05316 
05317   case 29:
05318 
05319 /* Line 1464 of yacc.c  */
05320 #line 1058 "ripper.y"
05321     {
05322                         if (in_def || in_single) {
05323                             rb_warn0("END in method; use at_exit");
05324                         }
05325 #if 0
05326                         (yyval.val) = NEW_POSTEXE(NEW_NODE(
05327                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
05328 #endif
05329                         (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
05330 
05331                     ;}
05332     break;
05333 
05334   case 30:
05335 
05336 /* Line 1464 of yacc.c  */
05337 #line 1070 "ripper.y"
05338     {
05339 #if 0
05340                         value_expr((yyvsp[(3) - (3)].val));
05341                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05342 #endif
05343                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05344 
05345                     ;}
05346     break;
05347 
05348   case 31:
05349 
05350 /* Line 1464 of yacc.c  */
05351 #line 1079 "ripper.y"
05352     {
05353 #if 0
05354                         value_expr((yyvsp[(3) - (3)].val));
05355                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05356                         (yyval.val) = (yyvsp[(1) - (3)].val);
05357 #endif
05358                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05359 
05360                     ;}
05361     break;
05362 
05363   case 32:
05364 
05365 /* Line 1464 of yacc.c  */
05366 #line 1089 "ripper.y"
05367     {
05368 #if 0
05369                         value_expr((yyvsp[(3) - (3)].val));
05370                         if ((yyvsp[(1) - (3)].val)) {
05371                             ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
05372                             if ((yyvsp[(2) - (3)].val) == tOROP) {
05373                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05374                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
05375                                 if (is_asgn_or_id(vid)) {
05376                                     (yyval.val)->nd_aid = vid;
05377                                 }
05378                             }
05379                             else if ((yyvsp[(2) - (3)].val) == tANDOP) {
05380                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05381                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
05382                             }
05383                             else {
05384                                 (yyval.val) = (yyvsp[(1) - (3)].val);
05385                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
05386                             }
05387                         }
05388                         else {
05389                             (yyval.val) = NEW_BEGIN(0);
05390                         }
05391 #endif
05392                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05393 
05394                     ;}
05395     break;
05396 
05397   case 33:
05398 
05399 /* Line 1464 of yacc.c  */
05400 #line 1118 "ripper.y"
05401     {
05402 #if 0
05403                         NODE *args;
05404 
05405                         value_expr((yyvsp[(6) - (6)].val));
05406                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
05407                         args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
05408                         if ((yyvsp[(5) - (6)].val) == tOROP) {
05409                             (yyvsp[(5) - (6)].val) = 0;
05410                         }
05411                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
05412                             (yyvsp[(5) - (6)].val) = 1;
05413                         }
05414                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
05415                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
05416 #endif
05417                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
05418                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
05419 
05420                     ;}
05421     break;
05422 
05423   case 34:
05424 
05425 /* Line 1464 of yacc.c  */
05426 #line 1139 "ripper.y"
05427     {
05428 #if 0
05429                         value_expr((yyvsp[(5) - (5)].val));
05430                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05431                             (yyvsp[(4) - (5)].val) = 0;
05432                         }
05433                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05434                             (yyvsp[(4) - (5)].val) = 1;
05435                         }
05436                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05437                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05438 #endif
05439                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
05440                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05441 
05442                     ;}
05443     break;
05444 
05445   case 35:
05446 
05447 /* Line 1464 of yacc.c  */
05448 #line 1156 "ripper.y"
05449     {
05450 #if 0
05451                         value_expr((yyvsp[(5) - (5)].val));
05452                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05453                             (yyvsp[(4) - (5)].val) = 0;
05454                         }
05455                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05456                             (yyvsp[(4) - (5)].val) = 1;
05457                         }
05458                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05459                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05460 #endif
05461                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
05462                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05463 
05464                     ;}
05465     break;
05466 
05467   case 36:
05468 
05469 /* Line 1464 of yacc.c  */
05470 #line 1173 "ripper.y"
05471     {
05472 #if 0
05473                         yyerror("constant re-assignment");
05474                         (yyval.val) = 0;
05475 #endif
05476                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05477                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05478                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05479 
05480                     ;}
05481     break;
05482 
05483   case 37:
05484 
05485 /* Line 1464 of yacc.c  */
05486 #line 1184 "ripper.y"
05487     {
05488 #if 0
05489                         value_expr((yyvsp[(5) - (5)].val));
05490                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05491                             (yyvsp[(4) - (5)].val) = 0;
05492                         }
05493                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05494                             (yyvsp[(4) - (5)].val) = 1;
05495                         }
05496                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05497                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05498 #endif
05499                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
05500                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05501 
05502                     ;}
05503     break;
05504 
05505   case 38:
05506 
05507 /* Line 1464 of yacc.c  */
05508 #line 1201 "ripper.y"
05509     {
05510 #if 0
05511                         rb_backref_error((yyvsp[(1) - (3)].val));
05512                         (yyval.val) = NEW_BEGIN(0);
05513 #endif
05514                         (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
05515                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05516 
05517                     ;}
05518     break;
05519 
05520   case 39:
05521 
05522 /* Line 1464 of yacc.c  */
05523 #line 1211 "ripper.y"
05524     {
05525 #if 0
05526                         value_expr((yyvsp[(3) - (3)].val));
05527                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05528 #endif
05529                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05530 
05531                     ;}
05532     break;
05533 
05534   case 40:
05535 
05536 /* Line 1464 of yacc.c  */
05537 #line 1220 "ripper.y"
05538     {
05539 #if 0
05540                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05541                         (yyval.val) = (yyvsp[(1) - (3)].val);
05542 #endif
05543                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05544 
05545                     ;}
05546     break;
05547 
05548   case 41:
05549 
05550 /* Line 1464 of yacc.c  */
05551 #line 1229 "ripper.y"
05552     {
05553 #if 0
05554                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05555                         (yyval.val) = (yyvsp[(1) - (3)].val);
05556 #endif
05557                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05558 
05559                     ;}
05560     break;
05561 
05562   case 44:
05563 
05564 /* Line 1464 of yacc.c  */
05565 #line 1242 "ripper.y"
05566     {
05567 #if 0
05568                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05569 #endif
05570                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
05571 
05572                     ;}
05573     break;
05574 
05575   case 45:
05576 
05577 /* Line 1464 of yacc.c  */
05578 #line 1250 "ripper.y"
05579     {
05580 #if 0
05581                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05582 #endif
05583                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
05584 
05585                     ;}
05586     break;
05587 
05588   case 46:
05589 
05590 /* Line 1464 of yacc.c  */
05591 #line 1258 "ripper.y"
05592     {
05593 #if 0
05594                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
05595 #endif
05596                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
05597 
05598                     ;}
05599     break;
05600 
05601   case 47:
05602 
05603 /* Line 1464 of yacc.c  */
05604 #line 1266 "ripper.y"
05605     {
05606 #if 0
05607                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
05608 #endif
05609                         (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
05610 
05611                     ;}
05612     break;
05613 
05614   case 49:
05615 
05616 /* Line 1464 of yacc.c  */
05617 #line 1277 "ripper.y"
05618     {
05619 #if 0
05620                         value_expr((yyvsp[(1) - (1)].val));
05621                         (yyval.val) = (yyvsp[(1) - (1)].val);
05622                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
05623 #endif
05624                         (yyval.val) = (yyvsp[(1) - (1)].val);
05625 
05626                     ;}
05627     break;
05628 
05629   case 53:
05630 
05631 /* Line 1464 of yacc.c  */
05632 #line 1294 "ripper.y"
05633     {
05634 #if 0
05635                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05636 #endif
05637                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
05638                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05639 
05640                     ;}
05641     break;
05642 
05643   case 54:
05644 
05645 /* Line 1464 of yacc.c  */
05646 #line 1303 "ripper.y"
05647     {
05648 #if 0
05649                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05650 #endif
05651                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
05652                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05653 
05654                     ;}
05655     break;
05656 
05657   case 55:
05658 
05659 /* Line 1464 of yacc.c  */
05660 #line 1314 "ripper.y"
05661     {
05662                         (yyvsp[(1) - (1)].vars) = dyna_push();
05663 #if 0
05664                         (yyval.num) = ruby_sourceline;
05665 #endif
05666 
05667                     ;}
05668     break;
05669 
05670   case 56:
05671 
05672 /* Line 1464 of yacc.c  */
05673 #line 1324 "ripper.y"
05674     {
05675 #if 0
05676                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
05677                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
05678 #endif
05679                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
05680 
05681                         dyna_pop((yyvsp[(1) - (5)].vars));
05682                     ;}
05683     break;
05684 
05685   case 57:
05686 
05687 /* Line 1464 of yacc.c  */
05688 #line 1336 "ripper.y"
05689     {
05690 #if 0
05691                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05692                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05693 #endif
05694                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05695 
05696                     ;}
05697     break;
05698 
05699   case 58:
05700 
05701 /* Line 1464 of yacc.c  */
05702 #line 1345 "ripper.y"
05703     {
05704 #if 0
05705                         block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
05706                         (yyvsp[(3) - (3)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05707                         (yyval.val) = (yyvsp[(3) - (3)].val);
05708                         fixpos((yyval.val), (yyvsp[(2) - (3)].val));
05709 #endif
05710                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05711                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
05712 
05713                     ;}
05714     break;
05715 
05716   case 59:
05717 
05718 /* Line 1464 of yacc.c  */
05719 #line 1357 "ripper.y"
05720     {
05721 #if 0
05722                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05723                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05724 #endif
05725                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05726 
05727                     ;}
05728     break;
05729 
05730   case 60:
05731 
05732 /* Line 1464 of yacc.c  */
05733 #line 1366 "ripper.y"
05734     {
05735 #if 0
05736                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05737                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05738                         (yyval.val) = (yyvsp[(5) - (5)].val);
05739                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05740 #endif
05741                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05742                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05743 
05744                    ;}
05745     break;
05746 
05747   case 61:
05748 
05749 /* Line 1464 of yacc.c  */
05750 #line 1378 "ripper.y"
05751     {
05752 #if 0
05753                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05754                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05755 #endif
05756                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05757 
05758                     ;}
05759     break;
05760 
05761   case 62:
05762 
05763 /* Line 1464 of yacc.c  */
05764 #line 1387 "ripper.y"
05765     {
05766 #if 0
05767                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05768                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05769                         (yyval.val) = (yyvsp[(5) - (5)].val);
05770                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05771 #endif
05772                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05773                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05774 
05775                    ;}
05776     break;
05777 
05778   case 63:
05779 
05780 /* Line 1464 of yacc.c  */
05781 #line 1399 "ripper.y"
05782     {
05783 #if 0
05784                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
05785                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05786 #endif
05787                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
05788 
05789                     ;}
05790     break;
05791 
05792   case 64:
05793 
05794 /* Line 1464 of yacc.c  */
05795 #line 1408 "ripper.y"
05796     {
05797 #if 0
05798                         (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
05799                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05800 #endif
05801                         (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
05802 
05803                     ;}
05804     break;
05805 
05806   case 65:
05807 
05808 /* Line 1464 of yacc.c  */
05809 #line 1417 "ripper.y"
05810     {
05811 #if 0
05812                         (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
05813 #endif
05814                         (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
05815 
05816                     ;}
05817     break;
05818 
05819   case 66:
05820 
05821 /* Line 1464 of yacc.c  */
05822 #line 1425 "ripper.y"
05823     {
05824 #if 0
05825                         (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
05826 #endif
05827                         (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
05828 
05829                     ;}
05830     break;
05831 
05832   case 67:
05833 
05834 /* Line 1464 of yacc.c  */
05835 #line 1433 "ripper.y"
05836     {
05837 #if 0
05838                         (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
05839 #endif
05840                         (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
05841 
05842                     ;}
05843     break;
05844 
05845   case 69:
05846 
05847 /* Line 1464 of yacc.c  */
05848 #line 1444 "ripper.y"
05849     {
05850 #if 0
05851                         (yyval.val) = (yyvsp[(2) - (3)].val);
05852 #endif
05853                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
05854 
05855                     ;}
05856     break;
05857 
05858   case 71:
05859 
05860 /* Line 1464 of yacc.c  */
05861 #line 1455 "ripper.y"
05862     {
05863 #if 0
05864                         (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
05865 #endif
05866                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
05867 
05868                     ;}
05869     break;
05870 
05871   case 72:
05872 
05873 /* Line 1464 of yacc.c  */
05874 #line 1465 "ripper.y"
05875     {
05876 #if 0
05877                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
05878 #endif
05879                         (yyval.val) = (yyvsp[(1) - (1)].val);
05880 
05881                     ;}
05882     break;
05883 
05884   case 73:
05885 
05886 /* Line 1464 of yacc.c  */
05887 #line 1473 "ripper.y"
05888     {
05889 #if 0
05890                         (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
05891 #endif
05892                         (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05893 
05894                     ;}
05895     break;
05896 
05897   case 74:
05898 
05899 /* Line 1464 of yacc.c  */
05900 #line 1481 "ripper.y"
05901     {
05902 #if 0
05903                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05904 #endif
05905                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05906 
05907                     ;}
05908     break;
05909 
05910   case 75:
05911 
05912 /* Line 1464 of yacc.c  */
05913 #line 1489 "ripper.y"
05914     {
05915 #if 0
05916                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
05917 #endif
05918                         (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05919                         (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
05920 
05921                     ;}
05922     break;
05923 
05924   case 76:
05925 
05926 /* Line 1464 of yacc.c  */
05927 #line 1498 "ripper.y"
05928     {
05929 #if 0
05930                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
05931 #endif
05932                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
05933 
05934                     ;}
05935     break;
05936 
05937   case 77:
05938 
05939 /* Line 1464 of yacc.c  */
05940 #line 1506 "ripper.y"
05941     {
05942 #if 0
05943                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
05944 #endif
05945                         (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
05946                         (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
05947 
05948                     ;}
05949     break;
05950 
05951   case 78:
05952 
05953 /* Line 1464 of yacc.c  */
05954 #line 1515 "ripper.y"
05955     {
05956 #if 0
05957                         (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
05958 #endif
05959                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
05960 
05961                     ;}
05962     break;
05963 
05964   case 79:
05965 
05966 /* Line 1464 of yacc.c  */
05967 #line 1523 "ripper.y"
05968     {
05969 #if 0
05970                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
05971 #endif
05972                         (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
05973                         (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05974 
05975                     ;}
05976     break;
05977 
05978   case 80:
05979 
05980 /* Line 1464 of yacc.c  */
05981 #line 1532 "ripper.y"
05982     {
05983 #if 0
05984                         (yyval.val) = NEW_MASGN(0, -1);
05985 #endif
05986                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
05987 
05988                     ;}
05989     break;
05990 
05991   case 81:
05992 
05993 /* Line 1464 of yacc.c  */
05994 #line 1540 "ripper.y"
05995     {
05996 #if 0
05997                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
05998 #endif
05999                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06000                         (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
06001 
06002                     ;}
06003     break;
06004 
06005   case 83:
06006 
06007 /* Line 1464 of yacc.c  */
06008 #line 1552 "ripper.y"
06009     {
06010 #if 0
06011                         (yyval.val) = (yyvsp[(2) - (3)].val);
06012 #endif
06013                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06014 
06015                     ;}
06016     break;
06017 
06018   case 84:
06019 
06020 /* Line 1464 of yacc.c  */
06021 #line 1562 "ripper.y"
06022     {
06023 #if 0
06024                         (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
06025 #endif
06026                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
06027 
06028                     ;}
06029     break;
06030 
06031   case 85:
06032 
06033 /* Line 1464 of yacc.c  */
06034 #line 1570 "ripper.y"
06035     {
06036 #if 0
06037                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06038 #endif
06039                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06040 
06041                     ;}
06042     break;
06043 
06044   case 86:
06045 
06046 /* Line 1464 of yacc.c  */
06047 #line 1580 "ripper.y"
06048     {
06049 #if 0
06050                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
06051 #endif
06052                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
06053 
06054                     ;}
06055     break;
06056 
06057   case 87:
06058 
06059 /* Line 1464 of yacc.c  */
06060 #line 1588 "ripper.y"
06061     {
06062 #if 0
06063                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06064 #endif
06065                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06066 
06067                     ;}
06068     break;
06069 
06070   case 88:
06071 
06072 /* Line 1464 of yacc.c  */
06073 #line 1598 "ripper.y"
06074     {
06075                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06076                     ;}
06077     break;
06078 
06079   case 89:
06080 
06081 /* Line 1464 of yacc.c  */
06082 #line 1602 "ripper.y"
06083     {
06084 #if 0
06085                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06086 #endif
06087                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06088 
06089                     ;}
06090     break;
06091 
06092   case 90:
06093 
06094 /* Line 1464 of yacc.c  */
06095 #line 1610 "ripper.y"
06096     {
06097 #if 0
06098                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06099 #endif
06100                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06101 
06102                     ;}
06103     break;
06104 
06105   case 91:
06106 
06107 /* Line 1464 of yacc.c  */
06108 #line 1618 "ripper.y"
06109     {
06110 #if 0
06111                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06112 #endif
06113                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06114 
06115                     ;}
06116     break;
06117 
06118   case 92:
06119 
06120 /* Line 1464 of yacc.c  */
06121 #line 1626 "ripper.y"
06122     {
06123 #if 0
06124                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06125 #endif
06126                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06127 
06128                     ;}
06129     break;
06130 
06131   case 93:
06132 
06133 /* Line 1464 of yacc.c  */
06134 #line 1634 "ripper.y"
06135     {
06136 #if 0
06137                         if (in_def || in_single)
06138                             yyerror("dynamic constant assignment");
06139                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06140 #endif
06141                         if (in_def || in_single)
06142                             yyerror("dynamic constant assignment");
06143                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06144 
06145                     ;}
06146     break;
06147 
06148   case 94:
06149 
06150 /* Line 1464 of yacc.c  */
06151 #line 1646 "ripper.y"
06152     {
06153 #if 0
06154                         if (in_def || in_single)
06155                             yyerror("dynamic constant assignment");
06156                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06157 #endif
06158                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06159 
06160                     ;}
06161     break;
06162 
06163   case 95:
06164 
06165 /* Line 1464 of yacc.c  */
06166 #line 1656 "ripper.y"
06167     {
06168 #if 0
06169                         rb_backref_error((yyvsp[(1) - (1)].val));
06170                         (yyval.val) = NEW_BEGIN(0);
06171 #endif
06172                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
06173                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06174 
06175                     ;}
06176     break;
06177 
06178   case 96:
06179 
06180 /* Line 1464 of yacc.c  */
06181 #line 1668 "ripper.y"
06182     {
06183                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06184 #if 0
06185                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06186 #endif
06187                         (yyval.val) = dispatch1(var_field, (yyval.val));
06188 
06189                     ;}
06190     break;
06191 
06192   case 97:
06193 
06194 /* Line 1464 of yacc.c  */
06195 #line 1677 "ripper.y"
06196     {
06197 #if 0
06198                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06199 #endif
06200                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06201 
06202                     ;}
06203     break;
06204 
06205   case 98:
06206 
06207 /* Line 1464 of yacc.c  */
06208 #line 1685 "ripper.y"
06209     {
06210 #if 0
06211                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06212 #endif
06213                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06214 
06215                     ;}
06216     break;
06217 
06218   case 99:
06219 
06220 /* Line 1464 of yacc.c  */
06221 #line 1693 "ripper.y"
06222     {
06223 #if 0
06224                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06225 #endif
06226                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
06227 
06228                     ;}
06229     break;
06230 
06231   case 100:
06232 
06233 /* Line 1464 of yacc.c  */
06234 #line 1701 "ripper.y"
06235     {
06236 #if 0
06237                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06238 #endif
06239                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06240 
06241                     ;}
06242     break;
06243 
06244   case 101:
06245 
06246 /* Line 1464 of yacc.c  */
06247 #line 1709 "ripper.y"
06248     {
06249 #if 0
06250                         if (in_def || in_single)
06251                             yyerror("dynamic constant assignment");
06252                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06253 #endif
06254                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06255                         if (in_def || in_single) {
06256                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06257                         }
06258 
06259                     ;}
06260     break;
06261 
06262   case 102:
06263 
06264 /* Line 1464 of yacc.c  */
06265 #line 1722 "ripper.y"
06266     {
06267 #if 0
06268                         if (in_def || in_single)
06269                             yyerror("dynamic constant assignment");
06270                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06271 #endif
06272                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06273                         if (in_def || in_single) {
06274                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06275                         }
06276 
06277                     ;}
06278     break;
06279 
06280   case 103:
06281 
06282 /* Line 1464 of yacc.c  */
06283 #line 1735 "ripper.y"
06284     {
06285 #if 0
06286                         rb_backref_error((yyvsp[(1) - (1)].val));
06287                         (yyval.val) = NEW_BEGIN(0);
06288 #endif
06289                         (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
06290 
06291                     ;}
06292     break;
06293 
06294   case 104:
06295 
06296 /* Line 1464 of yacc.c  */
06297 #line 1746 "ripper.y"
06298     {
06299 #if 0
06300                         yyerror("class/module name must be CONSTANT");
06301 #endif
06302                         (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
06303 
06304                     ;}
06305     break;
06306 
06307   case 106:
06308 
06309 /* Line 1464 of yacc.c  */
06310 #line 1757 "ripper.y"
06311     {
06312 #if 0
06313                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
06314 #endif
06315                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
06316 
06317                     ;}
06318     break;
06319 
06320   case 107:
06321 
06322 /* Line 1464 of yacc.c  */
06323 #line 1765 "ripper.y"
06324     {
06325 #if 0
06326                         (yyval.val) = NEW_COLON2(0, (yyval.val));
06327 #endif
06328                         (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
06329 
06330                     ;}
06331     break;
06332 
06333   case 108:
06334 
06335 /* Line 1464 of yacc.c  */
06336 #line 1773 "ripper.y"
06337     {
06338 #if 0
06339                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06340 #endif
06341                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06342 
06343                     ;}
06344     break;
06345 
06346   case 112:
06347 
06348 /* Line 1464 of yacc.c  */
06349 #line 1786 "ripper.y"
06350     {
06351                         lex_state = EXPR_ENDFN;
06352                         (yyval.val) = (yyvsp[(1) - (1)].val);
06353                     ;}
06354     break;
06355 
06356   case 113:
06357 
06358 /* Line 1464 of yacc.c  */
06359 #line 1791 "ripper.y"
06360     {
06361                         lex_state = EXPR_ENDFN;
06362 #if 0
06363                         (yyval.val) = (yyvsp[(1) - (1)].id);
06364 #endif
06365                         (yyval.val) = (yyvsp[(1) - (1)].val);
06366 
06367                     ;}
06368     break;
06369 
06370   case 116:
06371 
06372 /* Line 1464 of yacc.c  */
06373 #line 1806 "ripper.y"
06374     {
06375 #if 0
06376                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
06377 #endif
06378                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
06379 
06380                     ;}
06381     break;
06382 
06383   case 118:
06384 
06385 /* Line 1464 of yacc.c  */
06386 #line 1817 "ripper.y"
06387     {
06388 #if 0
06389                         (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
06390 #endif
06391                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
06392 
06393                     ;}
06394     break;
06395 
06396   case 119:
06397 
06398 /* Line 1464 of yacc.c  */
06399 #line 1824 "ripper.y"
06400     {lex_state = EXPR_FNAME;;}
06401     break;
06402 
06403   case 120:
06404 
06405 /* Line 1464 of yacc.c  */
06406 #line 1825 "ripper.y"
06407     {
06408 #if 0
06409                         (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
06410 #endif
06411                         rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06412 
06413                     ;}
06414     break;
06415 
06416   case 121:
06417 
06418 /* Line 1464 of yacc.c  */
06419 #line 1834 "ripper.y"
06420     { ifndef_ripper((yyval.val) = '|'); ;}
06421     break;
06422 
06423   case 122:
06424 
06425 /* Line 1464 of yacc.c  */
06426 #line 1835 "ripper.y"
06427     { ifndef_ripper((yyval.val) = '^'); ;}
06428     break;
06429 
06430   case 123:
06431 
06432 /* Line 1464 of yacc.c  */
06433 #line 1836 "ripper.y"
06434     { ifndef_ripper((yyval.val) = '&'); ;}
06435     break;
06436 
06437   case 124:
06438 
06439 /* Line 1464 of yacc.c  */
06440 #line 1837 "ripper.y"
06441     { ifndef_ripper((yyval.val) = tCMP); ;}
06442     break;
06443 
06444   case 125:
06445 
06446 /* Line 1464 of yacc.c  */
06447 #line 1838 "ripper.y"
06448     { ifndef_ripper((yyval.val) = tEQ); ;}
06449     break;
06450 
06451   case 126:
06452 
06453 /* Line 1464 of yacc.c  */
06454 #line 1839 "ripper.y"
06455     { ifndef_ripper((yyval.val) = tEQQ); ;}
06456     break;
06457 
06458   case 127:
06459 
06460 /* Line 1464 of yacc.c  */
06461 #line 1840 "ripper.y"
06462     { ifndef_ripper((yyval.val) = tMATCH); ;}
06463     break;
06464 
06465   case 128:
06466 
06467 /* Line 1464 of yacc.c  */
06468 #line 1841 "ripper.y"
06469     { ifndef_ripper((yyval.val) = tNMATCH); ;}
06470     break;
06471 
06472   case 129:
06473 
06474 /* Line 1464 of yacc.c  */
06475 #line 1842 "ripper.y"
06476     { ifndef_ripper((yyval.val) = '>'); ;}
06477     break;
06478 
06479   case 130:
06480 
06481 /* Line 1464 of yacc.c  */
06482 #line 1843 "ripper.y"
06483     { ifndef_ripper((yyval.val) = tGEQ); ;}
06484     break;
06485 
06486   case 131:
06487 
06488 /* Line 1464 of yacc.c  */
06489 #line 1844 "ripper.y"
06490     { ifndef_ripper((yyval.val) = '<'); ;}
06491     break;
06492 
06493   case 132:
06494 
06495 /* Line 1464 of yacc.c  */
06496 #line 1845 "ripper.y"
06497     { ifndef_ripper((yyval.val) = tLEQ); ;}
06498     break;
06499 
06500   case 133:
06501 
06502 /* Line 1464 of yacc.c  */
06503 #line 1846 "ripper.y"
06504     { ifndef_ripper((yyval.val) = tNEQ); ;}
06505     break;
06506 
06507   case 134:
06508 
06509 /* Line 1464 of yacc.c  */
06510 #line 1847 "ripper.y"
06511     { ifndef_ripper((yyval.val) = tLSHFT); ;}
06512     break;
06513 
06514   case 135:
06515 
06516 /* Line 1464 of yacc.c  */
06517 #line 1848 "ripper.y"
06518     { ifndef_ripper((yyval.val) = tRSHFT); ;}
06519     break;
06520 
06521   case 136:
06522 
06523 /* Line 1464 of yacc.c  */
06524 #line 1849 "ripper.y"
06525     { ifndef_ripper((yyval.val) = '+'); ;}
06526     break;
06527 
06528   case 137:
06529 
06530 /* Line 1464 of yacc.c  */
06531 #line 1850 "ripper.y"
06532     { ifndef_ripper((yyval.val) = '-'); ;}
06533     break;
06534 
06535   case 138:
06536 
06537 /* Line 1464 of yacc.c  */
06538 #line 1851 "ripper.y"
06539     { ifndef_ripper((yyval.val) = '*'); ;}
06540     break;
06541 
06542   case 139:
06543 
06544 /* Line 1464 of yacc.c  */
06545 #line 1852 "ripper.y"
06546     { ifndef_ripper((yyval.val) = '*'); ;}
06547     break;
06548 
06549   case 140:
06550 
06551 /* Line 1464 of yacc.c  */
06552 #line 1853 "ripper.y"
06553     { ifndef_ripper((yyval.val) = '/'); ;}
06554     break;
06555 
06556   case 141:
06557 
06558 /* Line 1464 of yacc.c  */
06559 #line 1854 "ripper.y"
06560     { ifndef_ripper((yyval.val) = '%'); ;}
06561     break;
06562 
06563   case 142:
06564 
06565 /* Line 1464 of yacc.c  */
06566 #line 1855 "ripper.y"
06567     { ifndef_ripper((yyval.val) = tPOW); ;}
06568     break;
06569 
06570   case 143:
06571 
06572 /* Line 1464 of yacc.c  */
06573 #line 1856 "ripper.y"
06574     { ifndef_ripper((yyval.val) = '!'); ;}
06575     break;
06576 
06577   case 144:
06578 
06579 /* Line 1464 of yacc.c  */
06580 #line 1857 "ripper.y"
06581     { ifndef_ripper((yyval.val) = '~'); ;}
06582     break;
06583 
06584   case 145:
06585 
06586 /* Line 1464 of yacc.c  */
06587 #line 1858 "ripper.y"
06588     { ifndef_ripper((yyval.val) = tUPLUS); ;}
06589     break;
06590 
06591   case 146:
06592 
06593 /* Line 1464 of yacc.c  */
06594 #line 1859 "ripper.y"
06595     { ifndef_ripper((yyval.val) = tUMINUS); ;}
06596     break;
06597 
06598   case 147:
06599 
06600 /* Line 1464 of yacc.c  */
06601 #line 1860 "ripper.y"
06602     { ifndef_ripper((yyval.val) = tAREF); ;}
06603     break;
06604 
06605   case 148:
06606 
06607 /* Line 1464 of yacc.c  */
06608 #line 1861 "ripper.y"
06609     { ifndef_ripper((yyval.val) = tASET); ;}
06610     break;
06611 
06612   case 149:
06613 
06614 /* Line 1464 of yacc.c  */
06615 #line 1862 "ripper.y"
06616     { ifndef_ripper((yyval.val) = '`'); ;}
06617     break;
06618 
06619   case 191:
06620 
06621 /* Line 1464 of yacc.c  */
06622 #line 1880 "ripper.y"
06623     {
06624 #if 0
06625                         value_expr((yyvsp[(3) - (3)].val));
06626                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06627 #endif
06628                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06629 
06630                     ;}
06631     break;
06632 
06633   case 192:
06634 
06635 /* Line 1464 of yacc.c  */
06636 #line 1889 "ripper.y"
06637     {
06638 #if 0
06639                         value_expr((yyvsp[(3) - (5)].val));
06640                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06641                         (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06642 #endif
06643                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
06644 
06645                     ;}
06646     break;
06647 
06648   case 193:
06649 
06650 /* Line 1464 of yacc.c  */
06651 #line 1899 "ripper.y"
06652     {
06653 #if 0
06654                         value_expr((yyvsp[(3) - (3)].val));
06655                         if ((yyvsp[(1) - (3)].val)) {
06656                             ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
06657                             if ((yyvsp[(2) - (3)].val) == tOROP) {
06658                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
06659                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
06660                                 if (is_asgn_or_id(vid)) {
06661                                     (yyval.val)->nd_aid = vid;
06662                                 }
06663                             }
06664                             else if ((yyvsp[(2) - (3)].val) == tANDOP) {
06665                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
06666                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
06667                             }
06668                             else {
06669                                 (yyval.val) = (yyvsp[(1) - (3)].val);
06670                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
06671                             }
06672                         }
06673                         else {
06674                             (yyval.val) = NEW_BEGIN(0);
06675                         }
06676 #endif
06677                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06678 
06679                     ;}
06680     break;
06681 
06682   case 194:
06683 
06684 /* Line 1464 of yacc.c  */
06685 #line 1928 "ripper.y"
06686     {
06687 #if 0
06688                         value_expr((yyvsp[(3) - (5)].val));
06689                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06690                         if ((yyvsp[(1) - (5)].val)) {
06691                             ID vid = (yyvsp[(1) - (5)].val)->nd_vid;
06692                             if ((yyvsp[(2) - (5)].val) == tOROP) {
06693                                 (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
06694                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (5)].val));
06695                                 if (is_asgn_or_id(vid)) {
06696                                     (yyval.val)->nd_aid = vid;
06697                                 }
06698                             }
06699                             else if ((yyvsp[(2) - (5)].val) == tANDOP) {
06700                                 (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
06701                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (5)].val));
06702                             }
06703                             else {
06704                                 (yyval.val) = (yyvsp[(1) - (5)].val);
06705                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (5)].val), NEW_LIST((yyvsp[(3) - (5)].val)));
06706                             }
06707                         }
06708                         else {
06709                             (yyval.val) = NEW_BEGIN(0);
06710                         }
06711 #endif
06712                         (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
06713                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
06714 
06715                     ;}
06716     break;
06717 
06718   case 195:
06719 
06720 /* Line 1464 of yacc.c  */
06721 #line 1959 "ripper.y"
06722     {
06723 #if 0
06724                         NODE *args;
06725 
06726                         value_expr((yyvsp[(6) - (6)].val));
06727                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
06728                         if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
06729                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06730                         }
06731                         else {
06732                             args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06733                         }
06734                         if ((yyvsp[(5) - (6)].val) == tOROP) {
06735                             (yyvsp[(5) - (6)].val) = 0;
06736                         }
06737                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
06738                             (yyvsp[(5) - (6)].val) = 1;
06739                         }
06740                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
06741                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
06742 #endif
06743                         (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
06744                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
06745 
06746                     ;}
06747     break;
06748 
06749   case 196:
06750 
06751 /* Line 1464 of yacc.c  */
06752 #line 1985 "ripper.y"
06753     {
06754 #if 0
06755                         value_expr((yyvsp[(5) - (5)].val));
06756                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06757                             (yyvsp[(4) - (5)].val) = 0;
06758                         }
06759                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06760                             (yyvsp[(4) - (5)].val) = 1;
06761                         }
06762                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06763                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06764 #endif
06765                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
06766                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06767 
06768                     ;}
06769     break;
06770 
06771   case 197:
06772 
06773 /* Line 1464 of yacc.c  */
06774 #line 2002 "ripper.y"
06775     {
06776 #if 0
06777                         value_expr((yyvsp[(5) - (5)].val));
06778                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06779                             (yyvsp[(4) - (5)].val) = 0;
06780                         }
06781                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06782                             (yyvsp[(4) - (5)].val) = 1;
06783                         }
06784                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06785                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06786 #endif
06787                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
06788                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06789 
06790                     ;}
06791     break;
06792 
06793   case 198:
06794 
06795 /* Line 1464 of yacc.c  */
06796 #line 2019 "ripper.y"
06797     {
06798 #if 0
06799                         value_expr((yyvsp[(5) - (5)].val));
06800                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06801                             (yyvsp[(4) - (5)].val) = 0;
06802                         }
06803                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06804                             (yyvsp[(4) - (5)].val) = 1;
06805                         }
06806                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06807                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06808 #endif
06809                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
06810                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06811 
06812                     ;}
06813     break;
06814 
06815   case 199:
06816 
06817 /* Line 1464 of yacc.c  */
06818 #line 2036 "ripper.y"
06819     {
06820 #if 0
06821                         yyerror("constant re-assignment");
06822                         (yyval.val) = NEW_BEGIN(0);
06823 #endif
06824                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06825                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06826                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06827 
06828                     ;}
06829     break;
06830 
06831   case 200:
06832 
06833 /* Line 1464 of yacc.c  */
06834 #line 2047 "ripper.y"
06835     {
06836 #if 0
06837                         yyerror("constant re-assignment");
06838                         (yyval.val) = NEW_BEGIN(0);
06839 #endif
06840                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
06841                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06842                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06843 
06844                     ;}
06845     break;
06846 
06847   case 201:
06848 
06849 /* Line 1464 of yacc.c  */
06850 #line 2058 "ripper.y"
06851     {
06852 #if 0
06853                         rb_backref_error((yyvsp[(1) - (3)].val));
06854                         (yyval.val) = NEW_BEGIN(0);
06855 #endif
06856                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
06857                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06858                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06859 
06860                     ;}
06861     break;
06862 
06863   case 202:
06864 
06865 /* Line 1464 of yacc.c  */
06866 #line 2069 "ripper.y"
06867     {
06868 #if 0
06869                         value_expr((yyvsp[(1) - (3)].val));
06870                         value_expr((yyvsp[(3) - (3)].val));
06871                         (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06872                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06873                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06874                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06875                         }
06876 #endif
06877                         (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06878 
06879                     ;}
06880     break;
06881 
06882   case 203:
06883 
06884 /* Line 1464 of yacc.c  */
06885 #line 2083 "ripper.y"
06886     {
06887 #if 0
06888                         value_expr((yyvsp[(1) - (3)].val));
06889                         value_expr((yyvsp[(3) - (3)].val));
06890                         (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06891                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06892                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06893                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06894                         }
06895 #endif
06896                         (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06897 
06898                     ;}
06899     break;
06900 
06901   case 204:
06902 
06903 /* Line 1464 of yacc.c  */
06904 #line 2097 "ripper.y"
06905     {
06906 #if 0
06907                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
06908 #endif
06909                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
06910 
06911                     ;}
06912     break;
06913 
06914   case 205:
06915 
06916 /* Line 1464 of yacc.c  */
06917 #line 2105 "ripper.y"
06918     {
06919 #if 0
06920                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
06921 #endif
06922                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
06923 
06924                     ;}
06925     break;
06926 
06927   case 206:
06928 
06929 /* Line 1464 of yacc.c  */
06930 #line 2113 "ripper.y"
06931     {
06932 #if 0
06933                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
06934 #endif
06935                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
06936 
06937                     ;}
06938     break;
06939 
06940   case 207:
06941 
06942 /* Line 1464 of yacc.c  */
06943 #line 2121 "ripper.y"
06944     {
06945 #if 0
06946                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
06947 #endif
06948                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
06949 
06950                     ;}
06951     break;
06952 
06953   case 208:
06954 
06955 /* Line 1464 of yacc.c  */
06956 #line 2129 "ripper.y"
06957     {
06958 #if 0
06959                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
06960 #endif
06961                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
06962 
06963                     ;}
06964     break;
06965 
06966   case 209:
06967 
06968 /* Line 1464 of yacc.c  */
06969 #line 2137 "ripper.y"
06970     {
06971 #if 0
06972                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
06973 #endif
06974                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
06975 
06976                     ;}
06977     break;
06978 
06979   case 210:
06980 
06981 /* Line 1464 of yacc.c  */
06982 #line 2145 "ripper.y"
06983     {
06984 #if 0
06985                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
06986 #endif
06987                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
06988                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
06989 
06990                     ;}
06991     break;
06992 
06993   case 211:
06994 
06995 /* Line 1464 of yacc.c  */
06996 #line 2154 "ripper.y"
06997     {
06998 #if 0
06999                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
07000 #endif
07001                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
07002                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
07003 
07004                     ;}
07005     break;
07006 
07007   case 212:
07008 
07009 /* Line 1464 of yacc.c  */
07010 #line 2163 "ripper.y"
07011     {
07012 #if 0
07013                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
07014 #endif
07015                         (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
07016 
07017                     ;}
07018     break;
07019 
07020   case 213:
07021 
07022 /* Line 1464 of yacc.c  */
07023 #line 2171 "ripper.y"
07024     {
07025 #if 0
07026                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
07027 #endif
07028                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
07029 
07030                     ;}
07031     break;
07032 
07033   case 214:
07034 
07035 /* Line 1464 of yacc.c  */
07036 #line 2179 "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 215:
07047 
07048 /* Line 1464 of yacc.c  */
07049 #line 2187 "ripper.y"
07050     {
07051 #if 0
07052                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
07053 #endif
07054                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
07055 
07056                     ;}
07057     break;
07058 
07059   case 216:
07060 
07061 /* Line 1464 of yacc.c  */
07062 #line 2195 "ripper.y"
07063     {
07064 #if 0
07065                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
07066 #endif
07067                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
07068 
07069                     ;}
07070     break;
07071 
07072   case 217:
07073 
07074 /* Line 1464 of yacc.c  */
07075 #line 2203 "ripper.y"
07076     {
07077 #if 0
07078                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
07079 #endif
07080                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
07081 
07082                     ;}
07083     break;
07084 
07085   case 218:
07086 
07087 /* Line 1464 of yacc.c  */
07088 #line 2211 "ripper.y"
07089     {
07090 #if 0
07091                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
07092 #endif
07093                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
07094 
07095                     ;}
07096     break;
07097 
07098   case 219:
07099 
07100 /* Line 1464 of yacc.c  */
07101 #line 2219 "ripper.y"
07102     {
07103 #if 0
07104                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
07105 #endif
07106                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
07107 
07108                     ;}
07109     break;
07110 
07111   case 220:
07112 
07113 /* Line 1464 of yacc.c  */
07114 #line 2227 "ripper.y"
07115     {
07116 #if 0
07117                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
07118 #endif
07119                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
07120 
07121                     ;}
07122     break;
07123 
07124   case 221:
07125 
07126 /* Line 1464 of yacc.c  */
07127 #line 2235 "ripper.y"
07128     {
07129 #if 0
07130                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
07131 #endif
07132                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
07133 
07134                     ;}
07135     break;
07136 
07137   case 222:
07138 
07139 /* Line 1464 of yacc.c  */
07140 #line 2243 "ripper.y"
07141     {
07142 #if 0
07143                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
07144 #endif
07145                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
07146 
07147                     ;}
07148     break;
07149 
07150   case 223:
07151 
07152 /* Line 1464 of yacc.c  */
07153 #line 2251 "ripper.y"
07154     {
07155 #if 0
07156                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
07157 #endif
07158                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
07159 
07160                     ;}
07161     break;
07162 
07163   case 224:
07164 
07165 /* Line 1464 of yacc.c  */
07166 #line 2259 "ripper.y"
07167     {
07168 #if 0
07169                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
07170 #endif
07171                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
07172 
07173                     ;}
07174     break;
07175 
07176   case 225:
07177 
07178 /* Line 1464 of yacc.c  */
07179 #line 2267 "ripper.y"
07180     {
07181 #if 0
07182                         (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07183                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && TYPE((yyvsp[(1) - (3)].val)->nd_lit) == T_REGEXP) {
07184                             (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
07185                         }
07186 #endif
07187                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
07188 
07189                     ;}
07190     break;
07191 
07192   case 226:
07193 
07194 /* Line 1464 of yacc.c  */
07195 #line 2278 "ripper.y"
07196     {
07197 #if 0
07198                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (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 227:
07206 
07207 /* Line 1464 of yacc.c  */
07208 #line 2286 "ripper.y"
07209     {
07210 #if 0
07211                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
07212 #endif
07213                         (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
07214 
07215                     ;}
07216     break;
07217 
07218   case 228:
07219 
07220 /* Line 1464 of yacc.c  */
07221 #line 2294 "ripper.y"
07222     {
07223 #if 0
07224                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
07225 #endif
07226                         (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
07227 
07228                     ;}
07229     break;
07230 
07231   case 229:
07232 
07233 /* Line 1464 of yacc.c  */
07234 #line 2302 "ripper.y"
07235     {
07236 #if 0
07237                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
07238 #endif
07239                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
07240 
07241                     ;}
07242     break;
07243 
07244   case 230:
07245 
07246 /* Line 1464 of yacc.c  */
07247 #line 2310 "ripper.y"
07248     {
07249 #if 0
07250                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
07251 #endif
07252                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
07253 
07254                     ;}
07255     break;
07256 
07257   case 231:
07258 
07259 /* Line 1464 of yacc.c  */
07260 #line 2318 "ripper.y"
07261     {
07262 #if 0
07263                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07264 #endif
07265                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
07266 
07267                     ;}
07268     break;
07269 
07270   case 232:
07271 
07272 /* Line 1464 of yacc.c  */
07273 #line 2326 "ripper.y"
07274     {
07275 #if 0
07276                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07277 #endif
07278                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
07279 
07280                     ;}
07281     break;
07282 
07283   case 233:
07284 
07285 /* Line 1464 of yacc.c  */
07286 #line 2333 "ripper.y"
07287     {in_defined = 1;;}
07288     break;
07289 
07290   case 234:
07291 
07292 /* Line 1464 of yacc.c  */
07293 #line 2334 "ripper.y"
07294     {
07295 #if 0
07296                         in_defined = 0;
07297                         (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
07298 #endif
07299                         in_defined = 0;
07300                         (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
07301 
07302                     ;}
07303     break;
07304 
07305   case 235:
07306 
07307 /* Line 1464 of yacc.c  */
07308 #line 2344 "ripper.y"
07309     {
07310 #if 0
07311                         value_expr((yyvsp[(1) - (6)].val));
07312                         (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07313                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07314 #endif
07315                         (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07316 
07317                     ;}
07318     break;
07319 
07320   case 236:
07321 
07322 /* Line 1464 of yacc.c  */
07323 #line 2354 "ripper.y"
07324     {
07325                         (yyval.val) = (yyvsp[(1) - (1)].val);
07326                     ;}
07327     break;
07328 
07329   case 237:
07330 
07331 /* Line 1464 of yacc.c  */
07332 #line 2360 "ripper.y"
07333     {
07334 #if 0
07335                         value_expr((yyvsp[(1) - (1)].val));
07336                         (yyval.val) = (yyvsp[(1) - (1)].val);
07337                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
07338 #endif
07339                         (yyval.val) = (yyvsp[(1) - (1)].val);
07340 
07341                     ;}
07342     break;
07343 
07344   case 239:
07345 
07346 /* Line 1464 of yacc.c  */
07347 #line 2373 "ripper.y"
07348     {
07349                         (yyval.val) = (yyvsp[(1) - (2)].val);
07350                     ;}
07351     break;
07352 
07353   case 240:
07354 
07355 /* Line 1464 of yacc.c  */
07356 #line 2377 "ripper.y"
07357     {
07358 #if 0
07359                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07360 #endif
07361                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07362 
07363                     ;}
07364     break;
07365 
07366   case 241:
07367 
07368 /* Line 1464 of yacc.c  */
07369 #line 2385 "ripper.y"
07370     {
07371 #if 0
07372                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07373 #endif
07374                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07375 
07376                     ;}
07377     break;
07378 
07379   case 242:
07380 
07381 /* Line 1464 of yacc.c  */
07382 #line 2395 "ripper.y"
07383     {
07384 #if 0
07385                         (yyval.val) = (yyvsp[(2) - (3)].val);
07386 #endif
07387                         (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
07388 
07389                     ;}
07390     break;
07391 
07392   case 247:
07393 
07394 /* Line 1464 of yacc.c  */
07395 #line 2413 "ripper.y"
07396     {
07397 #if 0
07398                         value_expr((yyvsp[(1) - (1)].val));
07399                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07400 #endif
07401                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07402 
07403                     ;}
07404     break;
07405 
07406   case 248:
07407 
07408 /* Line 1464 of yacc.c  */
07409 #line 2422 "ripper.y"
07410     {
07411 #if 0
07412                         (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07413 #endif
07414                         (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07415 
07416                     ;}
07417     break;
07418 
07419   case 249:
07420 
07421 /* Line 1464 of yacc.c  */
07422 #line 2430 "ripper.y"
07423     {
07424 #if 0
07425                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07426                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
07427 #endif
07428                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07429                         (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
07430 
07431                     ;}
07432     break;
07433 
07434   case 250:
07435 
07436 /* Line 1464 of yacc.c  */
07437 #line 2440 "ripper.y"
07438     {
07439 #if 0
07440                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07441                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
07442 #endif
07443                         (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
07444 
07445                     ;}
07446     break;
07447 
07448   case 251:
07449 
07450 /* Line 1464 of yacc.c  */
07451 #line 2451 "ripper.y"
07452     {
07453                         (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
07454                     ;}
07455     break;
07456 
07457   case 252:
07458 
07459 /* Line 1464 of yacc.c  */
07460 #line 2457 "ripper.y"
07461     {
07462                         (yyval.val) = cmdarg_stack;
07463                         CMDARG_PUSH(1);
07464                     ;}
07465     break;
07466 
07467   case 253:
07468 
07469 /* Line 1464 of yacc.c  */
07470 #line 2462 "ripper.y"
07471     {
07472                         /* CMDARG_POP() */
07473                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07474                         (yyval.val) = (yyvsp[(2) - (2)].val);
07475                     ;}
07476     break;
07477 
07478   case 254:
07479 
07480 /* Line 1464 of yacc.c  */
07481 #line 2470 "ripper.y"
07482     {
07483 #if 0
07484                         (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
07485 #endif
07486                         (yyval.val) = (yyvsp[(2) - (2)].val);
07487 
07488                     ;}
07489     break;
07490 
07491   case 255:
07492 
07493 /* Line 1464 of yacc.c  */
07494 #line 2480 "ripper.y"
07495     {
07496                         (yyval.val) = (yyvsp[(2) - (2)].val);
07497                     ;}
07498     break;
07499 
07500   case 256:
07501 
07502 /* Line 1464 of yacc.c  */
07503 #line 2484 "ripper.y"
07504     {
07505                         (yyval.val) = 0;
07506                     ;}
07507     break;
07508 
07509   case 257:
07510 
07511 /* Line 1464 of yacc.c  */
07512 #line 2488 "ripper.y"
07513     {
07514                         (yyval.val) = 0;
07515                     ;}
07516     break;
07517 
07518   case 258:
07519 
07520 /* Line 1464 of yacc.c  */
07521 #line 2494 "ripper.y"
07522     {
07523 #if 0
07524                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07525 #endif
07526                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07527 
07528                     ;}
07529     break;
07530 
07531   case 259:
07532 
07533 /* Line 1464 of yacc.c  */
07534 #line 2502 "ripper.y"
07535     {
07536 #if 0
07537                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07538 #endif
07539                         (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
07540 
07541                     ;}
07542     break;
07543 
07544   case 260:
07545 
07546 /* Line 1464 of yacc.c  */
07547 #line 2510 "ripper.y"
07548     {
07549 #if 0
07550                         NODE *n1;
07551                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07552                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07553                         }
07554                         else {
07555                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07556                         }
07557 #endif
07558                         (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07559 
07560                     ;}
07561     break;
07562 
07563   case 261:
07564 
07565 /* Line 1464 of yacc.c  */
07566 #line 2524 "ripper.y"
07567     {
07568 #if 0
07569                         NODE *n1;
07570                         if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07571                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07572                         }
07573                         else {
07574                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07575                         }
07576 #endif
07577                         (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07578 
07579                     ;}
07580     break;
07581 
07582   case 262:
07583 
07584 /* Line 1464 of yacc.c  */
07585 #line 2540 "ripper.y"
07586     {
07587 #if 0
07588                         NODE *n1;
07589                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07590                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07591                         }
07592                         else {
07593                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07594                         }
07595 #endif
07596                         (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
07597 
07598                     ;}
07599     break;
07600 
07601   case 263:
07602 
07603 /* Line 1464 of yacc.c  */
07604 #line 2554 "ripper.y"
07605     {
07606 #if 0
07607                         NODE *n1;
07608                         if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
07609                             (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07610                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07611                         }
07612                         else {
07613                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07614                         }
07615 #endif
07616                         (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
07617 
07618                     ;}
07619     break;
07620 
07621   case 264:
07622 
07623 /* Line 1464 of yacc.c  */
07624 #line 2569 "ripper.y"
07625     {
07626 #if 0
07627                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07628 #endif
07629                         (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
07630 
07631                     ;}
07632     break;
07633 
07634   case 273:
07635 
07636 /* Line 1464 of yacc.c  */
07637 #line 2587 "ripper.y"
07638     {
07639 #if 0
07640                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
07641 #endif
07642                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
07643 
07644                     ;}
07645     break;
07646 
07647   case 274:
07648 
07649 /* Line 1464 of yacc.c  */
07650 #line 2595 "ripper.y"
07651     {
07652 #if 0
07653                         (yyval.num) = ruby_sourceline;
07654 #endif
07655 
07656                     ;}
07657     break;
07658 
07659   case 275:
07660 
07661 /* Line 1464 of yacc.c  */
07662 #line 2603 "ripper.y"
07663     {
07664 #if 0
07665                         if ((yyvsp[(3) - (4)].val) == NULL) {
07666                             (yyval.val) = NEW_NIL();
07667                         }
07668                         else {
07669                             if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
07670                                 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
07671                                 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
07672                             (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
07673                         }
07674                         nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
07675 #endif
07676                         (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
07677 
07678                     ;}
07679     break;
07680 
07681   case 276:
07682 
07683 /* Line 1464 of yacc.c  */
07684 #line 2619 "ripper.y"
07685     {lex_state = EXPR_ENDARG;;}
07686     break;
07687 
07688   case 277:
07689 
07690 /* Line 1464 of yacc.c  */
07691 #line 2620 "ripper.y"
07692     {
07693                         rb_warning0("(...) interpreted as grouped expression");
07694 #if 0
07695                         (yyval.val) = (yyvsp[(2) - (4)].val);
07696 #endif
07697                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
07698 
07699                     ;}
07700     break;
07701 
07702   case 278:
07703 
07704 /* Line 1464 of yacc.c  */
07705 #line 2629 "ripper.y"
07706     {
07707 #if 0
07708                         (yyval.val) = (yyvsp[(2) - (3)].val);
07709 #endif
07710                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
07711 
07712                     ;}
07713     break;
07714 
07715   case 279:
07716 
07717 /* Line 1464 of yacc.c  */
07718 #line 2637 "ripper.y"
07719     {
07720 #if 0
07721                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07722 #endif
07723                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07724 
07725                     ;}
07726     break;
07727 
07728   case 280:
07729 
07730 /* Line 1464 of yacc.c  */
07731 #line 2645 "ripper.y"
07732     {
07733 #if 0
07734                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
07735 #endif
07736                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
07737 
07738                     ;}
07739     break;
07740 
07741   case 281:
07742 
07743 /* Line 1464 of yacc.c  */
07744 #line 2653 "ripper.y"
07745     {
07746 #if 0
07747                         if ((yyvsp[(2) - (3)].val) == 0) {
07748                             (yyval.val) = NEW_ZARRAY(); /* zero length array*/
07749                         }
07750                         else {
07751                             (yyval.val) = (yyvsp[(2) - (3)].val);
07752                         }
07753 #endif
07754                         (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
07755 
07756                     ;}
07757     break;
07758 
07759   case 282:
07760 
07761 /* Line 1464 of yacc.c  */
07762 #line 2666 "ripper.y"
07763     {
07764 #if 0
07765                         (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
07766 #endif
07767                         (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
07768 
07769                     ;}
07770     break;
07771 
07772   case 283:
07773 
07774 /* Line 1464 of yacc.c  */
07775 #line 2674 "ripper.y"
07776     {
07777 #if 0
07778                         (yyval.val) = NEW_RETURN(0);
07779 #endif
07780                         (yyval.val) = dispatch0(return0);
07781 
07782                     ;}
07783     break;
07784 
07785   case 284:
07786 
07787 /* Line 1464 of yacc.c  */
07788 #line 2682 "ripper.y"
07789     {
07790 #if 0
07791                         (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
07792 #endif
07793                         (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
07794 
07795                     ;}
07796     break;
07797 
07798   case 285:
07799 
07800 /* Line 1464 of yacc.c  */
07801 #line 2690 "ripper.y"
07802     {
07803 #if 0
07804                         (yyval.val) = NEW_YIELD(0, Qfalse);
07805 #endif
07806                         (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
07807 
07808                     ;}
07809     break;
07810 
07811   case 286:
07812 
07813 /* Line 1464 of yacc.c  */
07814 #line 2698 "ripper.y"
07815     {
07816 #if 0
07817                         (yyval.val) = NEW_YIELD(0, Qfalse);
07818 #endif
07819                         (yyval.val) = dispatch0(yield0);
07820 
07821                     ;}
07822     break;
07823 
07824   case 287:
07825 
07826 /* Line 1464 of yacc.c  */
07827 #line 2705 "ripper.y"
07828     {in_defined = 1;;}
07829     break;
07830 
07831   case 288:
07832 
07833 /* Line 1464 of yacc.c  */
07834 #line 2706 "ripper.y"
07835     {
07836 #if 0
07837                         in_defined = 0;
07838                         (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
07839 #endif
07840                         in_defined = 0;
07841                         (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
07842 
07843                     ;}
07844     break;
07845 
07846   case 289:
07847 
07848 /* Line 1464 of yacc.c  */
07849 #line 2716 "ripper.y"
07850     {
07851 #if 0
07852                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
07853 #endif
07854                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
07855 
07856                     ;}
07857     break;
07858 
07859   case 290:
07860 
07861 /* Line 1464 of yacc.c  */
07862 #line 2724 "ripper.y"
07863     {
07864 #if 0
07865                         (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
07866 #endif
07867                         (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
07868 
07869                     ;}
07870     break;
07871 
07872   case 291:
07873 
07874 /* Line 1464 of yacc.c  */
07875 #line 2732 "ripper.y"
07876     {
07877 #if 0
07878                         (yyvsp[(2) - (2)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].val), 0);
07879                         (yyval.val) = (yyvsp[(2) - (2)].val);
07880                         fixpos((yyvsp[(2) - (2)].val)->nd_iter, (yyvsp[(2) - (2)].val));
07881 #endif
07882                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
07883                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
07884 
07885                     ;}
07886     break;
07887 
07888   case 293:
07889 
07890 /* Line 1464 of yacc.c  */
07891 #line 2744 "ripper.y"
07892     {
07893 #if 0
07894                         block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
07895                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
07896                         (yyval.val) = (yyvsp[(2) - (2)].val);
07897                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
07898 #endif
07899                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07900 
07901                     ;}
07902     break;
07903 
07904   case 294:
07905 
07906 /* Line 1464 of yacc.c  */
07907 #line 2755 "ripper.y"
07908     {
07909                         (yyval.val) = (yyvsp[(2) - (2)].val);
07910                     ;}
07911     break;
07912 
07913   case 295:
07914 
07915 /* Line 1464 of yacc.c  */
07916 #line 2762 "ripper.y"
07917     {
07918 #if 0
07919                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07920                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07921 #endif
07922                         (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07923 
07924                     ;}
07925     break;
07926 
07927   case 296:
07928 
07929 /* Line 1464 of yacc.c  */
07930 #line 2774 "ripper.y"
07931     {
07932 #if 0
07933                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07934                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07935 #endif
07936                         (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07937 
07938                     ;}
07939     break;
07940 
07941   case 297:
07942 
07943 /* Line 1464 of yacc.c  */
07944 #line 2782 "ripper.y"
07945     {COND_PUSH(1);;}
07946     break;
07947 
07948   case 298:
07949 
07950 /* Line 1464 of yacc.c  */
07951 #line 2782 "ripper.y"
07952     {COND_POP();;}
07953     break;
07954 
07955   case 299:
07956 
07957 /* Line 1464 of yacc.c  */
07958 #line 2785 "ripper.y"
07959     {
07960 #if 0
07961                         (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07962                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07963 #endif
07964                         (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07965 
07966                     ;}
07967     break;
07968 
07969   case 300:
07970 
07971 /* Line 1464 of yacc.c  */
07972 #line 2793 "ripper.y"
07973     {COND_PUSH(1);;}
07974     break;
07975 
07976   case 301:
07977 
07978 /* Line 1464 of yacc.c  */
07979 #line 2793 "ripper.y"
07980     {COND_POP();;}
07981     break;
07982 
07983   case 302:
07984 
07985 /* Line 1464 of yacc.c  */
07986 #line 2796 "ripper.y"
07987     {
07988 #if 0
07989                         (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07990                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07991 #endif
07992                         (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07993 
07994                     ;}
07995     break;
07996 
07997   case 303:
07998 
07999 /* Line 1464 of yacc.c  */
08000 #line 2807 "ripper.y"
08001     {
08002 #if 0
08003                         (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08004                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08005 #endif
08006                         (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08007 
08008                     ;}
08009     break;
08010 
08011   case 304:
08012 
08013 /* Line 1464 of yacc.c  */
08014 #line 2816 "ripper.y"
08015     {
08016 #if 0
08017                         (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
08018 #endif
08019                         (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
08020 
08021                     ;}
08022     break;
08023 
08024   case 305:
08025 
08026 /* Line 1464 of yacc.c  */
08027 #line 2824 "ripper.y"
08028     {COND_PUSH(1);;}
08029     break;
08030 
08031   case 306:
08032 
08033 /* Line 1464 of yacc.c  */
08034 #line 2826 "ripper.y"
08035     {COND_POP();;}
08036     break;
08037 
08038   case 307:
08039 
08040 /* Line 1464 of yacc.c  */
08041 #line 2829 "ripper.y"
08042     {
08043 #if 0
08044                         /*
08045                          *  for a, b, c in e
08046                          *  #=>
08047                          *  e.each{|*x| a, b, c = x
08048                          *
08049                          *  for a in e
08050                          *  #=>
08051                          *  e.each{|x| a, = x}
08052                          */
08053                         ID id = internal_id();
08054                         ID *tbl = ALLOC_N(ID, 2);
08055                         NODE *m = NEW_ARGS_AUX(0, 0);
08056                         NODE *args, *scope;
08057 
08058                         if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
08059                             /* if args.length == 1 && args[0].kind_of?(Array)
08060                              *   args = args[0]
08061                              * end
08062                              */
08063                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
08064                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
08065                             m->nd_next = block_append(
08066                                 NEW_IF(
08067                                     NEW_NODE(NODE_AND,
08068                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
08069                                                       rb_intern("=="), one),
08070                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
08071                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
08072                                              0),
08073                                     NEW_DASGN_CURR(id,
08074                                                    NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
08075                                     0),
08076                                 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
08077 
08078                             args = new_args(m, 0, id, 0, 0);
08079                         }
08080                         else {
08081                             if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
08082                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
08083                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
08084                                 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
08085                                 m->nd_plen = 1;
08086                                 m->nd_next = (yyvsp[(2) - (9)].val);
08087                                 args = new_args(m, 0, 0, 0, 0);
08088                             }
08089                             else {
08090                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
08091                                 args = new_args(m, 0, id, 0, 0);
08092                             }
08093                         }
08094                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
08095                         tbl[0] = 1; tbl[1] = id;
08096                         (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
08097                         fixpos((yyval.val), (yyvsp[(2) - (9)].val));
08098 #endif
08099                         (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
08100 
08101                     ;}
08102     break;
08103 
08104   case 308:
08105 
08106 /* Line 1464 of yacc.c  */
08107 #line 2890 "ripper.y"
08108     {
08109                         if (in_def || in_single)
08110                             yyerror("class definition in method body");
08111                         local_push(0);
08112 #if 0
08113                         (yyval.num) = ruby_sourceline;
08114 #endif
08115 
08116                     ;}
08117     break;
08118 
08119   case 309:
08120 
08121 /* Line 1464 of yacc.c  */
08122 #line 2901 "ripper.y"
08123     {
08124 #if 0
08125                         (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
08126                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
08127 #endif
08128                         (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
08129 
08130                         local_pop();
08131                     ;}
08132     break;
08133 
08134   case 310:
08135 
08136 /* Line 1464 of yacc.c  */
08137 #line 2911 "ripper.y"
08138     {
08139                         (yyval.num) = in_def;
08140                         in_def = 0;
08141                     ;}
08142     break;
08143 
08144   case 311:
08145 
08146 /* Line 1464 of yacc.c  */
08147 #line 2916 "ripper.y"
08148     {
08149                         (yyval.num) = in_single;
08150                         in_single = 0;
08151                         local_push(0);
08152                     ;}
08153     break;
08154 
08155   case 312:
08156 
08157 /* Line 1464 of yacc.c  */
08158 #line 2923 "ripper.y"
08159     {
08160 #if 0
08161                         (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08162                         fixpos((yyval.val), (yyvsp[(3) - (8)].val));
08163 #endif
08164                         (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08165 
08166                         local_pop();
08167                         in_def = (yyvsp[(4) - (8)].num);
08168                         in_single = (yyvsp[(6) - (8)].num);
08169                     ;}
08170     break;
08171 
08172   case 313:
08173 
08174 /* Line 1464 of yacc.c  */
08175 #line 2935 "ripper.y"
08176     {
08177                         if (in_def || in_single)
08178                             yyerror("module definition in method body");
08179                         local_push(0);
08180 #if 0
08181                         (yyval.num) = ruby_sourceline;
08182 #endif
08183 
08184                     ;}
08185     break;
08186 
08187   case 314:
08188 
08189 /* Line 1464 of yacc.c  */
08190 #line 2946 "ripper.y"
08191     {
08192 #if 0
08193                         (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08194                         nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
08195 #endif
08196                         (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08197 
08198                         local_pop();
08199                     ;}
08200     break;
08201 
08202   case 315:
08203 
08204 /* Line 1464 of yacc.c  */
08205 #line 2956 "ripper.y"
08206     {
08207                         (yyval.id) = cur_mid;
08208                         cur_mid = (yyvsp[(2) - (2)].val);
08209                         in_def++;
08210                         local_push(0);
08211                     ;}
08212     break;
08213 
08214   case 316:
08215 
08216 /* Line 1464 of yacc.c  */
08217 #line 2965 "ripper.y"
08218     {
08219 #if 0
08220                         NODE *body = remove_begin((yyvsp[(5) - (6)].val));
08221                         reduce_nodes(&body);
08222                         (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
08223                         nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
08224 #endif
08225                         (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08226 
08227                         local_pop();
08228                         in_def--;
08229                         cur_mid = (yyvsp[(3) - (6)].id);
08230                     ;}
08231     break;
08232 
08233   case 317:
08234 
08235 /* Line 1464 of yacc.c  */
08236 #line 2978 "ripper.y"
08237     {lex_state = EXPR_FNAME;;}
08238     break;
08239 
08240   case 318:
08241 
08242 /* Line 1464 of yacc.c  */
08243 #line 2979 "ripper.y"
08244     {
08245                         in_single++;
08246                         lex_state = EXPR_ENDFN; /* force for args */
08247                         local_push(0);
08248                     ;}
08249     break;
08250 
08251   case 319:
08252 
08253 /* Line 1464 of yacc.c  */
08254 #line 2987 "ripper.y"
08255     {
08256 #if 0
08257                         NODE *body = remove_begin((yyvsp[(8) - (9)].val));
08258                         reduce_nodes(&body);
08259                         (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
08260                         nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
08261 #endif
08262                         (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
08263 
08264                         local_pop();
08265                         in_single--;
08266                     ;}
08267     break;
08268 
08269   case 320:
08270 
08271 /* Line 1464 of yacc.c  */
08272 #line 3000 "ripper.y"
08273     {
08274 #if 0
08275                         (yyval.val) = NEW_BREAK(0);
08276 #endif
08277                         (yyval.val) = dispatch1(break, arg_new());
08278 
08279                     ;}
08280     break;
08281 
08282   case 321:
08283 
08284 /* Line 1464 of yacc.c  */
08285 #line 3008 "ripper.y"
08286     {
08287 #if 0
08288                         (yyval.val) = NEW_NEXT(0);
08289 #endif
08290                         (yyval.val) = dispatch1(next, arg_new());
08291 
08292                     ;}
08293     break;
08294 
08295   case 322:
08296 
08297 /* Line 1464 of yacc.c  */
08298 #line 3016 "ripper.y"
08299     {
08300 #if 0
08301                         (yyval.val) = NEW_REDO();
08302 #endif
08303                         (yyval.val) = dispatch0(redo);
08304 
08305                     ;}
08306     break;
08307 
08308   case 323:
08309 
08310 /* Line 1464 of yacc.c  */
08311 #line 3024 "ripper.y"
08312     {
08313 #if 0
08314                         (yyval.val) = NEW_RETRY();
08315 #endif
08316                         (yyval.val) = dispatch0(retry);
08317 
08318                     ;}
08319     break;
08320 
08321   case 324:
08322 
08323 /* Line 1464 of yacc.c  */
08324 #line 3034 "ripper.y"
08325     {
08326 #if 0
08327                         value_expr((yyvsp[(1) - (1)].val));
08328                         (yyval.val) = (yyvsp[(1) - (1)].val);
08329                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
08330 #endif
08331                         (yyval.val) = (yyvsp[(1) - (1)].val);
08332 
08333                     ;}
08334     break;
08335 
08336   case 325:
08337 
08338 /* Line 1464 of yacc.c  */
08339 #line 3046 "ripper.y"
08340     {
08341                         token_info_push("begin");
08342                     ;}
08343     break;
08344 
08345   case 326:
08346 
08347 /* Line 1464 of yacc.c  */
08348 #line 3052 "ripper.y"
08349     {
08350                         token_info_push("if");
08351                     ;}
08352     break;
08353 
08354   case 327:
08355 
08356 /* Line 1464 of yacc.c  */
08357 #line 3058 "ripper.y"
08358     {
08359                         token_info_push("unless");
08360                     ;}
08361     break;
08362 
08363   case 328:
08364 
08365 /* Line 1464 of yacc.c  */
08366 #line 3064 "ripper.y"
08367     {
08368                         token_info_push("while");
08369                     ;}
08370     break;
08371 
08372   case 329:
08373 
08374 /* Line 1464 of yacc.c  */
08375 #line 3070 "ripper.y"
08376     {
08377                         token_info_push("until");
08378                     ;}
08379     break;
08380 
08381   case 330:
08382 
08383 /* Line 1464 of yacc.c  */
08384 #line 3076 "ripper.y"
08385     {
08386                         token_info_push("case");
08387                     ;}
08388     break;
08389 
08390   case 331:
08391 
08392 /* Line 1464 of yacc.c  */
08393 #line 3082 "ripper.y"
08394     {
08395                         token_info_push("for");
08396                     ;}
08397     break;
08398 
08399   case 332:
08400 
08401 /* Line 1464 of yacc.c  */
08402 #line 3088 "ripper.y"
08403     {
08404                         token_info_push("class");
08405                     ;}
08406     break;
08407 
08408   case 333:
08409 
08410 /* Line 1464 of yacc.c  */
08411 #line 3094 "ripper.y"
08412     {
08413                         token_info_push("module");
08414                     ;}
08415     break;
08416 
08417   case 334:
08418 
08419 /* Line 1464 of yacc.c  */
08420 #line 3100 "ripper.y"
08421     {
08422                         token_info_push("def");
08423 #if 0
08424                         (yyval.num) = ruby_sourceline;
08425 #endif
08426 
08427                     ;}
08428     break;
08429 
08430   case 335:
08431 
08432 /* Line 1464 of yacc.c  */
08433 #line 3110 "ripper.y"
08434     {
08435                         token_info_pop("end");
08436                     ;}
08437     break;
08438 
08439   case 336:
08440 
08441 /* Line 1464 of yacc.c  */
08442 #line 3118 "ripper.y"
08443     { (yyval.val) = Qnil; ;}
08444     break;
08445 
08446   case 338:
08447 
08448 /* Line 1464 of yacc.c  */
08449 #line 3124 "ripper.y"
08450     { (yyval.val) = (yyvsp[(2) - (2)].val); ;}
08451     break;
08452 
08453   case 339:
08454 
08455 /* Line 1464 of yacc.c  */
08456 #line 3131 "ripper.y"
08457     { (yyval.val) = Qnil; ;}
08458     break;
08459 
08460   case 342:
08461 
08462 /* Line 1464 of yacc.c  */
08463 #line 3140 "ripper.y"
08464     {
08465 #if 0
08466                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08467                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08468 #endif
08469                         (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08470 
08471                     ;}
08472     break;
08473 
08474   case 344:
08475 
08476 /* Line 1464 of yacc.c  */
08477 #line 3152 "ripper.y"
08478     {
08479 #if 0
08480                         (yyval.val) = (yyvsp[(2) - (2)].val);
08481 #endif
08482                         (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
08483 
08484                     ;}
08485     break;
08486 
08487   case 347:
08488 
08489 /* Line 1464 of yacc.c  */
08490 #line 3166 "ripper.y"
08491     {
08492                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
08493 #if 0
08494 #endif
08495                         (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
08496 
08497                     ;}
08498     break;
08499 
08500   case 348:
08501 
08502 /* Line 1464 of yacc.c  */
08503 #line 3174 "ripper.y"
08504     {
08505 #if 0
08506                         (yyval.val) = (yyvsp[(2) - (3)].val);
08507 #endif
08508                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
08509 
08510                     ;}
08511     break;
08512 
08513   case 349:
08514 
08515 /* Line 1464 of yacc.c  */
08516 #line 3184 "ripper.y"
08517     {
08518 #if 0
08519                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
08520 #endif
08521                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
08522 
08523                     ;}
08524     break;
08525 
08526   case 350:
08527 
08528 /* Line 1464 of yacc.c  */
08529 #line 3192 "ripper.y"
08530     {
08531 #if 0
08532                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08533 #endif
08534                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08535 
08536                     ;}
08537     break;
08538 
08539   case 351:
08540 
08541 /* Line 1464 of yacc.c  */
08542 #line 3202 "ripper.y"
08543     {
08544 #if 0
08545                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
08546 #endif
08547                         (yyval.val) = (yyvsp[(1) - (1)].val);
08548 
08549                     ;}
08550     break;
08551 
08552   case 352:
08553 
08554 /* Line 1464 of yacc.c  */
08555 #line 3210 "ripper.y"
08556     {
08557                         (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
08558 #if 0
08559                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
08560 #endif
08561                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
08562 
08563                     ;}
08564     break;
08565 
08566   case 353:
08567 
08568 /* Line 1464 of yacc.c  */
08569 #line 3219 "ripper.y"
08570     {
08571                         (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
08572 #if 0
08573                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
08574 #endif
08575                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
08576 
08577                     ;}
08578     break;
08579 
08580   case 354:
08581 
08582 /* Line 1464 of yacc.c  */
08583 #line 3228 "ripper.y"
08584     {
08585 #if 0
08586                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
08587 #endif
08588                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
08589 
08590                     ;}
08591     break;
08592 
08593   case 355:
08594 
08595 /* Line 1464 of yacc.c  */
08596 #line 3236 "ripper.y"
08597     {
08598 #if 0
08599                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
08600 #endif
08601                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
08602 
08603                     ;}
08604     break;
08605 
08606   case 356:
08607 
08608 /* Line 1464 of yacc.c  */
08609 #line 3244 "ripper.y"
08610     {
08611                         (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
08612 #if 0
08613                         (yyval.val) = NEW_MASGN(0, (yyval.val));
08614 #endif
08615                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
08616 
08617                     ;}
08618     break;
08619 
08620   case 357:
08621 
08622 /* Line 1464 of yacc.c  */
08623 #line 3253 "ripper.y"
08624     {
08625                         (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
08626 #if 0
08627                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
08628 #endif
08629                       #if 0
08630                       TODO: Check me
08631                       #endif
08632                         (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
08633 
08634                     ;}
08635     break;
08636 
08637   case 358:
08638 
08639 /* Line 1464 of yacc.c  */
08640 #line 3265 "ripper.y"
08641     {
08642 #if 0
08643                         (yyval.val) = NEW_MASGN(0, -1);
08644 #endif
08645                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08646 
08647                     ;}
08648     break;
08649 
08650   case 359:
08651 
08652 /* Line 1464 of yacc.c  */
08653 #line 3273 "ripper.y"
08654     {
08655 #if 0
08656                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
08657 #endif
08658                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08659 
08660                     ;}
08661     break;
08662 
08663   case 360:
08664 
08665 /* Line 1464 of yacc.c  */
08666 #line 3283 "ripper.y"
08667     {
08668 #if 0
08669                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
08670 #endif
08671                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
08672 
08673                     ;}
08674     break;
08675 
08676   case 361:
08677 
08678 /* Line 1464 of yacc.c  */
08679 #line 3291 "ripper.y"
08680     {
08681 #if 0
08682                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
08683 #endif
08684                         (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)));
08685 
08686                     ;}
08687     break;
08688 
08689   case 362:
08690 
08691 /* Line 1464 of yacc.c  */
08692 #line 3299 "ripper.y"
08693     {
08694 #if 0
08695                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
08696 #endif
08697                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08698 
08699                     ;}
08700     break;
08701 
08702   case 363:
08703 
08704 /* Line 1464 of yacc.c  */
08705 #line 3307 "ripper.y"
08706     {
08707 #if 0
08708                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08709 #endif
08710                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08711 
08712                     ;}
08713     break;
08714 
08715   case 364:
08716 
08717 /* Line 1464 of yacc.c  */
08718 #line 3315 "ripper.y"
08719     {
08720 #if 0
08721                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
08722 #endif
08723                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08724 
08725                     ;}
08726     break;
08727 
08728   case 365:
08729 
08730 /* Line 1464 of yacc.c  */
08731 #line 3323 "ripper.y"
08732     {
08733 #if 0
08734                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 1, 0, 0);
08735 #endif
08736                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil, Qnil);
08737                         dispatch1(excessed_comma, (yyval.val));
08738 
08739                     ;}
08740     break;
08741 
08742   case 366:
08743 
08744 /* Line 1464 of yacc.c  */
08745 #line 3332 "ripper.y"
08746     {
08747 #if 0
08748                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08749 #endif
08750                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08751 
08752                     ;}
08753     break;
08754 
08755   case 367:
08756 
08757 /* Line 1464 of yacc.c  */
08758 #line 3340 "ripper.y"
08759     {
08760 #if 0
08761                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
08762 #endif
08763                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil,Qnil, Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
08764 
08765                     ;}
08766     break;
08767 
08768   case 368:
08769 
08770 /* Line 1464 of yacc.c  */
08771 #line 3348 "ripper.y"
08772     {
08773 #if 0
08774                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
08775 #endif
08776                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08777 
08778                     ;}
08779     break;
08780 
08781   case 369:
08782 
08783 /* Line 1464 of yacc.c  */
08784 #line 3356 "ripper.y"
08785     {
08786 #if 0
08787                         (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08788 #endif
08789                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08790 
08791                     ;}
08792     break;
08793 
08794   case 370:
08795 
08796 /* Line 1464 of yacc.c  */
08797 #line 3364 "ripper.y"
08798     {
08799 #if 0
08800                         (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
08801 #endif
08802                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
08803 
08804                     ;}
08805     break;
08806 
08807   case 371:
08808 
08809 /* Line 1464 of yacc.c  */
08810 #line 3372 "ripper.y"
08811     {
08812 #if 0
08813                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08814 #endif
08815                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
08816 
08817                     ;}
08818     break;
08819 
08820   case 372:
08821 
08822 /* Line 1464 of yacc.c  */
08823 #line 3380 "ripper.y"
08824     {
08825 #if 0
08826                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
08827 #endif
08828                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
08829 
08830                     ;}
08831     break;
08832 
08833   case 373:
08834 
08835 /* Line 1464 of yacc.c  */
08836 #line 3388 "ripper.y"
08837     {
08838 #if 0
08839                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08840 #endif
08841                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
08842 
08843                     ;}
08844     break;
08845 
08846   case 374:
08847 
08848 /* Line 1464 of yacc.c  */
08849 #line 3396 "ripper.y"
08850     {
08851 #if 0
08852                         (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
08853 #endif
08854                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
08855 
08856                     ;}
08857     break;
08858 
08859   case 376:
08860 
08861 /* Line 1464 of yacc.c  */
08862 #line 3407 "ripper.y"
08863     {
08864                         command_start = TRUE;
08865                     ;}
08866     break;
08867 
08868   case 377:
08869 
08870 /* Line 1464 of yacc.c  */
08871 #line 3413 "ripper.y"
08872     {
08873 #if 0
08874                         (yyval.val) = 0;
08875 #endif
08876                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
08877                                           escape_Qundef((yyvsp[(2) - (3)].val)));
08878 
08879                     ;}
08880     break;
08881 
08882   case 378:
08883 
08884 /* Line 1464 of yacc.c  */
08885 #line 3422 "ripper.y"
08886     {
08887 #if 0
08888                         (yyval.val) = 0;
08889 #endif
08890                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
08891                                           Qnil);
08892 
08893                     ;}
08894     break;
08895 
08896   case 379:
08897 
08898 /* Line 1464 of yacc.c  */
08899 #line 3431 "ripper.y"
08900     {
08901 #if 0
08902                         (yyval.val) = (yyvsp[(2) - (4)].val);
08903 #endif
08904                         (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
08905 
08906                     ;}
08907     break;
08908 
08909   case 381:
08910 
08911 /* Line 1464 of yacc.c  */
08912 #line 3443 "ripper.y"
08913     {
08914 #if 0
08915                         (yyval.val) = 0;
08916 #endif
08917                         (yyval.val) = (yyvsp[(2) - (2)].val);
08918 
08919                     ;}
08920     break;
08921 
08922   case 382:
08923 
08924 /* Line 1464 of yacc.c  */
08925 #line 3455 "ripper.y"
08926     {
08927                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
08928                     ;}
08929     break;
08930 
08931   case 383:
08932 
08933 /* Line 1464 of yacc.c  */
08934 #line 3462 "ripper.y"
08935     {
08936                         rb_ary_push((yyval.val), (yyvsp[(3) - (3)].val));
08937                     ;}
08938     break;
08939 
08940   case 384:
08941 
08942 /* Line 1464 of yacc.c  */
08943 #line 3469 "ripper.y"
08944     {
08945                         new_bv(get_id((yyvsp[(1) - (1)].val)));
08946 #if 0
08947 #endif
08948                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
08949 
08950                     ;}
08951     break;
08952 
08953   case 385:
08954 
08955 /* Line 1464 of yacc.c  */
08956 #line 3477 "ripper.y"
08957     {
08958                         (yyval.val) = 0;
08959                     ;}
08960     break;
08961 
08962   case 386:
08963 
08964 /* Line 1464 of yacc.c  */
08965 #line 3482 "ripper.y"
08966     {
08967                         (yyval.vars) = dyna_push();
08968                     ;}
08969     break;
08970 
08971   case 387:
08972 
08973 /* Line 1464 of yacc.c  */
08974 #line 3485 "ripper.y"
08975     {
08976                         (yyval.num) = lpar_beg;
08977                         lpar_beg = ++paren_nest;
08978                     ;}
08979     break;
08980 
08981   case 388:
08982 
08983 /* Line 1464 of yacc.c  */
08984 #line 3491 "ripper.y"
08985     {
08986                         lpar_beg = (yyvsp[(2) - (4)].num);
08987 #if 0
08988                         (yyval.val) = (yyvsp[(3) - (4)].val);
08989                         (yyval.val)->nd_body = NEW_SCOPE((yyvsp[(3) - (4)].val)->nd_head, (yyvsp[(4) - (4)].val));
08990 #endif
08991                         (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08992 
08993                         dyna_pop((yyvsp[(1) - (4)].vars));
08994                     ;}
08995     break;
08996 
08997   case 389:
08998 
08999 /* Line 1464 of yacc.c  */
09000 #line 3504 "ripper.y"
09001     {
09002 #if 0
09003                         (yyval.val) = NEW_LAMBDA((yyvsp[(2) - (4)].val));
09004 #endif
09005                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
09006 
09007                     ;}
09008     break;
09009 
09010   case 390:
09011 
09012 /* Line 1464 of yacc.c  */
09013 #line 3512 "ripper.y"
09014     {
09015 #if 0
09016                         (yyval.val) = NEW_LAMBDA((yyvsp[(1) - (1)].val));
09017 #endif
09018                         (yyval.val) = (yyvsp[(1) - (1)].val);
09019 
09020                     ;}
09021     break;
09022 
09023   case 391:
09024 
09025 /* Line 1464 of yacc.c  */
09026 #line 3522 "ripper.y"
09027     {
09028                         (yyval.val) = (yyvsp[(2) - (3)].val);
09029                     ;}
09030     break;
09031 
09032   case 392:
09033 
09034 /* Line 1464 of yacc.c  */
09035 #line 3526 "ripper.y"
09036     {
09037                         (yyval.val) = (yyvsp[(2) - (3)].val);
09038                     ;}
09039     break;
09040 
09041   case 393:
09042 
09043 /* Line 1464 of yacc.c  */
09044 #line 3532 "ripper.y"
09045     {
09046                         (yyvsp[(1) - (1)].vars) = dyna_push();
09047 #if 0
09048                         (yyval.num) = ruby_sourceline;
09049 #endif
09050                     ;}
09051     break;
09052 
09053   case 394:
09054 
09055 /* Line 1464 of yacc.c  */
09056 #line 3541 "ripper.y"
09057     {
09058 #if 0
09059                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09060                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09061 #endif
09062                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09063 
09064                         dyna_pop((yyvsp[(1) - (5)].vars));
09065                     ;}
09066     break;
09067 
09068   case 395:
09069 
09070 /* Line 1464 of yacc.c  */
09071 #line 3553 "ripper.y"
09072     {
09073 #if 0
09074                         if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
09075                             compile_error(PARSER_ARG "block given to yield");
09076                         }
09077                         else {
09078                             block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
09079                         }
09080                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
09081                         (yyval.val) = (yyvsp[(2) - (2)].val);
09082                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
09083 #endif
09084                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09085 
09086                     ;}
09087     break;
09088 
09089   case 396:
09090 
09091 /* Line 1464 of yacc.c  */
09092 #line 3569 "ripper.y"
09093     {
09094 #if 0
09095                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09096 #endif
09097                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
09098                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09099 
09100                     ;}
09101     break;
09102 
09103   case 397:
09104 
09105 /* Line 1464 of yacc.c  */
09106 #line 3578 "ripper.y"
09107     {
09108 #if 0
09109                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09110 #endif
09111                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
09112                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09113 
09114                     ;}
09115     break;
09116 
09117   case 398:
09118 
09119 /* Line 1464 of yacc.c  */
09120 #line 3589 "ripper.y"
09121     {
09122 #if 0
09123                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09124                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
09125 #endif
09126                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
09127 
09128                     ;}
09129     break;
09130 
09131   case 399:
09132 
09133 /* Line 1464 of yacc.c  */
09134 #line 3598 "ripper.y"
09135     {
09136 #if 0
09137                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09138                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09139 #endif
09140                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
09141                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09142 
09143                     ;}
09144     break;
09145 
09146   case 400:
09147 
09148 /* Line 1464 of yacc.c  */
09149 #line 3608 "ripper.y"
09150     {
09151 #if 0
09152                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09153                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09154 #endif
09155                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
09156                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09157 
09158                     ;}
09159     break;
09160 
09161   case 401:
09162 
09163 /* Line 1464 of yacc.c  */
09164 #line 3618 "ripper.y"
09165     {
09166 #if 0
09167                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
09168 #endif
09169                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
09170 
09171                     ;}
09172     break;
09173 
09174   case 402:
09175 
09176 /* Line 1464 of yacc.c  */
09177 #line 3626 "ripper.y"
09178     {
09179 #if 0
09180                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
09181                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
09182 #endif
09183                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_id2sym('.'),
09184                                        ripper_intern("call"));
09185                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
09186 
09187                     ;}
09188     break;
09189 
09190   case 403:
09191 
09192 /* Line 1464 of yacc.c  */
09193 #line 3637 "ripper.y"
09194     {
09195 #if 0
09196                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
09197                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
09198 #endif
09199                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"),
09200                                        ripper_intern("call"));
09201                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
09202 
09203                     ;}
09204     break;
09205 
09206   case 404:
09207 
09208 /* Line 1464 of yacc.c  */
09209 #line 3648 "ripper.y"
09210     {
09211 #if 0
09212                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
09213 #endif
09214                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
09215 
09216                     ;}
09217     break;
09218 
09219   case 405:
09220 
09221 /* Line 1464 of yacc.c  */
09222 #line 3656 "ripper.y"
09223     {
09224 #if 0
09225                         (yyval.val) = NEW_ZSUPER();
09226 #endif
09227                         (yyval.val) = dispatch0(zsuper);
09228 
09229                     ;}
09230     break;
09231 
09232   case 406:
09233 
09234 /* Line 1464 of yacc.c  */
09235 #line 3664 "ripper.y"
09236     {
09237 #if 0
09238                         if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
09239                             (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
09240                         else
09241                             (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
09242                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09243 #endif
09244                         (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
09245 
09246                     ;}
09247     break;
09248 
09249   case 407:
09250 
09251 /* Line 1464 of yacc.c  */
09252 #line 3678 "ripper.y"
09253     {
09254                         (yyvsp[(1) - (1)].vars) = dyna_push();
09255 #if 0
09256                         (yyval.num) = ruby_sourceline;
09257 #endif
09258 
09259                     ;}
09260     break;
09261 
09262   case 408:
09263 
09264 /* Line 1464 of yacc.c  */
09265 #line 3687 "ripper.y"
09266     {
09267 #if 0
09268                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09269                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09270 #endif
09271                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09272 
09273                         dyna_pop((yyvsp[(1) - (5)].vars));
09274                     ;}
09275     break;
09276 
09277   case 409:
09278 
09279 /* Line 1464 of yacc.c  */
09280 #line 3697 "ripper.y"
09281     {
09282                         (yyvsp[(1) - (1)].vars) = dyna_push();
09283 #if 0
09284                         (yyval.num) = ruby_sourceline;
09285 #endif
09286 
09287                     ;}
09288     break;
09289 
09290   case 410:
09291 
09292 /* Line 1464 of yacc.c  */
09293 #line 3706 "ripper.y"
09294     {
09295 #if 0
09296                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09297                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09298 #endif
09299                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09300 
09301                         dyna_pop((yyvsp[(1) - (5)].vars));
09302                     ;}
09303     break;
09304 
09305   case 411:
09306 
09307 /* Line 1464 of yacc.c  */
09308 #line 3720 "ripper.y"
09309     {
09310 #if 0
09311                         (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09312 #endif
09313                         (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
09314 
09315                     ;}
09316     break;
09317 
09318   case 414:
09319 
09320 /* Line 1464 of yacc.c  */
09321 #line 3736 "ripper.y"
09322     {
09323 #if 0
09324                         if ((yyvsp[(3) - (6)].val)) {
09325                             (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
09326                             (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
09327                         }
09328                         (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09329                         fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
09330 #endif
09331                         (yyval.val) = dispatch4(rescue,
09332                                        escape_Qundef((yyvsp[(2) - (6)].val)),
09333                                        escape_Qundef((yyvsp[(3) - (6)].val)),
09334                                        escape_Qundef((yyvsp[(5) - (6)].val)),
09335                                        escape_Qundef((yyvsp[(6) - (6)].val)));
09336 
09337                     ;}
09338     break;
09339 
09340   case 416:
09341 
09342 /* Line 1464 of yacc.c  */
09343 #line 3756 "ripper.y"
09344     {
09345 #if 0
09346                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
09347 #endif
09348                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09349 
09350                     ;}
09351     break;
09352 
09353   case 417:
09354 
09355 /* Line 1464 of yacc.c  */
09356 #line 3764 "ripper.y"
09357     {
09358 #if 0
09359                         if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
09360 #endif
09361                         (yyval.val) = (yyvsp[(1) - (1)].val);
09362 
09363                     ;}
09364     break;
09365 
09366   case 419:
09367 
09368 /* Line 1464 of yacc.c  */
09369 #line 3775 "ripper.y"
09370     {
09371                         (yyval.val) = (yyvsp[(2) - (2)].val);
09372                     ;}
09373     break;
09374 
09375   case 421:
09376 
09377 /* Line 1464 of yacc.c  */
09378 #line 3782 "ripper.y"
09379     {
09380 #if 0
09381                         (yyval.val) = (yyvsp[(2) - (2)].val);
09382 #endif
09383                         (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
09384 
09385                     ;}
09386     break;
09387 
09388   case 424:
09389 
09390 /* Line 1464 of yacc.c  */
09391 #line 3794 "ripper.y"
09392     {
09393 #if 0
09394                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
09395 #endif
09396                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
09397 
09398                     ;}
09399     break;
09400 
09401   case 426:
09402 
09403 /* Line 1464 of yacc.c  */
09404 #line 3805 "ripper.y"
09405     {
09406 #if 0
09407                         NODE *node = (yyvsp[(1) - (1)].val);
09408                         if (!node) {
09409                             node = NEW_STR(STR_NEW0());
09410                         }
09411                         else {
09412                             node = evstr2dstr(node);
09413                         }
09414                         (yyval.val) = node;
09415 #endif
09416                         (yyval.val) = (yyvsp[(1) - (1)].val);
09417 
09418                     ;}
09419     break;
09420 
09421   case 429:
09422 
09423 /* Line 1464 of yacc.c  */
09424 #line 3824 "ripper.y"
09425     {
09426 #if 0
09427                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09428 #endif
09429                         (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09430 
09431                     ;}
09432     break;
09433 
09434   case 430:
09435 
09436 /* Line 1464 of yacc.c  */
09437 #line 3834 "ripper.y"
09438     {
09439 #if 0
09440                         (yyval.val) = (yyvsp[(2) - (3)].val);
09441 #endif
09442                         (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
09443 
09444                     ;}
09445     break;
09446 
09447   case 431:
09448 
09449 /* Line 1464 of yacc.c  */
09450 #line 3844 "ripper.y"
09451     {
09452 #if 0
09453                         NODE *node = (yyvsp[(2) - (3)].val);
09454                         if (!node) {
09455                             node = NEW_XSTR(STR_NEW0());
09456                         }
09457                         else {
09458                             switch (nd_type(node)) {
09459                               case NODE_STR:
09460                                 nd_set_type(node, NODE_XSTR);
09461                                 break;
09462                               case NODE_DSTR:
09463                                 nd_set_type(node, NODE_DXSTR);
09464                                 break;
09465                               default:
09466                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09467                                 break;
09468                             }
09469                         }
09470                         (yyval.val) = node;
09471 #endif
09472                         (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
09473 
09474                     ;}
09475     break;
09476 
09477   case 432:
09478 
09479 /* Line 1464 of yacc.c  */
09480 #line 3871 "ripper.y"
09481     {
09482 #if 0
09483                         int options = (yyvsp[(3) - (3)].val);
09484                         NODE *node = (yyvsp[(2) - (3)].val);
09485                         NODE *list, *prev;
09486                         if (!node) {
09487                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09488                         }
09489                         else switch (nd_type(node)) {
09490                           case NODE_STR:
09491                             {
09492                                 VALUE src = node->nd_lit;
09493                                 nd_set_type(node, NODE_LIT);
09494                                 node->nd_lit = reg_compile(src, options);
09495                             }
09496                             break;
09497                           default:
09498                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09499                           case NODE_DSTR:
09500                             if (options & RE_OPTION_ONCE) {
09501                                 nd_set_type(node, NODE_DREGX_ONCE);
09502                             }
09503                             else {
09504                                 nd_set_type(node, NODE_DREGX);
09505                             }
09506                             node->nd_cflag = options & RE_OPTION_MASK;
09507                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09508                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09509                                 if (nd_type(list->nd_head) == NODE_STR) {
09510                                     VALUE tail = list->nd_head->nd_lit;
09511                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09512                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09513                                         if (!literal_concat0(parser, lit, tail)) {
09514                                             node = 0;
09515                                             break;
09516                                         }
09517                                         rb_str_resize(tail, 0);
09518                                         prev->nd_next = list->nd_next;
09519                                         rb_gc_force_recycle((VALUE)list->nd_head);
09520                                         rb_gc_force_recycle((VALUE)list);
09521                                         list = prev;
09522                                     }
09523                                     else {
09524                                         prev = list;
09525                                     }
09526                                 }
09527                                 else {
09528                                     prev = 0;
09529                                 }
09530                             }
09531                             if (!node->nd_next) {
09532                                 VALUE src = node->nd_lit;
09533                                 nd_set_type(node, NODE_LIT);
09534                                 node->nd_lit = reg_compile(src, options);
09535                             }
09536                             break;
09537                         }
09538                         (yyval.val) = node;
09539 #endif
09540                         (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
09541 
09542                     ;}
09543     break;
09544 
09545   case 433:
09546 
09547 /* Line 1464 of yacc.c  */
09548 #line 3936 "ripper.y"
09549     {
09550 #if 0
09551                         (yyval.val) = NEW_ZARRAY();
09552 #endif
09553                         (yyval.val) = dispatch0(words_new);
09554                         (yyval.val) = dispatch1(array, (yyval.val));
09555 
09556                     ;}
09557     break;
09558 
09559   case 434:
09560 
09561 /* Line 1464 of yacc.c  */
09562 #line 3945 "ripper.y"
09563     {
09564 #if 0
09565                         (yyval.val) = (yyvsp[(2) - (3)].val);
09566 #endif
09567                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09568 
09569                     ;}
09570     break;
09571 
09572   case 435:
09573 
09574 /* Line 1464 of yacc.c  */
09575 #line 3955 "ripper.y"
09576     {
09577 #if 0
09578                         (yyval.val) = 0;
09579 #endif
09580                         (yyval.val) = dispatch0(words_new);
09581 
09582                     ;}
09583     break;
09584 
09585   case 436:
09586 
09587 /* Line 1464 of yacc.c  */
09588 #line 3963 "ripper.y"
09589     {
09590 #if 0
09591                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
09592 #endif
09593                         (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09594 
09595                     ;}
09596     break;
09597 
09598   case 437:
09599 
09600 /* Line 1464 of yacc.c  */
09601 #line 3975 "ripper.y"
09602     {
09603                         (yyval.val) = dispatch0(word_new);
09604                         (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
09605                     ;}
09606     break;
09607 
09608   case 438:
09609 
09610 /* Line 1464 of yacc.c  */
09611 #line 3981 "ripper.y"
09612     {
09613 #if 0
09614                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09615 #endif
09616                         (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09617 
09618                     ;}
09619     break;
09620 
09621   case 439:
09622 
09623 /* Line 1464 of yacc.c  */
09624 #line 3991 "ripper.y"
09625     {
09626 #if 0
09627                         (yyval.val) = NEW_ZARRAY();
09628 #endif
09629                         (yyval.val) = dispatch0(qwords_new);
09630                         (yyval.val) = dispatch1(array, (yyval.val));
09631 
09632                     ;}
09633     break;
09634 
09635   case 440:
09636 
09637 /* Line 1464 of yacc.c  */
09638 #line 4000 "ripper.y"
09639     {
09640 #if 0
09641                         (yyval.val) = (yyvsp[(2) - (3)].val);
09642 #endif
09643                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09644 
09645                     ;}
09646     break;
09647 
09648   case 441:
09649 
09650 /* Line 1464 of yacc.c  */
09651 #line 4010 "ripper.y"
09652     {
09653 #if 0
09654                         (yyval.val) = 0;
09655 #endif
09656                         (yyval.val) = dispatch0(qwords_new);
09657 
09658                     ;}
09659     break;
09660 
09661   case 442:
09662 
09663 /* Line 1464 of yacc.c  */
09664 #line 4018 "ripper.y"
09665     {
09666 #if 0
09667                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09668 #endif
09669                         (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09670 
09671                     ;}
09672     break;
09673 
09674   case 443:
09675 
09676 /* Line 1464 of yacc.c  */
09677 #line 4028 "ripper.y"
09678     {
09679 #if 0
09680                         (yyval.val) = 0;
09681 #endif
09682                         (yyval.val) = dispatch0(string_content);
09683 
09684                     ;}
09685     break;
09686 
09687   case 444:
09688 
09689 /* Line 1464 of yacc.c  */
09690 #line 4036 "ripper.y"
09691     {
09692 #if 0
09693                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09694 #endif
09695                         (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09696 
09697                     ;}
09698     break;
09699 
09700   case 445:
09701 
09702 /* Line 1464 of yacc.c  */
09703 #line 4046 "ripper.y"
09704     {
09705 #if 0
09706                         (yyval.val) = 0;
09707 #endif
09708                         (yyval.val) = dispatch0(xstring_new);
09709 
09710                     ;}
09711     break;
09712 
09713   case 446:
09714 
09715 /* Line 1464 of yacc.c  */
09716 #line 4054 "ripper.y"
09717     {
09718 #if 0
09719                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09720 #endif
09721                         (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09722 
09723                     ;}
09724     break;
09725 
09726   case 447:
09727 
09728 /* Line 1464 of yacc.c  */
09729 #line 4064 "ripper.y"
09730     {
09731 #if 0
09732                         (yyval.val) = 0;
09733 #endif
09734                         (yyval.val) = dispatch0(regexp_new);
09735 
09736                     ;}
09737     break;
09738 
09739   case 448:
09740 
09741 /* Line 1464 of yacc.c  */
09742 #line 4072 "ripper.y"
09743     {
09744 #if 0
09745                         NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
09746                         if (!head) {
09747                             (yyval.val) = tail;
09748                         }
09749                         else if (!tail) {
09750                             (yyval.val) = head;
09751                         }
09752                         else {
09753                             switch (nd_type(head)) {
09754                               case NODE_STR:
09755                                 nd_set_type(head, NODE_DSTR);
09756                                 break;
09757                               case NODE_DSTR:
09758                                 break;
09759                               default:
09760                                 head = list_append(NEW_DSTR(Qnil), head);
09761                                 break;
09762                             }
09763                             (yyval.val) = list_append(head, tail);
09764                         }
09765 #endif
09766                         (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09767 
09768                     ;}
09769     break;
09770 
09771   case 450:
09772 
09773 /* Line 1464 of yacc.c  */
09774 #line 4102 "ripper.y"
09775     {
09776                         (yyval.node) = lex_strterm;
09777                         lex_strterm = 0;
09778                         lex_state = EXPR_BEG;
09779                     ;}
09780     break;
09781 
09782   case 451:
09783 
09784 /* Line 1464 of yacc.c  */
09785 #line 4108 "ripper.y"
09786     {
09787 #if 0
09788                         lex_strterm = (yyvsp[(2) - (3)].node);
09789                         (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
09790 #endif
09791                         lex_strterm = (yyvsp[(2) - (3)].node);
09792                         (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
09793 
09794                     ;}
09795     break;
09796 
09797   case 452:
09798 
09799 /* Line 1464 of yacc.c  */
09800 #line 4118 "ripper.y"
09801     {
09802                         (yyvsp[(1) - (1)].val) = cond_stack;
09803                         (yyval.val) = cmdarg_stack;
09804                         cond_stack = 0;
09805                         cmdarg_stack = 0;
09806                     ;}
09807     break;
09808 
09809   case 453:
09810 
09811 /* Line 1464 of yacc.c  */
09812 #line 4124 "ripper.y"
09813     {
09814                         (yyval.node) = lex_strterm;
09815                         lex_strterm = 0;
09816                         lex_state = EXPR_BEG;
09817                     ;}
09818     break;
09819 
09820   case 454:
09821 
09822 /* Line 1464 of yacc.c  */
09823 #line 4130 "ripper.y"
09824     {
09825                         cond_stack = (yyvsp[(1) - (5)].val);
09826                         cmdarg_stack = (yyvsp[(2) - (5)].val);
09827                         lex_strterm = (yyvsp[(3) - (5)].node);
09828 #if 0
09829                         if ((yyvsp[(4) - (5)].val)) (yyvsp[(4) - (5)].val)->flags &= ~NODE_FL_NEWLINE;
09830                         (yyval.val) = new_evstr((yyvsp[(4) - (5)].val));
09831 #endif
09832                         (yyval.val) = dispatch1(string_embexpr, (yyvsp[(4) - (5)].val));
09833 
09834                     ;}
09835     break;
09836 
09837   case 455:
09838 
09839 /* Line 1464 of yacc.c  */
09840 #line 4144 "ripper.y"
09841     {
09842 #if 0
09843                         (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
09844 #endif
09845                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09846 
09847                     ;}
09848     break;
09849 
09850   case 456:
09851 
09852 /* Line 1464 of yacc.c  */
09853 #line 4152 "ripper.y"
09854     {
09855 #if 0
09856                         (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
09857 #endif
09858                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09859 
09860                     ;}
09861     break;
09862 
09863   case 457:
09864 
09865 /* Line 1464 of yacc.c  */
09866 #line 4160 "ripper.y"
09867     {
09868 #if 0
09869                         (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
09870 #endif
09871                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09872 
09873                     ;}
09874     break;
09875 
09876   case 459:
09877 
09878 /* Line 1464 of yacc.c  */
09879 #line 4171 "ripper.y"
09880     {
09881                         lex_state = EXPR_END;
09882 #if 0
09883                         (yyval.val) = (yyvsp[(2) - (2)].val);
09884 #endif
09885                         (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
09886 
09887                     ;}
09888     break;
09889 
09890   case 464:
09891 
09892 /* Line 1464 of yacc.c  */
09893 #line 4188 "ripper.y"
09894     {
09895                         lex_state = EXPR_END;
09896 #if 0
09897                         if (!((yyval.val) = (yyvsp[(2) - (3)].val))) {
09898                             (yyval.val) = NEW_LIT(ID2SYM(rb_intern("")));
09899                         }
09900                         else {
09901                             VALUE lit;
09902 
09903                             switch (nd_type((yyval.val))) {
09904                               case NODE_DSTR:
09905                                 nd_set_type((yyval.val), NODE_DSYM);
09906                                 break;
09907                               case NODE_STR:
09908                                 lit = (yyval.val)->nd_lit;
09909                                 (yyval.val)->nd_lit = ID2SYM(rb_intern_str(lit));
09910                                 nd_set_type((yyval.val), NODE_LIT);
09911                                 break;
09912                               default:
09913                                 (yyval.val) = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST((yyval.val)));
09914                                 break;
09915                             }
09916                         }
09917 #endif
09918                         (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
09919 
09920                     ;}
09921     break;
09922 
09923   case 467:
09924 
09925 /* Line 1464 of yacc.c  */
09926 #line 4220 "ripper.y"
09927     {
09928 #if 0
09929                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09930 #endif
09931                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09932 
09933                     ;}
09934     break;
09935 
09936   case 468:
09937 
09938 /* Line 1464 of yacc.c  */
09939 #line 4228 "ripper.y"
09940     {
09941 #if 0
09942                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09943 #endif
09944                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09945 
09946                     ;}
09947     break;
09948 
09949   case 474:
09950 
09951 /* Line 1464 of yacc.c  */
09952 #line 4242 "ripper.y"
09953     {ifndef_ripper((yyval.val) = keyword_nil);;}
09954     break;
09955 
09956   case 475:
09957 
09958 /* Line 1464 of yacc.c  */
09959 #line 4243 "ripper.y"
09960     {ifndef_ripper((yyval.val) = keyword_self);;}
09961     break;
09962 
09963   case 476:
09964 
09965 /* Line 1464 of yacc.c  */
09966 #line 4244 "ripper.y"
09967     {ifndef_ripper((yyval.val) = keyword_true);;}
09968     break;
09969 
09970   case 477:
09971 
09972 /* Line 1464 of yacc.c  */
09973 #line 4245 "ripper.y"
09974     {ifndef_ripper((yyval.val) = keyword_false);;}
09975     break;
09976 
09977   case 478:
09978 
09979 /* Line 1464 of yacc.c  */
09980 #line 4246 "ripper.y"
09981     {ifndef_ripper((yyval.val) = keyword__FILE__);;}
09982     break;
09983 
09984   case 479:
09985 
09986 /* Line 1464 of yacc.c  */
09987 #line 4247 "ripper.y"
09988     {ifndef_ripper((yyval.val) = keyword__LINE__);;}
09989     break;
09990 
09991   case 480:
09992 
09993 /* Line 1464 of yacc.c  */
09994 #line 4248 "ripper.y"
09995     {ifndef_ripper((yyval.val) = keyword__ENCODING__);;}
09996     break;
09997 
09998   case 481:
09999 
10000 /* Line 1464 of yacc.c  */
10001 #line 4252 "ripper.y"
10002     {
10003 #if 0
10004                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10005 #endif
10006                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10007 
10008                     ;}
10009     break;
10010 
10011   case 482:
10012 
10013 /* Line 1464 of yacc.c  */
10014 #line 4262 "ripper.y"
10015     {
10016                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10017 #if 0
10018 #endif
10019                         (yyval.val) = dispatch1(var_field, (yyval.val));
10020 
10021                     ;}
10022     break;
10023 
10024   case 485:
10025 
10026 /* Line 1464 of yacc.c  */
10027 #line 4276 "ripper.y"
10028     {
10029 #if 0
10030                         (yyval.val) = 0;
10031 #endif
10032                         (yyval.val) = Qnil;
10033 
10034                     ;}
10035     break;
10036 
10037   case 486:
10038 
10039 /* Line 1464 of yacc.c  */
10040 #line 4284 "ripper.y"
10041     {
10042                         lex_state = EXPR_BEG;
10043                     ;}
10044     break;
10045 
10046   case 487:
10047 
10048 /* Line 1464 of yacc.c  */
10049 #line 4288 "ripper.y"
10050     {
10051                         (yyval.val) = (yyvsp[(3) - (4)].val);
10052                     ;}
10053     break;
10054 
10055   case 488:
10056 
10057 /* Line 1464 of yacc.c  */
10058 #line 4292 "ripper.y"
10059     {
10060 #if 0
10061                         yyerrok;
10062                         (yyval.val) = 0;
10063 #endif
10064                         yyerrok;
10065                         (yyval.val) = Qnil;
10066 
10067                     ;}
10068     break;
10069 
10070   case 489:
10071 
10072 /* Line 1464 of yacc.c  */
10073 #line 4304 "ripper.y"
10074     {
10075 #if 0
10076                         (yyval.val) = (yyvsp[(2) - (3)].val);
10077 #endif
10078                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10079 
10080                         lex_state = EXPR_BEG;
10081                         command_start = TRUE;
10082                     ;}
10083     break;
10084 
10085   case 490:
10086 
10087 /* Line 1464 of yacc.c  */
10088 #line 4314 "ripper.y"
10089     {
10090                         (yyval.val) = (yyvsp[(1) - (2)].val);
10091                     ;}
10092     break;
10093 
10094   case 491:
10095 
10096 /* Line 1464 of yacc.c  */
10097 #line 4320 "ripper.y"
10098     {
10099 #if 0
10100                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
10101 #endif
10102                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
10103 
10104                     ;}
10105     break;
10106 
10107   case 492:
10108 
10109 /* Line 1464 of yacc.c  */
10110 #line 4328 "ripper.y"
10111     {
10112 #if 0
10113                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10114 #endif
10115                         (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)));
10116 
10117                     ;}
10118     break;
10119 
10120   case 493:
10121 
10122 /* Line 1464 of yacc.c  */
10123 #line 4336 "ripper.y"
10124     {
10125 #if 0
10126                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
10127 #endif
10128                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10129 
10130                     ;}
10131     break;
10132 
10133   case 494:
10134 
10135 /* Line 1464 of yacc.c  */
10136 #line 4344 "ripper.y"
10137     {
10138 #if 0
10139                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10140 #endif
10141                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10142 
10143                     ;}
10144     break;
10145 
10146   case 495:
10147 
10148 /* Line 1464 of yacc.c  */
10149 #line 4352 "ripper.y"
10150     {
10151 #if 0
10152                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10153 #endif
10154                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10155 
10156                     ;}
10157     break;
10158 
10159   case 496:
10160 
10161 /* Line 1464 of yacc.c  */
10162 #line 4360 "ripper.y"
10163     {
10164 #if 0
10165                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10166 #endif
10167                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10168 
10169                     ;}
10170     break;
10171 
10172   case 497:
10173 
10174 /* Line 1464 of yacc.c  */
10175 #line 4368 "ripper.y"
10176     {
10177 #if 0
10178                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
10179 #endif
10180                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10181 
10182                     ;}
10183     break;
10184 
10185   case 498:
10186 
10187 /* Line 1464 of yacc.c  */
10188 #line 4376 "ripper.y"
10189     {
10190 #if 0
10191                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10192 #endif
10193                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10194 
10195                     ;}
10196     break;
10197 
10198   case 499:
10199 
10200 /* Line 1464 of yacc.c  */
10201 #line 4384 "ripper.y"
10202     {
10203 #if 0
10204                         (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10205 #endif
10206                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10207 
10208                     ;}
10209     break;
10210 
10211   case 500:
10212 
10213 /* Line 1464 of yacc.c  */
10214 #line 4392 "ripper.y"
10215     {
10216 #if 0
10217                         (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
10218 #endif
10219                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10220 
10221                     ;}
10222     break;
10223 
10224   case 501:
10225 
10226 /* Line 1464 of yacc.c  */
10227 #line 4400 "ripper.y"
10228     {
10229 #if 0
10230                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10231 #endif
10232                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10233 
10234                     ;}
10235     break;
10236 
10237   case 502:
10238 
10239 /* Line 1464 of yacc.c  */
10240 #line 4408 "ripper.y"
10241     {
10242 #if 0
10243                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
10244 #endif
10245                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10246 
10247                     ;}
10248     break;
10249 
10250   case 503:
10251 
10252 /* Line 1464 of yacc.c  */
10253 #line 4416 "ripper.y"
10254     {
10255 #if 0
10256                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10257 #endif
10258                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10259 
10260                     ;}
10261     break;
10262 
10263   case 504:
10264 
10265 /* Line 1464 of yacc.c  */
10266 #line 4424 "ripper.y"
10267     {
10268 #if 0
10269                         (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
10270 #endif
10271                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
10272 
10273                     ;}
10274     break;
10275 
10276   case 505:
10277 
10278 /* Line 1464 of yacc.c  */
10279 #line 4432 "ripper.y"
10280     {
10281 #if 0
10282                         (yyval.val) = new_args(0, 0, 0, 0, 0);
10283 #endif
10284                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
10285 
10286                     ;}
10287     break;
10288 
10289   case 506:
10290 
10291 /* Line 1464 of yacc.c  */
10292 #line 4442 "ripper.y"
10293     {
10294 #if 0
10295                         yyerror("formal argument cannot be a constant");
10296                         (yyval.val) = 0;
10297 #endif
10298                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10299 
10300                     ;}
10301     break;
10302 
10303   case 507:
10304 
10305 /* Line 1464 of yacc.c  */
10306 #line 4451 "ripper.y"
10307     {
10308 #if 0
10309                         yyerror("formal argument cannot be an instance variable");
10310                         (yyval.val) = 0;
10311 #endif
10312                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10313 
10314                     ;}
10315     break;
10316 
10317   case 508:
10318 
10319 /* Line 1464 of yacc.c  */
10320 #line 4460 "ripper.y"
10321     {
10322 #if 0
10323                         yyerror("formal argument cannot be a global variable");
10324                         (yyval.val) = 0;
10325 #endif
10326                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10327 
10328                     ;}
10329     break;
10330 
10331   case 509:
10332 
10333 /* Line 1464 of yacc.c  */
10334 #line 4469 "ripper.y"
10335     {
10336 #if 0
10337                         yyerror("formal argument cannot be a class variable");
10338                         (yyval.val) = 0;
10339 #endif
10340                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10341 
10342                     ;}
10343     break;
10344 
10345   case 511:
10346 
10347 /* Line 1464 of yacc.c  */
10348 #line 4481 "ripper.y"
10349     {
10350                         formal_argument(get_id((yyvsp[(1) - (1)].val)));
10351                         (yyval.val) = (yyvsp[(1) - (1)].val);
10352                     ;}
10353     break;
10354 
10355   case 512:
10356 
10357 /* Line 1464 of yacc.c  */
10358 #line 4488 "ripper.y"
10359     {
10360                         arg_var(get_id((yyvsp[(1) - (1)].val)));
10361 #if 0
10362                         (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10363 #endif
10364                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10365 
10366                     ;}
10367     break;
10368 
10369   case 513:
10370 
10371 /* Line 1464 of yacc.c  */
10372 #line 4497 "ripper.y"
10373     {
10374                         ID tid = internal_id();
10375                         arg_var(tid);
10376 #if 0
10377                         if (dyna_in_block()) {
10378                             (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10379                         }
10380                         else {
10381                             (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10382                         }
10383                         (yyval.val) = NEW_ARGS_AUX(tid, 1);
10384                         (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10385 #endif
10386                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10387 
10388                     ;}
10389     break;
10390 
10391   case 514:
10392 
10393 /* Line 1464 of yacc.c  */
10394 #line 4518 "ripper.y"
10395     {
10396                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10397                     ;}
10398     break;
10399 
10400   case 515:
10401 
10402 /* Line 1464 of yacc.c  */
10403 #line 4523 "ripper.y"
10404     {
10405 #if 0
10406                         (yyval.val) = (yyvsp[(1) - (3)].val);
10407                         (yyval.val)->nd_plen++;
10408                         (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10409                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10410 #endif
10411                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10412 
10413                     ;}
10414     break;
10415 
10416   case 516:
10417 
10418 /* Line 1464 of yacc.c  */
10419 #line 4536 "ripper.y"
10420     {
10421                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10422                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10423 #if 0
10424                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10425 #endif
10426                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10427 
10428                     ;}
10429     break;
10430 
10431   case 517:
10432 
10433 /* Line 1464 of yacc.c  */
10434 #line 4548 "ripper.y"
10435     {
10436                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10437                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10438 #if 0
10439                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10440 #endif
10441                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10442 
10443                     ;}
10444     break;
10445 
10446   case 518:
10447 
10448 /* Line 1464 of yacc.c  */
10449 #line 4560 "ripper.y"
10450     {
10451 #if 0
10452                         (yyval.val) = (yyvsp[(1) - (1)].val);
10453 #endif
10454                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10455 
10456                     ;}
10457     break;
10458 
10459   case 519:
10460 
10461 /* Line 1464 of yacc.c  */
10462 #line 4568 "ripper.y"
10463     {
10464 #if 0
10465                         NODE *opts = (yyvsp[(1) - (3)].val);
10466 
10467                         while (opts->nd_next) {
10468                             opts = opts->nd_next;
10469                         }
10470                         opts->nd_next = (yyvsp[(3) - (3)].val);
10471                         (yyval.val) = (yyvsp[(1) - (3)].val);
10472 #endif
10473                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10474 
10475                     ;}
10476     break;
10477 
10478   case 520:
10479 
10480 /* Line 1464 of yacc.c  */
10481 #line 4584 "ripper.y"
10482     {
10483 #if 0
10484                         (yyval.val) = (yyvsp[(1) - (1)].val);
10485 #endif
10486                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10487 
10488                     ;}
10489     break;
10490 
10491   case 521:
10492 
10493 /* Line 1464 of yacc.c  */
10494 #line 4592 "ripper.y"
10495     {
10496 #if 0
10497                         NODE *opts = (yyvsp[(1) - (3)].val);
10498 
10499                         while (opts->nd_next) {
10500                             opts = opts->nd_next;
10501                         }
10502                         opts->nd_next = (yyvsp[(3) - (3)].val);
10503                         (yyval.val) = (yyvsp[(1) - (3)].val);
10504 #endif
10505                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10506 
10507                     ;}
10508     break;
10509 
10510   case 524:
10511 
10512 /* Line 1464 of yacc.c  */
10513 #line 4612 "ripper.y"
10514     {
10515 #if 0
10516                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10517                             yyerror("rest argument must be local variable");
10518 #endif
10519                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10520 #if 0
10521                         (yyval.val) = (yyvsp[(2) - (2)].val);
10522 #endif
10523                         (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10524 
10525                     ;}
10526     break;
10527 
10528   case 525:
10529 
10530 /* Line 1464 of yacc.c  */
10531 #line 4625 "ripper.y"
10532     {
10533 #if 0
10534                         (yyval.val) = internal_id();
10535                         arg_var((yyval.val));
10536 #endif
10537                         (yyval.val) = dispatch1(rest_param, Qnil);
10538 
10539                     ;}
10540     break;
10541 
10542   case 528:
10543 
10544 /* Line 1464 of yacc.c  */
10545 #line 4640 "ripper.y"
10546     {
10547 #if 0
10548                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10549                             yyerror("block argument must be local variable");
10550                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10551                             yyerror("duplicated block argument name");
10552 #endif
10553                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10554 #if 0
10555                         (yyval.val) = (yyvsp[(2) - (2)].val);
10556 #endif
10557                         (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10558 
10559                     ;}
10560     break;
10561 
10562   case 529:
10563 
10564 /* Line 1464 of yacc.c  */
10565 #line 4657 "ripper.y"
10566     {
10567                         (yyval.val) = (yyvsp[(2) - (2)].val);
10568                     ;}
10569     break;
10570 
10571   case 530:
10572 
10573 /* Line 1464 of yacc.c  */
10574 #line 4661 "ripper.y"
10575     {
10576 #if 0
10577                         (yyval.val) = 0;
10578 #endif
10579                         (yyval.val) = Qundef;
10580 
10581                     ;}
10582     break;
10583 
10584   case 531:
10585 
10586 /* Line 1464 of yacc.c  */
10587 #line 4671 "ripper.y"
10588     {
10589 #if 0
10590                         value_expr((yyvsp[(1) - (1)].val));
10591                         (yyval.val) = (yyvsp[(1) - (1)].val);
10592                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
10593 #endif
10594                         (yyval.val) = (yyvsp[(1) - (1)].val);
10595 
10596                     ;}
10597     break;
10598 
10599   case 532:
10600 
10601 /* Line 1464 of yacc.c  */
10602 #line 4680 "ripper.y"
10603     {lex_state = EXPR_BEG;;}
10604     break;
10605 
10606   case 533:
10607 
10608 /* Line 1464 of yacc.c  */
10609 #line 4681 "ripper.y"
10610     {
10611 #if 0
10612                         if ((yyvsp[(3) - (4)].val) == 0) {
10613                             yyerror("can't define singleton method for ().");
10614                         }
10615                         else {
10616                             switch (nd_type((yyvsp[(3) - (4)].val))) {
10617                               case NODE_STR:
10618                               case NODE_DSTR:
10619                               case NODE_XSTR:
10620                               case NODE_DXSTR:
10621                               case NODE_DREGX:
10622                               case NODE_LIT:
10623                               case NODE_ARRAY:
10624                               case NODE_ZARRAY:
10625                                 yyerror("can't define singleton method for literals");
10626                               default:
10627                                 value_expr((yyvsp[(3) - (4)].val));
10628                                 break;
10629                             }
10630                         }
10631                         (yyval.val) = (yyvsp[(3) - (4)].val);
10632 #endif
10633                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10634 
10635                     ;}
10636     break;
10637 
10638   case 535:
10639 
10640 /* Line 1464 of yacc.c  */
10641 #line 4711 "ripper.y"
10642     {
10643 #if 0
10644                         (yyval.val) = (yyvsp[(1) - (2)].val);
10645 #endif
10646                         (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10647 
10648                     ;}
10649     break;
10650 
10651   case 536:
10652 
10653 /* Line 1464 of yacc.c  */
10654 #line 4723 "ripper.y"
10655     {
10656                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10657                     ;}
10658     break;
10659 
10660   case 537:
10661 
10662 /* Line 1464 of yacc.c  */
10663 #line 4728 "ripper.y"
10664     {
10665 #if 0
10666                         (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10667 #endif
10668                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10669 
10670                     ;}
10671     break;
10672 
10673   case 538:
10674 
10675 /* Line 1464 of yacc.c  */
10676 #line 4738 "ripper.y"
10677     {
10678 #if 0
10679                         (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10680 #endif
10681                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10682 
10683                     ;}
10684     break;
10685 
10686   case 539:
10687 
10688 /* Line 1464 of yacc.c  */
10689 #line 4746 "ripper.y"
10690     {
10691 #if 0
10692                         (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10693 #endif
10694                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10695 
10696                     ;}
10697     break;
10698 
10699   case 550:
10700 
10701 /* Line 1464 of yacc.c  */
10702 #line 4774 "ripper.y"
10703     { (yyval.val) = (yyvsp[(1) - (1)].val); ;}
10704     break;
10705 
10706   case 551:
10707 
10708 /* Line 1464 of yacc.c  */
10709 #line 4779 "ripper.y"
10710     { (yyval.val) = (yyvsp[(1) - (1)].val); ;}
10711     break;
10712 
10713   case 561:
10714 
10715 /* Line 1464 of yacc.c  */
10716 #line 4802 "ripper.y"
10717     {yyerrok;;}
10718     break;
10719 
10720   case 564:
10721 
10722 /* Line 1464 of yacc.c  */
10723 #line 4807 "ripper.y"
10724     {yyerrok;;}
10725     break;
10726 
10727   case 565:
10728 
10729 /* Line 1464 of yacc.c  */
10730 #line 4811 "ripper.y"
10731     {
10732 #if 0
10733                         (yyval.val) = 0;
10734 #endif
10735                         (yyval.val) = Qundef;
10736 
10737                     ;}
10738     break;
10739 
10740 
10741 
10742 /* Line 1464 of yacc.c  */
10743 #line 10742 "parse.c"
10744       default: break;
10745     }
10746   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10747 
10748   YYPOPSTACK (yylen);
10749   yylen = 0;
10750   YY_STACK_PRINT (yyss, yyssp);
10751 
10752   *++yyvsp = yyval;
10753 
10754   /* Now `shift' the result of the reduction.  Determine what state
10755      that goes to, based on the state we popped back to and the rule
10756      number reduced by.  */
10757 
10758   yyn = yyr1[yyn];
10759 
10760   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10761   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10762     yystate = yytable[yystate];
10763   else
10764     yystate = yydefgoto[yyn - YYNTOKENS];
10765 
10766   goto yynewstate;
10767 
10768 
10769 /*------------------------------------.
10770 | yyerrlab -- here on detecting error |
10771 `------------------------------------*/
10772 yyerrlab:
10773   /* If not already recovering from an error, report this error.  */
10774   if (!yyerrstatus)
10775     {
10776       ++yynerrs;
10777 #if ! YYERROR_VERBOSE
10778       parser_yyerror (parser, YY_("syntax error"));
10779 #else
10780       {
10781         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
10782         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
10783           {
10784             YYSIZE_T yyalloc = 2 * yysize;
10785             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
10786               yyalloc = YYSTACK_ALLOC_MAXIMUM;
10787             if (yymsg != yymsgbuf)
10788               YYSTACK_FREE (yymsg);
10789             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
10790             if (yymsg)
10791               yymsg_alloc = yyalloc;
10792             else
10793               {
10794                 yymsg = yymsgbuf;
10795                 yymsg_alloc = sizeof yymsgbuf;
10796               }
10797           }
10798 
10799         if (0 < yysize && yysize <= yymsg_alloc)
10800           {
10801             (void) yysyntax_error (yymsg, yystate, yychar);
10802             parser_yyerror (parser, yymsg);
10803           }
10804         else
10805           {
10806             parser_yyerror (parser, YY_("syntax error"));
10807             if (yysize != 0)
10808               goto yyexhaustedlab;
10809           }
10810       }
10811 #endif
10812     }
10813 
10814 
10815 
10816   if (yyerrstatus == 3)
10817     {
10818       /* If just tried and failed to reuse lookahead token after an
10819          error, discard it.  */
10820 
10821       if (yychar <= YYEOF)
10822         {
10823           /* Return failure if at end of input.  */
10824           if (yychar == YYEOF)
10825             YYABORT;
10826         }
10827       else
10828         {
10829           yydestruct ("Error: discarding",
10830                       yytoken, &yylval, parser);
10831           yychar = YYEMPTY;
10832         }
10833     }
10834 
10835   /* Else will try to reuse lookahead token after shifting the error
10836      token.  */
10837   goto yyerrlab1;
10838 
10839 
10840 /*---------------------------------------------------.
10841 | yyerrorlab -- error raised explicitly by YYERROR.  |
10842 `---------------------------------------------------*/
10843 yyerrorlab:
10844 
10845   /* Pacify compilers like GCC when the user code never invokes
10846      YYERROR and the label yyerrorlab therefore never appears in user
10847      code.  */
10848   if (/*CONSTCOND*/ 0)
10849      goto yyerrorlab;
10850 
10851   /* Do not reclaim the symbols of the rule which action triggered
10852      this YYERROR.  */
10853   YYPOPSTACK (yylen);
10854   yylen = 0;
10855   YY_STACK_PRINT (yyss, yyssp);
10856   yystate = *yyssp;
10857   goto yyerrlab1;
10858 
10859 
10860 /*-------------------------------------------------------------.
10861 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
10862 `-------------------------------------------------------------*/
10863 yyerrlab1:
10864   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
10865 
10866   for (;;)
10867     {
10868       yyn = yypact[yystate];
10869       if (yyn != YYPACT_NINF)
10870         {
10871           yyn += YYTERROR;
10872           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10873             {
10874               yyn = yytable[yyn];
10875               if (0 < yyn)
10876                 break;
10877             }
10878         }
10879 
10880       /* Pop the current state because it cannot handle the error token.  */
10881       if (yyssp == yyss)
10882         YYABORT;
10883 
10884 
10885       yydestruct ("Error: popping",
10886                   yystos[yystate], yyvsp, parser);
10887       YYPOPSTACK (1);
10888       yystate = *yyssp;
10889       YY_STACK_PRINT (yyss, yyssp);
10890     }
10891 
10892   *++yyvsp = yylval;
10893 
10894 
10895   /* Shift the error token.  */
10896   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10897 
10898   yystate = yyn;
10899   goto yynewstate;
10900 
10901 
10902 /*-------------------------------------.
10903 | yyacceptlab -- YYACCEPT comes here.  |
10904 `-------------------------------------*/
10905 yyacceptlab:
10906   yyresult = 0;
10907   goto yyreturn;
10908 
10909 /*-----------------------------------.
10910 | yyabortlab -- YYABORT comes here.  |
10911 `-----------------------------------*/
10912 yyabortlab:
10913   yyresult = 1;
10914   goto yyreturn;
10915 
10916 #if !defined(yyoverflow) || YYERROR_VERBOSE
10917 /*-------------------------------------------------.
10918 | yyexhaustedlab -- memory exhaustion comes here.  |
10919 `-------------------------------------------------*/
10920 yyexhaustedlab:
10921   parser_yyerror (parser, YY_("memory exhausted"));
10922   yyresult = 2;
10923   /* Fall through.  */
10924 #endif
10925 
10926 yyreturn:
10927   if (yychar != YYEMPTY)
10928      yydestruct ("Cleanup: discarding lookahead",
10929                  yytoken, &yylval, parser);
10930   /* Do not reclaim the symbols of the rule which action triggered
10931      this YYABORT or YYACCEPT.  */
10932   YYPOPSTACK (yylen);
10933   YY_STACK_PRINT (yyss, yyssp);
10934   while (yyssp != yyss)
10935     {
10936       yydestruct ("Cleanup: popping",
10937                   yystos[*yyssp], yyvsp, parser);
10938       YYPOPSTACK (1);
10939     }
10940 #ifndef yyoverflow
10941   if (yyss != yyssa)
10942     YYSTACK_FREE (yyss);
10943 #endif
10944 #if YYERROR_VERBOSE
10945   if (yymsg != yymsgbuf)
10946     YYSTACK_FREE (yymsg);
10947 #endif
10948   /* Make sure YYID is used.  */
10949   return YYID (yyresult);
10950 }
10951 
10952 
10953 
10954 /* Line 1684 of yacc.c  */
10955 #line 4819 "ripper.y"
10956 
10957 # undef parser
10958 # undef yylex
10959 # undef yylval
10960 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
10961 
10962 static int parser_regx_options(struct parser_params*);
10963 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
10964 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
10965 static int parser_parse_string(struct parser_params*,NODE*);
10966 static int parser_here_document(struct parser_params*,NODE*);
10967 
10968 
10969 # define nextc()                   parser_nextc(parser)
10970 # define pushback(c)               parser_pushback(parser, c)
10971 # define newtok()                  parser_newtok(parser)
10972 # define tokspace(n)               parser_tokspace(parser, n)
10973 # define tokadd(c)                 parser_tokadd(parser, c)
10974 # define tok_hex(numlen)           parser_tok_hex(parser, numlen)
10975 # define read_escape(flags,e)      parser_read_escape(parser, flags, e)
10976 # define tokadd_escape(e)          parser_tokadd_escape(parser, e)
10977 # define regx_options()            parser_regx_options(parser)
10978 # define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser,f,t,p,n,e)
10979 # define parse_string(n)           parser_parse_string(parser,n)
10980 # define tokaddmbc(c, enc)         parser_tokaddmbc(parser, c, enc)
10981 # define here_document(n)          parser_here_document(parser,n)
10982 # define heredoc_identifier()      parser_heredoc_identifier(parser)
10983 # define heredoc_restore(n)        parser_heredoc_restore(parser,n)
10984 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,e,l,i)
10985 
10986 #ifndef RIPPER
10987 # define set_yylval_str(x) yylval.node = NEW_STR(x)
10988 # define set_yylval_num(x) yylval.num = x
10989 # define set_yylval_id(x)  yylval.id = x
10990 # define set_yylval_name(x)  yylval.id = x
10991 # define set_yylval_literal(x) yylval.node = NEW_LIT(x)
10992 # define set_yylval_node(x) yylval.node = x
10993 # define yylval_id() yylval.id
10994 #else
10995 static inline VALUE
10996 ripper_yylval_id(ID x)
10997 {
10998     return (VALUE)NEW_LASGN(x, ID2SYM(x));
10999 }
11000 # define set_yylval_str(x) (void)(x)
11001 # define set_yylval_num(x) (void)(x)
11002 # define set_yylval_id(x)  (void)(x)
11003 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11004 # define set_yylval_literal(x) (void)(x)
11005 # define set_yylval_node(x) (void)(x)
11006 # define yylval_id() yylval.id
11007 #endif
11008 
11009 #ifndef RIPPER
11010 #define ripper_flush(p) (void)(p)
11011 #else
11012 #define ripper_flush(p) (p->tokp = p->parser_lex_p)
11013 
11014 #define yylval_rval *(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val)
11015 
11016 static int
11017 ripper_has_scan_event(struct parser_params *parser)
11018 {
11019 
11020     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11021     return lex_p > parser->tokp;
11022 }
11023 
11024 static VALUE
11025 ripper_scan_event_val(struct parser_params *parser, int t)
11026 {
11027     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11028     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11029     ripper_flush(parser);
11030     return rval;
11031 }
11032 
11033 static void
11034 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11035 {
11036     if (!ripper_has_scan_event(parser)) return;
11037     yylval_rval = ripper_scan_event_val(parser, t);
11038 }
11039 
11040 static void
11041 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11042 {
11043     if (!ripper_has_scan_event(parser)) return;
11044     (void)ripper_scan_event_val(parser, t);
11045 }
11046 
11047 static void
11048 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11049 {
11050     int saved_line = ruby_sourceline;
11051     const char *saved_tokp = parser->tokp;
11052 
11053     ruby_sourceline = parser->delayed_line;
11054     parser->tokp = lex_pbeg + parser->delayed_col;
11055     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11056     parser->delayed = Qnil;
11057     ruby_sourceline = saved_line;
11058     parser->tokp = saved_tokp;
11059 }
11060 #endif /* RIPPER */
11061 
11062 #include "ruby/regex.h"
11063 #include "ruby/util.h"
11064 
11065 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11066    since ours (we hope) works properly with all combinations of
11067    machines, compilers, `char' and `unsigned char' argument types.
11068    (Per Bothner suggested the basic approach.)  */
11069 #undef SIGN_EXTEND_CHAR
11070 #if __STDC__
11071 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11072 #else  /* not __STDC__ */
11073 /* As in Harbison and Steele.  */
11074 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11075 #endif
11076 
11077 #define parser_encoding_name()  (parser->enc->name)
11078 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,parser->enc)
11079 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
11080 #define is_identchar(p,e,enc) (rb_enc_isalnum(*p,enc) || (*p) == '_' || !ISASCII(*p))
11081 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
11082 
11083 #define parser_isascii() ISASCII(*(lex_p-1))
11084 
11085 #ifndef RIPPER
11086 static int
11087 token_info_get_column(struct parser_params *parser, const char *token)
11088 {
11089     int column = 1;
11090     const char *p, *pend = lex_p - strlen(token);
11091     for (p = lex_pbeg; p < pend; p++) {
11092         if (*p == '\t') {
11093             column = (((column - 1) / 8) + 1) * 8;
11094         }
11095         column++;
11096     }
11097     return column;
11098 }
11099 
11100 static int
11101 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11102 {
11103     const char *p, *pend = lex_p - strlen(token);
11104     for (p = lex_pbeg; p < pend; p++) {
11105         if (*p != ' ' && *p != '\t') {
11106             return 1;
11107         }
11108     }
11109     return 0;
11110 }
11111 
11112 #undef token_info_push
11113 static void
11114 token_info_push(struct parser_params *parser, const char *token)
11115 {
11116     token_info *ptinfo;
11117 
11118     if (compile_for_eval) return;
11119     ptinfo = ALLOC(token_info);
11120     ptinfo->token = token;
11121     ptinfo->linenum = ruby_sourceline;
11122     ptinfo->column = token_info_get_column(parser, token);
11123     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11124     ptinfo->next = parser->parser_token_info;
11125 
11126     parser->parser_token_info = ptinfo;
11127 }
11128 
11129 #undef token_info_pop
11130 static void
11131 token_info_pop(struct parser_params *parser, const char *token)
11132 {
11133     int linenum;
11134     token_info *ptinfo = parser->parser_token_info;
11135 
11136     if (!ptinfo) return;
11137     parser->parser_token_info = ptinfo->next;
11138     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11139         goto finish;
11140     }
11141     linenum = ruby_sourceline;
11142     if (linenum == ptinfo->linenum) { /* SKIP */
11143         goto finish;
11144     }
11145     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11146         goto finish;
11147     }
11148     rb_compile_warning(ruby_sourcefile, linenum,
11149                "mismatched indentations at '%s' with '%s' at %d",
11150                token, ptinfo->token, ptinfo->linenum);
11151 
11152   finish:
11153     xfree(ptinfo);
11154 }
11155 #endif  /* RIPPER */
11156 
11157 static int
11158 parser_yyerror(struct parser_params *parser, const char *msg)
11159 {
11160 #ifndef RIPPER
11161     const int max_line_margin = 30;
11162     const char *p, *pe;
11163     char *buf;
11164     long len;
11165     int i;
11166 
11167     compile_error(PARSER_ARG "%s", msg);
11168     p = lex_p;
11169     while (lex_pbeg <= p) {
11170         if (*p == '\n') break;
11171         p--;
11172     }
11173     p++;
11174 
11175     pe = lex_p;
11176     while (pe < lex_pend) {
11177         if (*pe == '\n') break;
11178         pe++;
11179     }
11180 
11181     len = pe - p;
11182     if (len > 4) {
11183         char *p2;
11184         const char *pre = "", *post = "";
11185 
11186         if (len > max_line_margin * 2 + 10) {
11187             if (lex_p - p > max_line_margin) {
11188                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11189                 pre = "...";
11190             }
11191             if (pe - lex_p > max_line_margin) {
11192                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11193                 post = "...";
11194             }
11195             len = pe - p;
11196         }
11197         buf = ALLOCA_N(char, len+2);
11198         MEMCPY(buf, p, char, len);
11199         buf[len] = '\0';
11200         rb_compile_error_append("%s%s%s", pre, buf, post);
11201 
11202         i = (int)(lex_p - p);
11203         p2 = buf; pe = buf + len;
11204 
11205         while (p2 < pe) {
11206             if (*p2 != '\t') *p2 = ' ';
11207             p2++;
11208         }
11209         buf[i] = '^';
11210         buf[i+1] = '\0';
11211         rb_compile_error_append("%s%s", pre, buf);
11212     }
11213 #else
11214     dispatch1(parse_error, STR_NEW2(msg));
11215 #endif /* !RIPPER */
11216     return 0;
11217 }
11218 
11219 static void parser_prepare(struct parser_params *parser);
11220 
11221 #ifndef RIPPER
11222 VALUE ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always);
11223 
11224 static VALUE
11225 debug_lines(const char *f)
11226 {
11227     ID script_lines;
11228     CONST_ID(script_lines, "SCRIPT_LINES__");
11229     if (rb_const_defined_at(rb_cObject, script_lines)) {
11230         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11231         if (TYPE(hash) == T_HASH) {
11232             VALUE fname = rb_str_new2(f);
11233             VALUE lines = rb_ary_new();
11234             rb_hash_aset(hash, fname, lines);
11235             return lines;
11236         }
11237     }
11238     return 0;
11239 }
11240 
11241 static VALUE
11242 coverage(const char *f, int n)
11243 {
11244     extern VALUE rb_get_coverages(void);
11245     VALUE coverages = rb_get_coverages();
11246     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11247         VALUE fname = rb_str_new2(f);
11248         VALUE lines = rb_ary_new2(n);
11249         int i;
11250         RBASIC(lines)->klass = 0;
11251         for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11252         RARRAY(lines)->as.heap.len = n;
11253         rb_hash_aset(coverages, fname, lines);
11254         return lines;
11255     }
11256     return 0;
11257 }
11258 
11259 static int
11260 e_option_supplied(struct parser_params *parser)
11261 {
11262     return strcmp(ruby_sourcefile, "-e") == 0;
11263 }
11264 
11265 static VALUE
11266 yycompile0(VALUE arg, int tracing)
11267 {
11268     int n;
11269     NODE *tree;
11270     struct parser_params *parser = (struct parser_params *)arg;
11271 
11272     if (!compile_for_eval && rb_safe_level() == 0) {
11273         ruby_debug_lines = debug_lines(ruby_sourcefile);
11274         if (ruby_debug_lines && ruby_sourceline > 0) {
11275             VALUE str = STR_NEW0();
11276             n = ruby_sourceline;
11277             do {
11278                 rb_ary_push(ruby_debug_lines, str);
11279             } while (--n);
11280         }
11281 
11282         if (!e_option_supplied(parser)) {
11283             ruby_coverage = coverage(ruby_sourcefile, ruby_sourceline);
11284         }
11285     }
11286 
11287     parser_prepare(parser);
11288     deferred_nodes = 0;
11289     n = yyparse((void*)parser);
11290     ruby_debug_lines = 0;
11291     ruby_coverage = 0;
11292     compile_for_eval = 0;
11293 
11294     lex_strterm = 0;
11295     lex_p = lex_pbeg = lex_pend = 0;
11296     lex_lastline = lex_nextline = 0;
11297     if (parser->nerr) {
11298         return 0;
11299     }
11300     tree = ruby_eval_tree;
11301     if (!tree) {
11302         tree = NEW_NIL();
11303     }
11304     else if (ruby_eval_tree_begin) {
11305         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11306     }
11307     return (VALUE)tree;
11308 }
11309 
11310 static NODE*
11311 yycompile(struct parser_params *parser, const char *f, int line)
11312 {
11313     ruby_sourcefile = ruby_strdup(f);
11314     ruby_sourceline = line - 1;
11315     return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
11316 }
11317 #endif /* !RIPPER */
11318 
11319 static rb_encoding *
11320 must_be_ascii_compatible(VALUE s)
11321 {
11322     rb_encoding *enc = rb_enc_get(s);
11323     if (!rb_enc_asciicompat(enc)) {
11324         rb_raise(rb_eArgError, "invalid source encoding");
11325     }
11326     return enc;
11327 }
11328 
11329 static VALUE
11330 lex_get_str(struct parser_params *parser, VALUE s)
11331 {
11332     char *beg, *end, *pend;
11333     rb_encoding *enc = must_be_ascii_compatible(s);
11334 
11335     beg = RSTRING_PTR(s);
11336     if (lex_gets_ptr) {
11337         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11338         beg += lex_gets_ptr;
11339     }
11340     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11341     end = beg;
11342     while (end < pend) {
11343         if (*end++ == '\n') break;
11344     }
11345     lex_gets_ptr = end - RSTRING_PTR(s);
11346     return rb_enc_str_new(beg, end - beg, enc);
11347 }
11348 
11349 static VALUE
11350 lex_getline(struct parser_params *parser)
11351 {
11352     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11353     if (NIL_P(line)) return line;
11354     must_be_ascii_compatible(line);
11355 #ifndef RIPPER
11356     if (ruby_debug_lines) {
11357         rb_enc_associate(line, parser->enc);
11358         rb_ary_push(ruby_debug_lines, line);
11359     }
11360     if (ruby_coverage) {
11361         rb_ary_push(ruby_coverage, Qnil);
11362     }
11363 #endif
11364     return line;
11365 }
11366 
11367 static const rb_data_type_t parser_data_type;
11368 
11369 #ifndef RIPPER
11370 static NODE*
11371 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11372 {
11373     struct parser_params *parser;
11374     NODE *node;
11375     volatile VALUE tmp;
11376 
11377     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11378     lex_gets = lex_get_str;
11379     lex_gets_ptr = 0;
11380     lex_input = s;
11381     lex_pbeg = lex_p = lex_pend = 0;
11382     compile_for_eval = rb_parse_in_eval();
11383 
11384     node = yycompile(parser, f, line);
11385     tmp = vparser; /* prohibit tail call optimization */
11386 
11387     return node;
11388 }
11389 
11390 NODE*
11391 rb_compile_string(const char *f, VALUE s, int line)
11392 {
11393     must_be_ascii_compatible(s);
11394     return parser_compile_string(rb_parser_new(), f, s, line);
11395 }
11396 
11397 NODE*
11398 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11399 {
11400     must_be_ascii_compatible(s);
11401     return parser_compile_string(vparser, f, s, line);
11402 }
11403 
11404 NODE*
11405 rb_compile_cstr(const char *f, const char *s, int len, int line)
11406 {
11407     VALUE str = rb_str_new(s, len);
11408     return parser_compile_string(rb_parser_new(), f, str, line);
11409 }
11410 
11411 NODE*
11412 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11413 {
11414     VALUE str = rb_str_new(s, len);
11415     return parser_compile_string(vparser, f, str, line);
11416 }
11417 
11418 static VALUE
11419 lex_io_gets(struct parser_params *parser, VALUE io)
11420 {
11421     return rb_io_gets(io);
11422 }
11423 
11424 NODE*
11425 rb_compile_file(const char *f, VALUE file, int start)
11426 {
11427     VALUE volatile vparser = rb_parser_new();
11428 
11429     return rb_parser_compile_file(vparser, f, file, start);
11430 }
11431 
11432 NODE*
11433 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11434 {
11435     struct parser_params *parser;
11436     volatile VALUE tmp;
11437     NODE *node;
11438 
11439     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11440     lex_gets = lex_io_gets;
11441     lex_input = file;
11442     lex_pbeg = lex_p = lex_pend = 0;
11443     compile_for_eval = rb_parse_in_eval();
11444 
11445     node = yycompile(parser, f, start);
11446     tmp = vparser; /* prohibit tail call optimization */
11447 
11448     return node;
11449 }
11450 #endif  /* !RIPPER */
11451 
11452 #define STR_FUNC_ESCAPE 0x01
11453 #define STR_FUNC_EXPAND 0x02
11454 #define STR_FUNC_REGEXP 0x04
11455 #define STR_FUNC_QWORDS 0x08
11456 #define STR_FUNC_SYMBOL 0x10
11457 #define STR_FUNC_INDENT 0x20
11458 
11459 enum string_type {
11460     str_squote = (0),
11461     str_dquote = (STR_FUNC_EXPAND),
11462     str_xquote = (STR_FUNC_EXPAND),
11463     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
11464     str_sword  = (STR_FUNC_QWORDS),
11465     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
11466     str_ssym   = (STR_FUNC_SYMBOL),
11467     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
11468 };
11469 
11470 static VALUE
11471 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11472 {
11473     VALUE str;
11474 
11475     str = rb_enc_str_new(p, n, enc);
11476     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11477         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
11478         }
11479         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11480             rb_enc_associate(str, rb_ascii8bit_encoding());
11481         }
11482     }
11483 
11484     return str;
11485 }
11486 
11487 #define lex_goto_eol(parser) (parser->parser_lex_p = parser->parser_lex_pend)
11488 #define peek(c) (lex_p < lex_pend && (c) == *lex_p)
11489 
11490 static inline int
11491 parser_nextc(struct parser_params *parser)
11492 {
11493     int c;
11494 
11495     if (lex_p == lex_pend) {
11496         VALUE v = lex_nextline;
11497         lex_nextline = 0;
11498         if (!v) {
11499             if (parser->eofp)
11500                 return -1;
11501 
11502             if (!lex_input || NIL_P(v = lex_getline(parser))) {
11503                 parser->eofp = Qtrue;
11504                 lex_goto_eol(parser);
11505                 return -1;
11506             }
11507         }
11508         {
11509 #ifdef RIPPER
11510             if (parser->tokp < lex_pend) {
11511                 if (NIL_P(parser->delayed)) {
11512                     parser->delayed = rb_str_buf_new(1024);
11513                     rb_str_buf_cat(parser->delayed,
11514                                    parser->tokp, lex_pend - parser->tokp);
11515                     parser->delayed_line = ruby_sourceline;
11516                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11517                 }
11518                 else {
11519                     rb_str_buf_cat(parser->delayed,
11520                                    parser->tokp, lex_pend - parser->tokp);
11521                 }
11522             }
11523 #endif
11524             if (heredoc_end > 0) {
11525                 ruby_sourceline = heredoc_end;
11526                 heredoc_end = 0;
11527             }
11528             ruby_sourceline++;
11529             parser->line_count++;
11530             lex_pbeg = lex_p = RSTRING_PTR(v);
11531             lex_pend = lex_p + RSTRING_LEN(v);
11532             ripper_flush(parser);
11533             lex_lastline = v;
11534         }
11535     }
11536     c = (unsigned char)*lex_p++;
11537     if (c == '\r' && peek('\n')) {
11538         lex_p++;
11539         c = '\n';
11540     }
11541 
11542     return c;
11543 }
11544 
11545 static void
11546 parser_pushback(struct parser_params *parser, int c)
11547 {
11548     if (c == -1) return;
11549     lex_p--;
11550     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11551         lex_p--;
11552     }
11553 }
11554 
11555 #define was_bol() (lex_p == lex_pbeg + 1)
11556 
11557 #define tokfix() (tokenbuf[tokidx]='\0')
11558 #define tok() tokenbuf
11559 #define toklen() tokidx
11560 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11561 
11562 static char*
11563 parser_newtok(struct parser_params *parser)
11564 {
11565     tokidx = 0;
11566     if (!tokenbuf) {
11567         toksiz = 60;
11568         tokenbuf = ALLOC_N(char, 60);
11569     }
11570     if (toksiz > 4096) {
11571         toksiz = 60;
11572         REALLOC_N(tokenbuf, char, 60);
11573     }
11574     return tokenbuf;
11575 }
11576 
11577 static char *
11578 parser_tokspace(struct parser_params *parser, int n)
11579 {
11580     tokidx += n;
11581 
11582     if (tokidx >= toksiz) {
11583         do {toksiz *= 2;} while (toksiz < tokidx);
11584         REALLOC_N(tokenbuf, char, toksiz);
11585     }
11586     return &tokenbuf[tokidx-n];
11587 }
11588 
11589 static void
11590 parser_tokadd(struct parser_params *parser, int c)
11591 {
11592     tokenbuf[tokidx++] = (char)c;
11593     if (tokidx >= toksiz) {
11594         toksiz *= 2;
11595         REALLOC_N(tokenbuf, char, toksiz);
11596     }
11597 }
11598 
11599 static int
11600 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11601 {
11602     int c;
11603 
11604     c = scan_hex(lex_p, 2, numlen);
11605     if (!*numlen) {
11606         yyerror("invalid hex escape");
11607         return 0;
11608     }
11609     lex_p += *numlen;
11610     return c;
11611 }
11612 
11613 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11614 
11615 static int
11616 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
11617                    int string_literal, int symbol_literal, int regexp_literal)
11618 {
11619     /*
11620      * If string_literal is true, then we allow multiple codepoints
11621      * in \u{}, and add the codepoints to the current token.
11622      * Otherwise we're parsing a character literal and return a single
11623      * codepoint without adding it
11624      */
11625 
11626     int codepoint;
11627     size_t numlen;
11628 
11629     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11630 
11631     if (peek('{')) {  /* handle \u{...} form */
11632         do {
11633             if (regexp_literal) { tokadd(*lex_p); }
11634             nextc();
11635             codepoint = scan_hex(lex_p, 6, &numlen);
11636             if (numlen == 0)  {
11637                 yyerror("invalid Unicode escape");
11638                 return 0;
11639             }
11640             if (codepoint > 0x10ffff) {
11641                 yyerror("invalid Unicode codepoint (too large)");
11642                 return 0;
11643             }
11644             lex_p += numlen;
11645             if (regexp_literal) {
11646                 tokcopy((int)numlen);
11647             }
11648             else if (codepoint >= 0x80) {
11649                 *encp = UTF8_ENC();
11650                 if (string_literal) tokaddmbc(codepoint, *encp);
11651             }
11652             else if (string_literal) {
11653                 tokadd(codepoint);
11654             }
11655         } while (string_literal && (peek(' ') || peek('\t')));
11656 
11657         if (!peek('}')) {
11658             yyerror("unterminated Unicode escape");
11659             return 0;
11660         }
11661 
11662         if (regexp_literal) { tokadd('}'); }
11663         nextc();
11664     }
11665     else {                      /* handle \uxxxx form */
11666         codepoint = scan_hex(lex_p, 4, &numlen);
11667         if (numlen < 4) {
11668             yyerror("invalid Unicode escape");
11669             return 0;
11670         }
11671         lex_p += 4;
11672         if (regexp_literal) {
11673             tokcopy(4);
11674         }
11675         else if (codepoint >= 0x80) {
11676             *encp = UTF8_ENC();
11677             if (string_literal) tokaddmbc(codepoint, *encp);
11678         }
11679         else if (string_literal) {
11680             tokadd(codepoint);
11681         }
11682     }
11683 
11684     return codepoint;
11685 }
11686 
11687 #define ESCAPE_CONTROL 1
11688 #define ESCAPE_META    2
11689 
11690 static int
11691 parser_read_escape(struct parser_params *parser, int flags,
11692                    rb_encoding **encp)
11693 {
11694     int c;
11695     size_t numlen;
11696 
11697     switch (c = nextc()) {
11698       case '\\':        /* Backslash */
11699         return c;
11700 
11701       case 'n': /* newline */
11702         return '\n';
11703 
11704       case 't': /* horizontal tab */
11705         return '\t';
11706 
11707       case 'r': /* carriage-return */
11708         return '\r';
11709 
11710       case 'f': /* form-feed */
11711         return '\f';
11712 
11713       case 'v': /* vertical tab */
11714         return '\13';
11715 
11716       case 'a': /* alarm(bell) */
11717         return '\007';
11718 
11719       case 'e': /* escape */
11720         return 033;
11721 
11722       case '0': case '1': case '2': case '3': /* octal constant */
11723       case '4': case '5': case '6': case '7':
11724         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11725         pushback(c);
11726         c = scan_oct(lex_p, 3, &numlen);
11727         lex_p += numlen;
11728         return c;
11729 
11730       case 'x': /* hex constant */
11731         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11732         c = tok_hex(&numlen);
11733         if (numlen == 0) return 0;
11734         return c;
11735 
11736       case 'b': /* backspace */
11737         return '\010';
11738 
11739       case 's': /* space */
11740         return ' ';
11741 
11742       case 'M':
11743         if (flags & ESCAPE_META) goto eof;
11744         if ((c = nextc()) != '-') {
11745             pushback(c);
11746             goto eof;
11747         }
11748         if ((c = nextc()) == '\\') {
11749             if (peek('u')) goto eof;
11750             return read_escape(flags|ESCAPE_META, encp) | 0x80;
11751         }
11752         else if (c == -1 || !ISASCII(c)) goto eof;
11753         else {
11754             return ((c & 0xff) | 0x80);
11755         }
11756 
11757       case 'C':
11758         if ((c = nextc()) != '-') {
11759             pushback(c);
11760             goto eof;
11761         }
11762       case 'c':
11763         if (flags & ESCAPE_CONTROL) goto eof;
11764         if ((c = nextc())== '\\') {
11765             if (peek('u')) goto eof;
11766             c = read_escape(flags|ESCAPE_CONTROL, encp);
11767         }
11768         else if (c == '?')
11769             return 0177;
11770         else if (c == -1 || !ISASCII(c)) goto eof;
11771         return c & 0x9f;
11772 
11773       eof:
11774       case -1:
11775         yyerror("Invalid escape character syntax");
11776         return '\0';
11777 
11778       default:
11779         return c;
11780     }
11781 }
11782 
11783 static void
11784 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
11785 {
11786     int len = rb_enc_codelen(c, enc);
11787     rb_enc_mbcput(c, tokspace(len), enc);
11788 }
11789 
11790 static int
11791 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
11792 {
11793     int c;
11794     int flags = 0;
11795     size_t numlen;
11796 
11797   first:
11798     switch (c = nextc()) {
11799       case '\n':
11800         return 0;               /* just ignore */
11801 
11802       case '0': case '1': case '2': case '3': /* octal constant */
11803       case '4': case '5': case '6': case '7':
11804         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11805         {
11806             ruby_scan_oct(--lex_p, 3, &numlen);
11807             if (numlen == 0) goto eof;
11808             lex_p += numlen;
11809             tokcopy((int)numlen + 1);
11810         }
11811         return 0;
11812 
11813       case 'x': /* hex constant */
11814         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11815         {
11816             tok_hex(&numlen);
11817             if (numlen == 0) goto eof;
11818             tokcopy((int)numlen + 2);
11819         }
11820         return 0;
11821 
11822       case 'M':
11823         if (flags & ESCAPE_META) goto eof;
11824         if ((c = nextc()) != '-') {
11825             pushback(c);
11826             goto eof;
11827         }
11828         tokcopy(3);
11829         flags |= ESCAPE_META;
11830         goto escaped;
11831 
11832       case 'C':
11833         if (flags & ESCAPE_CONTROL) goto eof;
11834         if ((c = nextc()) != '-') {
11835             pushback(c);
11836             goto eof;
11837         }
11838         tokcopy(3);
11839         goto escaped;
11840 
11841       case 'c':
11842         if (flags & ESCAPE_CONTROL) goto eof;
11843         tokcopy(2);
11844         flags |= ESCAPE_CONTROL;
11845       escaped:
11846         if ((c = nextc()) == '\\') {
11847             goto first;
11848         }
11849         else if (c == -1) goto eof;
11850         tokadd(c);
11851         return 0;
11852 
11853       eof:
11854       case -1:
11855         yyerror("Invalid escape character syntax");
11856         return -1;
11857 
11858       default:
11859         tokadd('\\');
11860         tokadd(c);
11861     }
11862     return 0;
11863 }
11864 
11865 extern int rb_char_to_option_kcode(int c, int *option, int *kcode);
11866 
11867 static int
11868 parser_regx_options(struct parser_params *parser)
11869 {
11870     int kcode = 0;
11871     int kopt = 0;
11872     int options = 0;
11873     int c, opt, kc;
11874 
11875     newtok();
11876     while (c = nextc(), ISALPHA(c)) {
11877         if (c == 'o') {
11878             options |= RE_OPTION_ONCE;
11879         }
11880         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
11881             if (kc >= 0) {
11882                 if (kc != rb_ascii8bit_encindex()) kcode = c;
11883                 kopt = opt;
11884             }
11885             else {
11886                 options |= opt;
11887             }
11888         }
11889         else {
11890             tokadd(c);
11891         }
11892     }
11893     options |= kopt;
11894     pushback(c);
11895     if (toklen()) {
11896         tokfix();
11897         compile_error(PARSER_ARG "unknown regexp option%s - %s",
11898                       toklen() > 1 ? "s" : "", tok());
11899     }
11900     return options | RE_OPTION_ENCODING(kcode);
11901 }
11902 
11903 static void
11904 dispose_string(VALUE str)
11905 {
11906     /* TODO: should use another API? */
11907     if (RBASIC(str)->flags & RSTRING_NOEMBED)
11908         xfree(RSTRING_PTR(str));
11909     rb_gc_force_recycle(str);
11910 }
11911 
11912 static int
11913 parser_tokadd_mbchar(struct parser_params *parser, int c)
11914 {
11915     int len = parser_precise_mbclen();
11916     if (!MBCLEN_CHARFOUND_P(len)) {
11917         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
11918         return -1;
11919     }
11920     tokadd(c);
11921     lex_p += --len;
11922     if (len > 0) tokcopy(len);
11923     return c;
11924 }
11925 
11926 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, c)
11927 
11928 static int
11929 parser_tokadd_string(struct parser_params *parser,
11930                      int func, int term, int paren, long *nest,
11931                      rb_encoding **encp)
11932 {
11933     int c;
11934     int has_nonascii = 0;
11935     rb_encoding *enc = *encp;
11936     char *errbuf = 0;
11937     static const char mixed_msg[] = "%s mixed within %s source";
11938 
11939 #define mixed_error(enc1, enc2) if (!errbuf) {  \
11940         size_t len = sizeof(mixed_msg) - 4;     \
11941         len += strlen(rb_enc_name(enc1));       \
11942         len += strlen(rb_enc_name(enc2));       \
11943         errbuf = ALLOCA_N(char, len);           \
11944         snprintf(errbuf, len, mixed_msg,        \
11945                  rb_enc_name(enc1),             \
11946                  rb_enc_name(enc2));            \
11947         yyerror(errbuf);                        \
11948     }
11949 #define mixed_escape(beg, enc1, enc2) do {      \
11950         const char *pos = lex_p;                \
11951         lex_p = beg;                            \
11952         mixed_error(enc1, enc2);                \
11953         lex_p = pos;                            \
11954     } while (0)
11955 
11956     while ((c = nextc()) != -1) {
11957         if (paren && c == paren) {
11958             ++*nest;
11959         }
11960         else if (c == term) {
11961             if (!nest || !*nest) {
11962                 pushback(c);
11963                 break;
11964             }
11965             --*nest;
11966         }
11967         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
11968             int c2 = *lex_p;
11969             if (c2 == '$' || c2 == '@' || c2 == '{') {
11970                 pushback(c);
11971                 break;
11972             }
11973         }
11974         else if (c == '\\') {
11975             const char *beg = lex_p - 1;
11976             c = nextc();
11977             switch (c) {
11978               case '\n':
11979                 if (func & STR_FUNC_QWORDS) break;
11980                 if (func & STR_FUNC_EXPAND) continue;
11981                 tokadd('\\');
11982                 break;
11983 
11984               case '\\':
11985                 if (func & STR_FUNC_ESCAPE) tokadd(c);
11986                 break;
11987 
11988               case 'u':
11989                 if ((func & STR_FUNC_EXPAND) == 0) {
11990                     tokadd('\\');
11991                     break;
11992                 }
11993                 parser_tokadd_utf8(parser, &enc, 1,
11994                                    func & STR_FUNC_SYMBOL,
11995                                    func & STR_FUNC_REGEXP);
11996                 if (has_nonascii && enc != *encp) {
11997                     mixed_escape(beg, enc, *encp);
11998                 }
11999                 continue;
12000 
12001               default:
12002                 if (func & STR_FUNC_REGEXP) {
12003                     pushback(c);
12004                     if ((c = tokadd_escape(&enc)) < 0)
12005                         return -1;
12006                     if (has_nonascii && enc != *encp) {
12007                         mixed_escape(beg, enc, *encp);
12008                     }
12009                     continue;
12010                 }
12011                 else if (func & STR_FUNC_EXPAND) {
12012                     pushback(c);
12013                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
12014                     c = read_escape(0, &enc);
12015                 }
12016                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12017                     /* ignore backslashed spaces in %w */
12018                 }
12019                 else if (c != term && !(paren && c == paren)) {
12020                     tokadd('\\');
12021                     pushback(c);
12022                     continue;
12023                 }
12024             }
12025         }
12026         else if (!parser_isascii()) {
12027             has_nonascii = 1;
12028             if (enc != *encp) {
12029                 mixed_error(enc, *encp);
12030                 continue;
12031             }
12032             if (tokadd_mbchar(c) == -1) return -1;
12033             continue;
12034         }
12035         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12036             pushback(c);
12037             break;
12038         }
12039         if (c & 0x80) {
12040             has_nonascii = 1;
12041             if (enc != *encp) {
12042                 mixed_error(enc, *encp);
12043                 continue;
12044             }
12045         }
12046         tokadd(c);
12047     }
12048     *encp = enc;
12049     return c;
12050 }
12051 
12052 #define NEW_STRTERM(func, term, paren) \
12053         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12054 
12055 static int
12056 parser_parse_string(struct parser_params *parser, NODE *quote)
12057 {
12058     int func = (int)quote->nd_func;
12059     int term = nd_term(quote);
12060     int paren = nd_paren(quote);
12061     int c, space = 0;
12062     rb_encoding *enc = parser->enc;
12063 
12064     if (func == -1) return tSTRING_END;
12065     c = nextc();
12066     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12067         do {c = nextc();} while (ISSPACE(c));
12068         space = 1;
12069     }
12070     if (c == term && !quote->nd_nest) {
12071         if (func & STR_FUNC_QWORDS) {
12072             quote->nd_func = -1;
12073             return ' ';
12074         }
12075         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12076         set_yylval_num(regx_options());
12077         return tREGEXP_END;
12078     }
12079     if (space) {
12080         pushback(c);
12081         return ' ';
12082     }
12083     newtok();
12084     if ((func & STR_FUNC_EXPAND) && c == '#') {
12085         switch (c = nextc()) {
12086           case '$':
12087           case '@':
12088             pushback(c);
12089             return tSTRING_DVAR;
12090           case '{':
12091             return tSTRING_DBEG;
12092         }
12093         tokadd('#');
12094     }
12095     pushback(c);
12096     if (tokadd_string(func, term, paren, &quote->nd_nest,
12097                       &enc) == -1) {
12098         ruby_sourceline = nd_line(quote);
12099         if (func & STR_FUNC_REGEXP) {
12100             if (parser->eofp)
12101                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
12102             return tREGEXP_END;
12103         }
12104         else {
12105             if (parser->eofp)
12106                 compile_error(PARSER_ARG "unterminated string meets end of file");
12107             return tSTRING_END;
12108         }
12109     }
12110 
12111     tokfix();
12112     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12113 
12114 #ifdef RIPPER
12115     if (!NIL_P(parser->delayed)){
12116         ptrdiff_t len = lex_p - parser->tokp;
12117         if (len > 0) {
12118             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12119         }
12120         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12121         parser->tokp = lex_p;
12122     }
12123 #endif
12124 
12125     return tSTRING_CONTENT;
12126 }
12127 
12128 static int
12129 parser_heredoc_identifier(struct parser_params *parser)
12130 {
12131     int c = nextc(), term, func = 0;
12132     long len;
12133 
12134     if (c == '-') {
12135         c = nextc();
12136         func = STR_FUNC_INDENT;
12137     }
12138     switch (c) {
12139       case '\'':
12140         func |= str_squote; goto quoted;
12141       case '"':
12142         func |= str_dquote; goto quoted;
12143       case '`':
12144         func |= str_xquote;
12145       quoted:
12146         newtok();
12147         tokadd(func);
12148         term = c;
12149         while ((c = nextc()) != -1 && c != term) {
12150             if (tokadd_mbchar(c) == -1) return 0;
12151         }
12152         if (c == -1) {
12153             compile_error(PARSER_ARG "unterminated here document identifier");
12154             return 0;
12155         }
12156         break;
12157 
12158       default:
12159         if (!parser_is_identchar()) {
12160             pushback(c);
12161             if (func & STR_FUNC_INDENT) {
12162                 pushback('-');
12163             }
12164             return 0;
12165         }
12166         newtok();
12167         term = '"';
12168         tokadd(func |= str_dquote);
12169         do {
12170             if (tokadd_mbchar(c) == -1) return 0;
12171         } while ((c = nextc()) != -1 && parser_is_identchar());
12172         pushback(c);
12173         break;
12174     }
12175 
12176     tokfix();
12177 #ifdef RIPPER
12178     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12179 #endif
12180     len = lex_p - lex_pbeg;
12181     lex_goto_eol(parser);
12182     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12183                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12184                                   len,                          /* nd_nth */
12185                                   lex_lastline);                /* nd_orig */
12186     nd_set_line(lex_strterm, ruby_sourceline);
12187     ripper_flush(parser);
12188     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12189 }
12190 
12191 static void
12192 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12193 {
12194     VALUE line;
12195 
12196     line = here->nd_orig;
12197     lex_lastline = line;
12198     lex_pbeg = RSTRING_PTR(line);
12199     lex_pend = lex_pbeg + RSTRING_LEN(line);
12200     lex_p = lex_pbeg + here->nd_nth;
12201     heredoc_end = ruby_sourceline;
12202     ruby_sourceline = nd_line(here);
12203     dispose_string(here->nd_lit);
12204     rb_gc_force_recycle((VALUE)here);
12205     ripper_flush(parser);
12206 }
12207 
12208 static int
12209 parser_whole_match_p(struct parser_params *parser,
12210     const char *eos, long len, int indent)
12211 {
12212     const char *p = lex_pbeg;
12213     long n;
12214 
12215     if (indent) {
12216         while (*p && ISSPACE(*p)) p++;
12217     }
12218     n = lex_pend - (p + len);
12219     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12220     return strncmp(eos, p, len) == 0;
12221 }
12222 
12223 static int
12224 parser_here_document(struct parser_params *parser, NODE *here)
12225 {
12226     int c, func, indent = 0;
12227     const char *eos, *p, *pend;
12228     long len;
12229     VALUE str = 0;
12230     rb_encoding *enc = parser->enc;
12231 
12232     eos = RSTRING_PTR(here->nd_lit);
12233     len = RSTRING_LEN(here->nd_lit) - 1;
12234     indent = (func = *eos++) & STR_FUNC_INDENT;
12235 
12236     if ((c = nextc()) == -1) {
12237       error:
12238         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12239 #ifdef RIPPER
12240         if (NIL_P(parser->delayed)) {
12241             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12242         }
12243         else {
12244             if (str ||
12245                 ((len = lex_p - parser->tokp) > 0 &&
12246                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12247                 rb_str_append(parser->delayed, str);
12248             }
12249             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12250         }
12251         lex_goto_eol(parser);
12252 #endif
12253       restore:
12254         heredoc_restore(lex_strterm);
12255         lex_strterm = 0;
12256         return 0;
12257     }
12258     if (was_bol() && whole_match_p(eos, len, indent)) {
12259         heredoc_restore(lex_strterm);
12260         return tSTRING_END;
12261     }
12262 
12263     if (!(func & STR_FUNC_EXPAND)) {
12264         do {
12265             p = RSTRING_PTR(lex_lastline);
12266             pend = lex_pend;
12267             if (pend > p) {
12268                 switch (pend[-1]) {
12269                   case '\n':
12270                     if (--pend == p || pend[-1] != '\r') {
12271                         pend++;
12272                         break;
12273                     }
12274                   case '\r':
12275                     --pend;
12276                 }
12277             }
12278             if (str)
12279                 rb_str_cat(str, p, pend - p);
12280             else
12281                 str = STR_NEW(p, pend - p);
12282             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12283             lex_goto_eol(parser);
12284             if (nextc() == -1) {
12285                 if (str) dispose_string(str);
12286                 goto error;
12287             }
12288         } while (!whole_match_p(eos, len, indent));
12289     }
12290     else {
12291         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12292         newtok();
12293         if (c == '#') {
12294             switch (c = nextc()) {
12295               case '$':
12296               case '@':
12297                 pushback(c);
12298                 return tSTRING_DVAR;
12299               case '{':
12300                 return tSTRING_DBEG;
12301             }
12302             tokadd('#');
12303         }
12304         do {
12305             pushback(c);
12306             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12307                 if (parser->eofp) goto error;
12308                 goto restore;
12309             }
12310             if (c != '\n') {
12311                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12312                 return tSTRING_CONTENT;
12313             }
12314             tokadd(nextc());
12315             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12316             if ((c = nextc()) == -1) goto error;
12317         } while (!whole_match_p(eos, len, indent));
12318         str = STR_NEW3(tok(), toklen(), enc, func);
12319     }
12320 #ifdef RIPPER
12321     if (!NIL_P(parser->delayed))
12322         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12323     lex_goto_eol(parser);
12324     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12325 #endif
12326     heredoc_restore(lex_strterm);
12327     lex_strterm = NEW_STRTERM(-1, 0, 0);
12328     set_yylval_str(str);
12329     return tSTRING_CONTENT;
12330 }
12331 
12332 #include "lex.c"
12333 
12334 static void
12335 arg_ambiguous_gen(struct parser_params *parser)
12336 {
12337 #ifndef RIPPER
12338     rb_warning0("ambiguous first argument; put parentheses or even spaces");
12339 #else
12340     dispatch0(arg_ambiguous);
12341 #endif
12342 }
12343 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12344 
12345 static ID
12346 formal_argument_gen(struct parser_params *parser, ID lhs)
12347 {
12348 #ifndef RIPPER
12349     if (!is_local_id(lhs))
12350         yyerror("formal argument must be local variable");
12351 #endif
12352     shadowing_lvar(lhs);
12353     return lhs;
12354 }
12355 
12356 static int
12357 lvar_defined_gen(struct parser_params *parser, ID id)
12358 {
12359     return (dyna_in_block() && dvar_defined(id)) || local_id(id);
12360 }
12361 
12362 /* emacsen -*- hack */
12363 static long
12364 parser_encode_length(struct parser_params *parser, const char *name, long len)
12365 {
12366     long nlen;
12367 
12368     if (len > 5 && name[nlen = len - 5] == '-') {
12369         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12370             return nlen;
12371     }
12372     if (len > 4 && name[nlen = len - 4] == '-') {
12373         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12374             return nlen;
12375         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12376             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12377             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12378             return nlen;
12379     }
12380     return len;
12381 }
12382 
12383 static void
12384 parser_set_encode(struct parser_params *parser, const char *name)
12385 {
12386     int idx = rb_enc_find_index(name);
12387     rb_encoding *enc;
12388     VALUE excargs[3];
12389 
12390     if (idx < 0) {
12391         VALUE rb_make_backtrace(void);
12392         VALUE rb_make_exception(int, VALUE*);
12393 
12394         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12395       error:
12396         excargs[0] = rb_eArgError;
12397         excargs[2] = rb_make_backtrace();
12398         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12399         rb_exc_raise(rb_make_exception(3, excargs));
12400     }
12401     enc = rb_enc_from_index(idx);
12402     if (!rb_enc_asciicompat(enc)) {
12403         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12404         goto error;
12405     }
12406     parser->enc = enc;
12407 #ifndef RIPPER
12408     if (ruby_debug_lines) {
12409         long i, n = RARRAY_LEN(ruby_debug_lines);
12410         const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12411         for (i = 0; i < n; ++i) {
12412             rb_enc_associate_index(*p, idx);
12413         }
12414     }
12415 #endif
12416 }
12417 
12418 static int
12419 comment_at_top(struct parser_params *parser)
12420 {
12421     const char *p = lex_pbeg, *pend = lex_p - 1;
12422     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12423     while (p < pend) {
12424         if (!ISSPACE(*p)) return 0;
12425         p++;
12426     }
12427     return 1;
12428 }
12429 
12430 #ifndef RIPPER
12431 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12432 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12433 
12434 static void
12435 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12436 {
12437     if (!comment_at_top(parser)) {
12438         return;
12439     }
12440     parser_set_encode(parser, val);
12441 }
12442 
12443 struct magic_comment {
12444     const char *name;
12445     rb_magic_comment_setter_t func;
12446     rb_magic_comment_length_t length;
12447 };
12448 
12449 static const struct magic_comment magic_comments[] = {
12450     {"coding", magic_comment_encoding, parser_encode_length},
12451     {"encoding", magic_comment_encoding, parser_encode_length},
12452 };
12453 #endif
12454 
12455 static const char *
12456 magic_comment_marker(const char *str, long len)
12457 {
12458     long i = 2;
12459 
12460     while (i < len) {
12461         switch (str[i]) {
12462           case '-':
12463             if (str[i-1] == '*' && str[i-2] == '-') {
12464                 return str + i + 1;
12465             }
12466             i += 2;
12467             break;
12468           case '*':
12469             if (i + 1 >= len) return 0;
12470             if (str[i+1] != '-') {
12471                 i += 4;
12472             }
12473             else if (str[i-1] != '-') {
12474                 i += 2;
12475             }
12476             else {
12477                 return str + i + 2;
12478             }
12479             break;
12480           default:
12481             i += 3;
12482             break;
12483         }
12484     }
12485     return 0;
12486 }
12487 
12488 static int
12489 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12490 {
12491     VALUE name = 0, val = 0;
12492     const char *beg, *end, *vbeg, *vend;
12493 #define str_copy(_s, _p, _n) ((_s) \
12494         ? (rb_str_resize((_s), (_n)), \
12495            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12496         : ((_s) = STR_NEW((_p), (_n))))
12497 
12498     if (len <= 7) return FALSE;
12499     if (!(beg = magic_comment_marker(str, len))) return FALSE;
12500     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12501     str = beg;
12502     len = end - beg - 3;
12503 
12504     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12505     while (len > 0) {
12506 #ifndef RIPPER
12507         const struct magic_comment *p = magic_comments;
12508 #endif
12509         char *s;
12510         int i;
12511         long n = 0;
12512 
12513         for (; len > 0 && *str; str++, --len) {
12514             switch (*str) {
12515               case '\'': case '"': case ':': case ';':
12516                 continue;
12517             }
12518             if (!ISSPACE(*str)) break;
12519         }
12520         for (beg = str; len > 0; str++, --len) {
12521             switch (*str) {
12522               case '\'': case '"': case ':': case ';':
12523                 break;
12524               default:
12525                 if (ISSPACE(*str)) break;
12526                 continue;
12527             }
12528             break;
12529         }
12530         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12531         if (!len) break;
12532         if (*str != ':') continue;
12533 
12534         do str++; while (--len > 0 && ISSPACE(*str));
12535         if (!len) break;
12536         if (*str == '"') {
12537             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12538                 if (*str == '\\') {
12539                     --len;
12540                     ++str;
12541                 }
12542             }
12543             vend = str;
12544             if (len) {
12545                 --len;
12546                 ++str;
12547             }
12548         }
12549         else {
12550             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12551             vend = str;
12552         }
12553         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12554 
12555         n = end - beg;
12556         str_copy(name, beg, n);
12557         s = RSTRING_PTR(name);
12558         for (i = 0; i < n; ++i) {
12559             if (s[i] == '-') s[i] = '_';
12560         }
12561 #ifndef RIPPER
12562         do {
12563             if (STRNCASECMP(p->name, s, n) == 0) {
12564                 n = vend - vbeg;
12565                 if (p->length) {
12566                     n = (*p->length)(parser, vbeg, n);
12567                 }
12568                 str_copy(val, vbeg, n);
12569                 (*p->func)(parser, s, RSTRING_PTR(val));
12570                 break;
12571             }
12572         } while (++p < magic_comments + numberof(magic_comments));
12573 #else
12574         dispatch2(magic_comment, name, val);
12575 #endif
12576     }
12577 
12578     return TRUE;
12579 }
12580 
12581 static void
12582 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12583 {
12584     int sep = 0;
12585     const char *beg = str;
12586     VALUE s;
12587 
12588     for (;;) {
12589         if (send - str <= 6) return;
12590         switch (str[6]) {
12591           case 'C': case 'c': str += 6; continue;
12592           case 'O': case 'o': str += 5; continue;
12593           case 'D': case 'd': str += 4; continue;
12594           case 'I': case 'i': str += 3; continue;
12595           case 'N': case 'n': str += 2; continue;
12596           case 'G': case 'g': str += 1; continue;
12597           case '=': case ':':
12598             sep = 1;
12599             str += 6;
12600             break;
12601           default:
12602             str += 6;
12603             if (ISSPACE(*str)) break;
12604             continue;
12605         }
12606         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12607     }
12608     for (;;) {
12609         do {
12610             if (++str >= send) return;
12611         } while (ISSPACE(*str));
12612         if (sep) break;
12613         if (*str != '=' && *str != ':') return;
12614         sep = 1;
12615         str++;
12616     }
12617     beg = str;
12618     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12619     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12620     parser_set_encode(parser, RSTRING_PTR(s));
12621     rb_str_resize(s, 0);
12622 }
12623 
12624 static void
12625 parser_prepare(struct parser_params *parser)
12626 {
12627     int c = nextc();
12628     switch (c) {
12629       case '#':
12630         if (peek('!')) parser->has_shebang = 1;
12631         break;
12632       case 0xef:                /* UTF-8 BOM marker */
12633         if (lex_pend - lex_p >= 2 &&
12634             (unsigned char)lex_p[0] == 0xbb &&
12635             (unsigned char)lex_p[1] == 0xbf) {
12636             parser->enc = rb_utf8_encoding();
12637             lex_p += 2;
12638             lex_pbeg = lex_p;
12639             return;
12640         }
12641         break;
12642       case EOF:
12643         return;
12644     }
12645     pushback(c);
12646     parser->enc = rb_enc_get(lex_lastline);
12647 }
12648 
12649 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
12650 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
12651 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
12652 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12653 
12654 #ifndef RIPPER
12655 #define ambiguous_operator(op, syn) ( \
12656     rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12657     rb_warning0("even though it seems like "syn""))
12658 #else
12659 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12660 #endif
12661 #define warn_balanced(op, syn) \
12662     (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
12663      last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
12664      last_state != EXPR_ENDARG && \
12665      space_seen && !ISSPACE(c) && \
12666      (ambiguous_operator(op, syn), 0))
12667 
12668 static int
12669 parser_yylex(struct parser_params *parser)
12670 {
12671     register int c;
12672     int space_seen = 0;
12673     int cmd_state;
12674     enum lex_state_e last_state;
12675     rb_encoding *enc;
12676     int mb;
12677 #ifdef RIPPER
12678     int fallthru = FALSE;
12679 #endif
12680 
12681     if (lex_strterm) {
12682         int token;
12683         if (nd_type(lex_strterm) == NODE_HEREDOC) {
12684             token = here_document(lex_strterm);
12685             if (token == tSTRING_END) {
12686                 lex_strterm = 0;
12687                 lex_state = EXPR_END;
12688             }
12689         }
12690         else {
12691             token = parse_string(lex_strterm);
12692             if (token == tSTRING_END || token == tREGEXP_END) {
12693                 rb_gc_force_recycle((VALUE)lex_strterm);
12694                 lex_strterm = 0;
12695                 lex_state = EXPR_END;
12696             }
12697         }
12698         return token;
12699     }
12700     cmd_state = command_start;
12701     command_start = FALSE;
12702   retry:
12703     last_state = lex_state;
12704     switch (c = nextc()) {
12705       case '\0':                /* NUL */
12706       case '\004':              /* ^D */
12707       case '\032':              /* ^Z */
12708       case -1:                  /* end of script. */
12709         return 0;
12710 
12711         /* white spaces */
12712       case ' ': case '\t': case '\f': case '\r':
12713       case '\13': /* '\v' */
12714         space_seen = 1;
12715 #ifdef RIPPER
12716         while ((c = nextc())) {
12717             switch (c) {
12718               case ' ': case '\t': case '\f': case '\r':
12719               case '\13': /* '\v' */
12720                 break;
12721               default:
12722                 goto outofloop;
12723             }
12724         }
12725       outofloop:
12726         pushback(c);
12727         ripper_dispatch_scan_event(parser, tSP);
12728 #endif
12729         goto retry;
12730 
12731       case '#':         /* it's a comment */
12732         /* no magic_comment in shebang line */
12733         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
12734             if (comment_at_top(parser)) {
12735                 set_file_encoding(parser, lex_p, lex_pend);
12736             }
12737         }
12738         lex_p = lex_pend;
12739 #ifdef RIPPER
12740         ripper_dispatch_scan_event(parser, tCOMMENT);
12741         fallthru = TRUE;
12742 #endif
12743         /* fall through */
12744       case '\n':
12745         switch (lex_state) {
12746           case EXPR_BEG:
12747           case EXPR_FNAME:
12748           case EXPR_DOT:
12749           case EXPR_CLASS:
12750           case EXPR_VALUE:
12751 #ifdef RIPPER
12752             if (!fallthru) {
12753                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
12754             }
12755             fallthru = FALSE;
12756 #endif
12757             goto retry;
12758           default:
12759             break;
12760         }
12761         while ((c = nextc())) {
12762             switch (c) {
12763               case ' ': case '\t': case '\f': case '\r':
12764               case '\13': /* '\v' */
12765                 space_seen = 1;
12766                 break;
12767               case '.': {
12768                   if ((c = nextc()) != '.') {
12769                       pushback(c);
12770                       pushback('.');
12771                       goto retry;
12772                   }
12773               }
12774               default:
12775                 --ruby_sourceline;
12776                 lex_nextline = lex_lastline;
12777               case -1:          /* EOF no decrement*/
12778                 lex_goto_eol(parser);
12779 #ifdef RIPPER
12780                 if (c != -1) {
12781                     parser->tokp = lex_p;
12782                 }
12783 #endif
12784                 goto normal_newline;
12785             }
12786         }
12787       normal_newline:
12788         command_start = TRUE;
12789         lex_state = EXPR_BEG;
12790         return '\n';
12791 
12792       case '*':
12793         if ((c = nextc()) == '*') {
12794             if ((c = nextc()) == '=') {
12795                 set_yylval_id(tPOW);
12796                 lex_state = EXPR_BEG;
12797                 return tOP_ASGN;
12798             }
12799             pushback(c);
12800             c = tPOW;
12801         }
12802         else {
12803             if (c == '=') {
12804                 set_yylval_id('*');
12805                 lex_state = EXPR_BEG;
12806                 return tOP_ASGN;
12807             }
12808             pushback(c);
12809             if (IS_SPCARG(c)) {
12810                 rb_warning0("`*' interpreted as argument prefix");
12811                 c = tSTAR;
12812             }
12813             else if (IS_BEG()) {
12814                 c = tSTAR;
12815             }
12816             else {
12817                 warn_balanced("*", "argument prefix");
12818                 c = '*';
12819             }
12820         }
12821         switch (lex_state) {
12822           case EXPR_FNAME: case EXPR_DOT:
12823             lex_state = EXPR_ARG; break;
12824           default:
12825             lex_state = EXPR_BEG; break;
12826         }
12827         return c;
12828 
12829       case '!':
12830         c = nextc();
12831         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
12832             lex_state = EXPR_ARG;
12833             if (c == '@') {
12834                 return '!';
12835             }
12836         }
12837         else {
12838             lex_state = EXPR_BEG;
12839         }
12840         if (c == '=') {
12841             return tNEQ;
12842         }
12843         if (c == '~') {
12844             return tNMATCH;
12845         }
12846         pushback(c);
12847         return '!';
12848 
12849       case '=':
12850         if (was_bol()) {
12851             /* skip embedded rd document */
12852             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
12853 #ifdef RIPPER
12854                 int first_p = TRUE;
12855 
12856                 lex_goto_eol(parser);
12857                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
12858 #endif
12859                 for (;;) {
12860                     lex_goto_eol(parser);
12861 #ifdef RIPPER
12862                     if (!first_p) {
12863                         ripper_dispatch_scan_event(parser, tEMBDOC);
12864                     }
12865                     first_p = FALSE;
12866 #endif
12867                     c = nextc();
12868                     if (c == -1) {
12869                         compile_error(PARSER_ARG "embedded document meets end of file");
12870                         return 0;
12871                     }
12872                     if (c != '=') continue;
12873                     if (strncmp(lex_p, "end", 3) == 0 &&
12874                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
12875                         break;
12876                     }
12877                 }
12878                 lex_goto_eol(parser);
12879 #ifdef RIPPER
12880                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
12881 #endif
12882                 goto retry;
12883             }
12884         }
12885 
12886         switch (lex_state) {
12887           case EXPR_FNAME: case EXPR_DOT:
12888             lex_state = EXPR_ARG; break;
12889           default:
12890             lex_state = EXPR_BEG; break;
12891         }
12892         if ((c = nextc()) == '=') {
12893             if ((c = nextc()) == '=') {
12894                 return tEQQ;
12895             }
12896             pushback(c);
12897             return tEQ;
12898         }
12899         if (c == '~') {
12900             return tMATCH;
12901         }
12902         else if (c == '>') {
12903             return tASSOC;
12904         }
12905         pushback(c);
12906         return '=';
12907 
12908       case '<':
12909         last_state = lex_state;
12910         c = nextc();
12911         if (c == '<' &&
12912             lex_state != EXPR_DOT &&
12913             lex_state != EXPR_CLASS &&
12914             !IS_END() &&
12915             (!IS_ARG() || space_seen)) {
12916             int token = heredoc_identifier();
12917             if (token) return token;
12918         }
12919         switch (lex_state) {
12920           case EXPR_FNAME: case EXPR_DOT:
12921             lex_state = EXPR_ARG; break;
12922           default:
12923             lex_state = EXPR_BEG; break;
12924         }
12925         if (c == '=') {
12926             if ((c = nextc()) == '>') {
12927                 return tCMP;
12928             }
12929             pushback(c);
12930             return tLEQ;
12931         }
12932         if (c == '<') {
12933             if ((c = nextc()) == '=') {
12934                 set_yylval_id(tLSHFT);
12935                 lex_state = EXPR_BEG;
12936                 return tOP_ASGN;
12937             }
12938             pushback(c);
12939             warn_balanced("<<", "here document");
12940             return tLSHFT;
12941         }
12942         pushback(c);
12943         return '<';
12944 
12945       case '>':
12946         switch (lex_state) {
12947           case EXPR_FNAME: case EXPR_DOT:
12948             lex_state = EXPR_ARG; break;
12949           default:
12950             lex_state = EXPR_BEG; break;
12951         }
12952         if ((c = nextc()) == '=') {
12953             return tGEQ;
12954         }
12955         if (c == '>') {
12956             if ((c = nextc()) == '=') {
12957                 set_yylval_id(tRSHFT);
12958                 lex_state = EXPR_BEG;
12959                 return tOP_ASGN;
12960             }
12961             pushback(c);
12962             return tRSHFT;
12963         }
12964         pushback(c);
12965         return '>';
12966 
12967       case '"':
12968         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
12969         return tSTRING_BEG;
12970 
12971       case '`':
12972         if (lex_state == EXPR_FNAME) {
12973             lex_state = EXPR_ENDFN;
12974             return c;
12975         }
12976         if (lex_state == EXPR_DOT) {
12977             if (cmd_state)
12978                 lex_state = EXPR_CMDARG;
12979             else
12980                 lex_state = EXPR_ARG;
12981             return c;
12982         }
12983         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
12984         return tXSTRING_BEG;
12985 
12986       case '\'':
12987         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
12988         return tSTRING_BEG;
12989 
12990       case '?':
12991         if (IS_END()) {
12992             lex_state = EXPR_VALUE;
12993             return '?';
12994         }
12995         c = nextc();
12996         if (c == -1) {
12997             compile_error(PARSER_ARG "incomplete character syntax");
12998             return 0;
12999         }
13000         if (rb_enc_isspace(c, parser->enc)) {
13001             if (!IS_ARG()) {
13002                 int c2 = 0;
13003                 switch (c) {
13004                   case ' ':
13005                     c2 = 's';
13006                     break;
13007                   case '\n':
13008                     c2 = 'n';
13009                     break;
13010                   case '\t':
13011                     c2 = 't';
13012                     break;
13013                   case '\v':
13014                     c2 = 'v';
13015                     break;
13016                   case '\r':
13017                     c2 = 'r';
13018                     break;
13019                   case '\f':
13020                     c2 = 'f';
13021                     break;
13022                 }
13023                 if (c2) {
13024                     rb_warnI("invalid character syntax; use ?\\%c", c2);
13025                 }
13026             }
13027           ternary:
13028             pushback(c);
13029             lex_state = EXPR_VALUE;
13030             return '?';
13031         }
13032         newtok();
13033         enc = parser->enc;
13034         if (!parser_isascii()) {
13035             if (tokadd_mbchar(c) == -1) return 0;
13036         }
13037         else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
13038                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
13039             goto ternary;
13040         }
13041         else if (c == '\\') {
13042             if (peek('u')) {
13043                 nextc();
13044                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13045                 if (0x80 <= c) {
13046                     tokaddmbc(c, enc);
13047                 }
13048                 else {
13049                     tokadd(c);
13050                 }
13051             }
13052             else {
13053                 c = read_escape(0, &enc);
13054                 tokadd(c);
13055             }
13056         }
13057         else {
13058             tokadd(c);
13059         }
13060         tokfix();
13061         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13062         lex_state = EXPR_END;
13063         return tCHAR;
13064 
13065       case '&':
13066         if ((c = nextc()) == '&') {
13067             lex_state = EXPR_BEG;
13068             if ((c = nextc()) == '=') {
13069                 set_yylval_id(tANDOP);
13070                 lex_state = EXPR_BEG;
13071                 return tOP_ASGN;
13072             }
13073             pushback(c);
13074             return tANDOP;
13075         }
13076         else if (c == '=') {
13077             set_yylval_id('&');
13078             lex_state = EXPR_BEG;
13079             return tOP_ASGN;
13080         }
13081         pushback(c);
13082         if (IS_SPCARG(c)) {
13083             rb_warning0("`&' interpreted as argument prefix");
13084             c = tAMPER;
13085         }
13086         else if (IS_BEG()) {
13087             c = tAMPER;
13088         }
13089         else {
13090             warn_balanced("&", "argument prefix");
13091             c = '&';
13092         }
13093         switch (lex_state) {
13094           case EXPR_FNAME: case EXPR_DOT:
13095             lex_state = EXPR_ARG; break;
13096           default:
13097             lex_state = EXPR_BEG;
13098         }
13099         return c;
13100 
13101       case '|':
13102         if ((c = nextc()) == '|') {
13103             lex_state = EXPR_BEG;
13104             if ((c = nextc()) == '=') {
13105                 set_yylval_id(tOROP);
13106                 lex_state = EXPR_BEG;
13107                 return tOP_ASGN;
13108             }
13109             pushback(c);
13110             return tOROP;
13111         }
13112         if (c == '=') {
13113             set_yylval_id('|');
13114             lex_state = EXPR_BEG;
13115             return tOP_ASGN;
13116         }
13117         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13118             lex_state = EXPR_ARG;
13119         }
13120         else {
13121             lex_state = EXPR_BEG;
13122         }
13123         pushback(c);
13124         return '|';
13125 
13126       case '+':
13127         c = nextc();
13128         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13129             lex_state = EXPR_ARG;
13130             if (c == '@') {
13131                 return tUPLUS;
13132             }
13133             pushback(c);
13134             return '+';
13135         }
13136         if (c == '=') {
13137             set_yylval_id('+');
13138             lex_state = EXPR_BEG;
13139             return tOP_ASGN;
13140         }
13141         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13142             lex_state = EXPR_BEG;
13143             pushback(c);
13144             if (c != -1 && ISDIGIT(c)) {
13145                 c = '+';
13146                 goto start_num;
13147             }
13148             return tUPLUS;
13149         }
13150         lex_state = EXPR_BEG;
13151         pushback(c);
13152         warn_balanced("+", "unary operator");
13153         return '+';
13154 
13155       case '-':
13156         c = nextc();
13157         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13158             lex_state = EXPR_ARG;
13159             if (c == '@') {
13160                 return tUMINUS;
13161             }
13162             pushback(c);
13163             return '-';
13164         }
13165         if (c == '=') {
13166             set_yylval_id('-');
13167             lex_state = EXPR_BEG;
13168             return tOP_ASGN;
13169         }
13170         if (c == '>') {
13171             lex_state = EXPR_ARG;
13172             return tLAMBDA;
13173         }
13174         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13175             lex_state = EXPR_BEG;
13176             pushback(c);
13177             if (c != -1 && ISDIGIT(c)) {
13178                 return tUMINUS_NUM;
13179             }
13180             return tUMINUS;
13181         }
13182         lex_state = EXPR_BEG;
13183         pushback(c);
13184         warn_balanced("-", "unary operator");
13185         return '-';
13186 
13187       case '.':
13188         lex_state = EXPR_BEG;
13189         if ((c = nextc()) == '.') {
13190             if ((c = nextc()) == '.') {
13191                 return tDOT3;
13192             }
13193             pushback(c);
13194             return tDOT2;
13195         }
13196         pushback(c);
13197         if (c != -1 && ISDIGIT(c)) {
13198             yyerror("no .<digit> floating literal anymore; put 0 before dot");
13199         }
13200         lex_state = EXPR_DOT;
13201         return '.';
13202 
13203       start_num:
13204       case '0': case '1': case '2': case '3': case '4':
13205       case '5': case '6': case '7': case '8': case '9':
13206         {
13207             int is_float, seen_point, seen_e, nondigit;
13208 
13209             is_float = seen_point = seen_e = nondigit = 0;
13210             lex_state = EXPR_END;
13211             newtok();
13212             if (c == '-' || c == '+') {
13213                 tokadd(c);
13214                 c = nextc();
13215             }
13216             if (c == '0') {
13217 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13218                 int start = toklen();
13219                 c = nextc();
13220                 if (c == 'x' || c == 'X') {
13221                     /* hexadecimal */
13222                     c = nextc();
13223                     if (c != -1 && ISXDIGIT(c)) {
13224                         do {
13225                             if (c == '_') {
13226                                 if (nondigit) break;
13227                                 nondigit = c;
13228                                 continue;
13229                             }
13230                             if (!ISXDIGIT(c)) break;
13231                             nondigit = 0;
13232                             tokadd(c);
13233                         } while ((c = nextc()) != -1);
13234                     }
13235                     pushback(c);
13236                     tokfix();
13237                     if (toklen() == start) {
13238                         no_digits();
13239                     }
13240                     else if (nondigit) goto trailing_uc;
13241                     set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
13242                     return tINTEGER;
13243                 }
13244                 if (c == 'b' || c == 'B') {
13245                     /* binary */
13246                     c = nextc();
13247                     if (c == '0' || c == '1') {
13248                         do {
13249                             if (c == '_') {
13250                                 if (nondigit) break;
13251                                 nondigit = c;
13252                                 continue;
13253                             }
13254                             if (c != '0' && c != '1') break;
13255                             nondigit = 0;
13256                             tokadd(c);
13257                         } while ((c = nextc()) != -1);
13258                     }
13259                     pushback(c);
13260                     tokfix();
13261                     if (toklen() == start) {
13262                         no_digits();
13263                     }
13264                     else if (nondigit) goto trailing_uc;
13265                     set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
13266                     return tINTEGER;
13267                 }
13268                 if (c == 'd' || c == 'D') {
13269                     /* decimal */
13270                     c = nextc();
13271                     if (c != -1 && ISDIGIT(c)) {
13272                         do {
13273                             if (c == '_') {
13274                                 if (nondigit) break;
13275                                 nondigit = c;
13276                                 continue;
13277                             }
13278                             if (!ISDIGIT(c)) break;
13279                             nondigit = 0;
13280                             tokadd(c);
13281                         } while ((c = nextc()) != -1);
13282                     }
13283                     pushback(c);
13284                     tokfix();
13285                     if (toklen() == start) {
13286                         no_digits();
13287                     }
13288                     else if (nondigit) goto trailing_uc;
13289                     set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13290                     return tINTEGER;
13291                 }
13292                 if (c == '_') {
13293                     /* 0_0 */
13294                     goto octal_number;
13295                 }
13296                 if (c == 'o' || c == 'O') {
13297                     /* prefixed octal */
13298                     c = nextc();
13299                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
13300                         no_digits();
13301                     }
13302                 }
13303                 if (c >= '0' && c <= '7') {
13304                     /* octal */
13305                   octal_number:
13306                     do {
13307                         if (c == '_') {
13308                             if (nondigit) break;
13309                             nondigit = c;
13310                             continue;
13311                         }
13312                         if (c < '0' || c > '9') break;
13313                         if (c > '7') goto invalid_octal;
13314                         nondigit = 0;
13315                         tokadd(c);
13316                     } while ((c = nextc()) != -1);
13317                     if (toklen() > start) {
13318                         pushback(c);
13319                         tokfix();
13320                         if (nondigit) goto trailing_uc;
13321                         set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
13322                         return tINTEGER;
13323                     }
13324                     if (nondigit) {
13325                         pushback(c);
13326                         goto trailing_uc;
13327                     }
13328                 }
13329                 if (c > '7' && c <= '9') {
13330                   invalid_octal:
13331                     yyerror("Invalid octal digit");
13332                 }
13333                 else if (c == '.' || c == 'e' || c == 'E') {
13334                     tokadd('0');
13335                 }
13336                 else {
13337                     pushback(c);
13338                     set_yylval_literal(INT2FIX(0));
13339                     return tINTEGER;
13340                 }
13341             }
13342 
13343             for (;;) {
13344                 switch (c) {
13345                   case '0': case '1': case '2': case '3': case '4':
13346                   case '5': case '6': case '7': case '8': case '9':
13347                     nondigit = 0;
13348                     tokadd(c);
13349                     break;
13350 
13351                   case '.':
13352                     if (nondigit) goto trailing_uc;
13353                     if (seen_point || seen_e) {
13354                         goto decode_num;
13355                     }
13356                     else {
13357                         int c0 = nextc();
13358                         if (c0 == -1 || !ISDIGIT(c0)) {
13359                             pushback(c0);
13360                             goto decode_num;
13361                         }
13362                         c = c0;
13363                     }
13364                     tokadd('.');
13365                     tokadd(c);
13366                     is_float++;
13367                     seen_point++;
13368                     nondigit = 0;
13369                     break;
13370 
13371                   case 'e':
13372                   case 'E':
13373                     if (nondigit) {
13374                         pushback(c);
13375                         c = nondigit;
13376                         goto decode_num;
13377                     }
13378                     if (seen_e) {
13379                         goto decode_num;
13380                     }
13381                     tokadd(c);
13382                     seen_e++;
13383                     is_float++;
13384                     nondigit = c;
13385                     c = nextc();
13386                     if (c != '-' && c != '+') continue;
13387                     tokadd(c);
13388                     nondigit = c;
13389                     break;
13390 
13391                   case '_':     /* `_' in number just ignored */
13392                     if (nondigit) goto decode_num;
13393                     nondigit = c;
13394                     break;
13395 
13396                   default:
13397                     goto decode_num;
13398                 }
13399                 c = nextc();
13400             }
13401 
13402           decode_num:
13403             pushback(c);
13404             if (nondigit) {
13405                 char tmp[30];
13406               trailing_uc:
13407                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13408                 yyerror(tmp);
13409             }
13410             tokfix();
13411             if (is_float) {
13412                 double d = strtod(tok(), 0);
13413                 if (errno == ERANGE) {
13414                     rb_warningS("Float %s out of range", tok());
13415                     errno = 0;
13416                 }
13417                 set_yylval_literal(DBL2NUM(d));
13418                 return tFLOAT;
13419             }
13420             set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13421             return tINTEGER;
13422         }
13423 
13424       case ')':
13425       case ']':
13426         paren_nest--;
13427       case '}':
13428         COND_LEXPOP();
13429         CMDARG_LEXPOP();
13430         if (c == ')')
13431             lex_state = EXPR_ENDFN;
13432         else
13433             lex_state = EXPR_ENDARG;
13434         return c;
13435 
13436       case ':':
13437         c = nextc();
13438         if (c == ':') {
13439             if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
13440                 lex_state = EXPR_BEG;
13441                 return tCOLON3;
13442             }
13443             lex_state = EXPR_DOT;
13444             return tCOLON2;
13445         }
13446         if (IS_END() || ISSPACE(c)) {
13447             pushback(c);
13448             warn_balanced(":", "symbol literal");
13449             lex_state = EXPR_BEG;
13450             return ':';
13451         }
13452         switch (c) {
13453           case '\'':
13454             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13455             break;
13456           case '"':
13457             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13458             break;
13459           default:
13460             pushback(c);
13461             break;
13462         }
13463         lex_state = EXPR_FNAME;
13464         return tSYMBEG;
13465 
13466       case '/':
13467         if (IS_BEG()) {
13468             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13469             return tREGEXP_BEG;
13470         }
13471         if ((c = nextc()) == '=') {
13472             set_yylval_id('/');
13473             lex_state = EXPR_BEG;
13474             return tOP_ASGN;
13475         }
13476         pushback(c);
13477         if (IS_SPCARG(c)) {
13478             arg_ambiguous();
13479             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13480             return tREGEXP_BEG;
13481         }
13482         switch (lex_state) {
13483           case EXPR_FNAME: case EXPR_DOT:
13484             lex_state = EXPR_ARG; break;
13485           default:
13486             lex_state = EXPR_BEG; break;
13487         }
13488         warn_balanced("/", "regexp literal");
13489         return '/';
13490 
13491       case '^':
13492         if ((c = nextc()) == '=') {
13493             set_yylval_id('^');
13494             lex_state = EXPR_BEG;
13495             return tOP_ASGN;
13496         }
13497         switch (lex_state) {
13498           case EXPR_FNAME: case EXPR_DOT:
13499             lex_state = EXPR_ARG; break;
13500           default:
13501             lex_state = EXPR_BEG; break;
13502         }
13503         pushback(c);
13504         return '^';
13505 
13506       case ';':
13507         lex_state = EXPR_BEG;
13508         command_start = TRUE;
13509         return ';';
13510 
13511       case ',':
13512         lex_state = EXPR_BEG;
13513         return ',';
13514 
13515       case '~':
13516         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13517             if ((c = nextc()) != '@') {
13518                 pushback(c);
13519             }
13520             lex_state = EXPR_ARG;
13521         }
13522         else {
13523             lex_state = EXPR_BEG;
13524         }
13525         return '~';
13526 
13527       case '(':
13528         if (IS_BEG()) {
13529             c = tLPAREN;
13530         }
13531         else if (IS_SPCARG(-1)) {
13532             c = tLPAREN_ARG;
13533         }
13534         paren_nest++;
13535         COND_PUSH(0);
13536         CMDARG_PUSH(0);
13537         lex_state = EXPR_BEG;
13538         return c;
13539 
13540       case '[':
13541         paren_nest++;
13542         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13543             lex_state = EXPR_ARG;
13544             if ((c = nextc()) == ']') {
13545                 if ((c = nextc()) == '=') {
13546                     return tASET;
13547                 }
13548                 pushback(c);
13549                 return tAREF;
13550             }
13551             pushback(c);
13552             return '[';
13553         }
13554         else if (IS_BEG()) {
13555             c = tLBRACK;
13556         }
13557         else if (IS_ARG() && space_seen) {
13558             c = tLBRACK;
13559         }
13560         lex_state = EXPR_BEG;
13561         COND_PUSH(0);
13562         CMDARG_PUSH(0);
13563         return c;
13564 
13565       case '{':
13566         if (lpar_beg && lpar_beg == paren_nest) {
13567             lex_state = EXPR_BEG;
13568             lpar_beg = 0;
13569             --paren_nest;
13570             COND_PUSH(0);
13571             CMDARG_PUSH(0);
13572             return tLAMBEG;
13573         }
13574         if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
13575             c = '{';          /* block (primary) */
13576         else if (lex_state == EXPR_ENDARG)
13577             c = tLBRACE_ARG;  /* block (expr) */
13578         else
13579             c = tLBRACE;      /* hash */
13580         COND_PUSH(0);
13581         CMDARG_PUSH(0);
13582         lex_state = EXPR_BEG;
13583         if (c != tLBRACE) command_start = TRUE;
13584         return c;
13585 
13586       case '\\':
13587         c = nextc();
13588         if (c == '\n') {
13589             space_seen = 1;
13590 #ifdef RIPPER
13591             ripper_dispatch_scan_event(parser, tSP);
13592 #endif
13593             goto retry; /* skip \\n */
13594         }
13595         pushback(c);
13596         return '\\';
13597 
13598       case '%':
13599         if (IS_BEG()) {
13600             int term;
13601             int paren;
13602 
13603             c = nextc();
13604           quotation:
13605             if (c == -1 || !ISALNUM(c)) {
13606                 term = c;
13607                 c = 'Q';
13608             }
13609             else {
13610                 term = nextc();
13611                 if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
13612                     yyerror("unknown type of %string");
13613                     return 0;
13614                 }
13615             }
13616             if (c == -1 || term == -1) {
13617                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13618                 return 0;
13619             }
13620             paren = term;
13621             if (term == '(') term = ')';
13622             else if (term == '[') term = ']';
13623             else if (term == '{') term = '}';
13624             else if (term == '<') term = '>';
13625             else paren = 0;
13626 
13627             switch (c) {
13628               case 'Q':
13629                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13630                 return tSTRING_BEG;
13631 
13632               case 'q':
13633                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
13634                 return tSTRING_BEG;
13635 
13636               case 'W':
13637                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
13638                 do {c = nextc();} while (ISSPACE(c));
13639                 pushback(c);
13640                 return tWORDS_BEG;
13641 
13642               case 'w':
13643                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
13644                 do {c = nextc();} while (ISSPACE(c));
13645                 pushback(c);
13646                 return tQWORDS_BEG;
13647 
13648               case 'x':
13649                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13650                 return tXSTRING_BEG;
13651 
13652               case 'r':
13653                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13654                 return tREGEXP_BEG;
13655 
13656               case 's':
13657                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13658                 lex_state = EXPR_FNAME;
13659                 return tSYMBEG;
13660 
13661               default:
13662                 yyerror("unknown type of %string");
13663                 return 0;
13664             }
13665         }
13666         if ((c = nextc()) == '=') {
13667             set_yylval_id('%');
13668             lex_state = EXPR_BEG;
13669             return tOP_ASGN;
13670         }
13671         if (IS_SPCARG(c)) {
13672             goto quotation;
13673         }
13674         switch (lex_state) {
13675           case EXPR_FNAME: case EXPR_DOT:
13676             lex_state = EXPR_ARG; break;
13677           default:
13678             lex_state = EXPR_BEG; break;
13679         }
13680         pushback(c);
13681         warn_balanced("%%", "string literal");
13682         return '%';
13683 
13684       case '$':
13685         lex_state = EXPR_END;
13686         newtok();
13687         c = nextc();
13688         switch (c) {
13689           case '_':             /* $_: last read line string */
13690             c = nextc();
13691             if (parser_is_identchar()) {
13692                 tokadd('$');
13693                 tokadd('_');
13694                 break;
13695             }
13696             pushback(c);
13697             c = '_';
13698             /* fall through */
13699           case '~':             /* $~: match-data */
13700           case '*':             /* $*: argv */
13701           case '$':             /* $$: pid */
13702           case '?':             /* $?: last status */
13703           case '!':             /* $!: error string */
13704           case '@':             /* $@: error position */
13705           case '/':             /* $/: input record separator */
13706           case '\\':            /* $\: output record separator */
13707           case ';':             /* $;: field separator */
13708           case ',':             /* $,: output field separator */
13709           case '.':             /* $.: last read line number */
13710           case '=':             /* $=: ignorecase */
13711           case ':':             /* $:: load path */
13712           case '<':             /* $<: reading filename */
13713           case '>':             /* $>: default output handle */
13714           case '\"':            /* $": already loaded files */
13715             tokadd('$');
13716             tokadd(c);
13717             tokfix();
13718             set_yylval_name(rb_intern(tok()));
13719             return tGVAR;
13720 
13721           case '-':
13722             tokadd('$');
13723             tokadd(c);
13724             c = nextc();
13725             if (parser_is_identchar()) {
13726                 if (tokadd_mbchar(c) == -1) return 0;
13727             }
13728             else {
13729                 pushback(c);
13730             }
13731           gvar:
13732             tokfix();
13733             set_yylval_name(rb_intern(tok()));
13734             return tGVAR;
13735 
13736           case '&':             /* $&: last match */
13737           case '`':             /* $`: string before last match */
13738           case '\'':            /* $': string after last match */
13739           case '+':             /* $+: string matches last paren. */
13740             if (last_state == EXPR_FNAME) {
13741                 tokadd('$');
13742                 tokadd(c);
13743                 goto gvar;
13744             }
13745             set_yylval_node(NEW_BACK_REF(c));
13746             return tBACK_REF;
13747 
13748           case '1': case '2': case '3':
13749           case '4': case '5': case '6':
13750           case '7': case '8': case '9':
13751             tokadd('$');
13752             do {
13753                 tokadd(c);
13754                 c = nextc();
13755             } while (c != -1 && ISDIGIT(c));
13756             pushback(c);
13757             if (last_state == EXPR_FNAME) goto gvar;
13758             tokfix();
13759             set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
13760             return tNTH_REF;
13761 
13762           default:
13763             if (!parser_is_identchar()) {
13764                 pushback(c);
13765                 return '$';
13766             }
13767           case '0':
13768             tokadd('$');
13769         }
13770         break;
13771 
13772       case '@':
13773         c = nextc();
13774         newtok();
13775         tokadd('@');
13776         if (c == '@') {
13777             tokadd('@');
13778             c = nextc();
13779         }
13780         if (c != -1 && ISDIGIT(c)) {
13781             if (tokidx == 1) {
13782                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
13783             }
13784             else {
13785                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
13786             }
13787             return 0;
13788         }
13789         if (!parser_is_identchar()) {
13790             pushback(c);
13791             return '@';
13792         }
13793         break;
13794 
13795       case '_':
13796         if (was_bol() && whole_match_p("__END__", 7, 0)) {
13797             ruby__end__seen = 1;
13798             parser->eofp = Qtrue;
13799 #ifndef RIPPER
13800             return -1;
13801 #else
13802             lex_goto_eol(parser);
13803             ripper_dispatch_scan_event(parser, k__END__);
13804             return 0;
13805 #endif
13806         }
13807         newtok();
13808         break;
13809 
13810       default:
13811         if (!parser_is_identchar()) {
13812             rb_compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
13813             goto retry;
13814         }
13815 
13816         newtok();
13817         break;
13818     }
13819 
13820     mb = ENC_CODERANGE_7BIT;
13821     do {
13822         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
13823         if (tokadd_mbchar(c) == -1) return 0;
13824         c = nextc();
13825     } while (parser_is_identchar());
13826     switch (tok()[0]) {
13827       case '@': case '$':
13828         pushback(c);
13829         break;
13830       default:
13831         if ((c == '!' || c == '?') && !peek('=')) {
13832             tokadd(c);
13833         }
13834         else {
13835             pushback(c);
13836         }
13837     }
13838     tokfix();
13839 
13840     {
13841         int result = 0;
13842 
13843         last_state = lex_state;
13844         switch (tok()[0]) {
13845           case '$':
13846             lex_state = EXPR_END;
13847             result = tGVAR;
13848             break;
13849           case '@':
13850             lex_state = EXPR_END;
13851             if (tok()[1] == '@')
13852                 result = tCVAR;
13853             else
13854                 result = tIVAR;
13855             break;
13856 
13857           default:
13858             if (toklast() == '!' || toklast() == '?') {
13859                 result = tFID;
13860             }
13861             else {
13862                 if (lex_state == EXPR_FNAME) {
13863                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
13864                         (!peek('=') || (lex_p + 1 < lex_pend && lex_p[1] == '>'))) {
13865                         result = tIDENTIFIER;
13866                         tokadd(c);
13867                         tokfix();
13868                     }
13869                     else {
13870                         pushback(c);
13871                     }
13872                 }
13873                 if (result == 0 && ISUPPER(tok()[0])) {
13874                     result = tCONSTANT;
13875                 }
13876                 else {
13877                     result = tIDENTIFIER;
13878                 }
13879             }
13880 
13881             if ((lex_state == EXPR_BEG && !cmd_state) ||
13882                 IS_ARG()) {
13883                 if (peek(':') && !(lex_p + 1 < lex_pend && lex_p[1] == ':')) {
13884                     lex_state = EXPR_BEG;
13885                     nextc();
13886                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
13887                     return tLABEL;
13888                 }
13889             }
13890             if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
13891                 const struct kwtable *kw;
13892 
13893                 /* See if it is a reserved word.  */
13894                 kw = rb_reserved_word(tok(), toklen());
13895                 if (kw) {
13896                     enum lex_state_e state = lex_state;
13897                     lex_state = kw->state;
13898                     if (state == EXPR_FNAME) {
13899                         set_yylval_name(rb_intern(kw->name));
13900                         return kw->id[0];
13901                     }
13902                     if (kw->id[0] == keyword_do) {
13903                         command_start = TRUE;
13904                         if (lpar_beg && lpar_beg == paren_nest) {
13905                             lpar_beg = 0;
13906                             --paren_nest;
13907                             return keyword_do_LAMBDA;
13908                         }
13909                         if (COND_P()) return keyword_do_cond;
13910                         if (CMDARG_P() && state != EXPR_CMDARG)
13911                             return keyword_do_block;
13912                         if (state == EXPR_ENDARG || state == EXPR_BEG)
13913                             return keyword_do_block;
13914                         return keyword_do;
13915                     }
13916                     if (state == EXPR_BEG || state == EXPR_VALUE)
13917                         return kw->id[0];
13918                     else {
13919                         if (kw->id[0] != kw->id[1])
13920                             lex_state = EXPR_BEG;
13921                         return kw->id[1];
13922                     }
13923                 }
13924             }
13925 
13926             if (IS_BEG() ||
13927                 lex_state == EXPR_DOT ||
13928                 IS_ARG()) {
13929                 if (cmd_state) {
13930                     lex_state = EXPR_CMDARG;
13931                 }
13932                 else {
13933                     lex_state = EXPR_ARG;
13934                 }
13935             }
13936             else if (lex_state == EXPR_FNAME) {
13937                 lex_state = EXPR_ENDFN;
13938             }
13939             else {
13940                 lex_state = EXPR_END;
13941             }
13942         }
13943         {
13944             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
13945 
13946             set_yylval_name(ident);
13947             if (last_state != EXPR_DOT && is_local_id(ident) && lvar_defined(ident)) {
13948                 lex_state = EXPR_END;
13949             }
13950         }
13951         return result;
13952     }
13953 }
13954 
13955 #if YYPURE
13956 static int
13957 yylex(void *lval, void *p)
13958 #else
13959 yylex(void *p)
13960 #endif
13961 {
13962     struct parser_params *parser = (struct parser_params*)p;
13963     int t;
13964 
13965 #if YYPURE
13966     parser->parser_yylval = lval;
13967     parser->parser_yylval->val = Qundef;
13968 #endif
13969     t = parser_yylex(parser);
13970 #ifdef RIPPER
13971     if (!NIL_P(parser->delayed)) {
13972         ripper_dispatch_delayed_token(parser, t);
13973         return t;
13974     }
13975     if (t != 0)
13976         ripper_dispatch_scan_event(parser, t);
13977 #endif
13978 
13979     return t;
13980 }
13981 
13982 #ifndef RIPPER
13983 static NODE*
13984 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
13985 {
13986     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
13987     nd_set_line(n, ruby_sourceline);
13988     return n;
13989 }
13990 
13991 enum node_type
13992 nodetype(NODE *node)                    /* for debug */
13993 {
13994     return (enum node_type)nd_type(node);
13995 }
13996 
13997 int
13998 nodeline(NODE *node)
13999 {
14000     return nd_line(node);
14001 }
14002 
14003 static NODE*
14004 newline_node(NODE *node)
14005 {
14006     if (node) {
14007         node = remove_begin(node);
14008         node->flags |= NODE_FL_NEWLINE;
14009     }
14010     return node;
14011 }
14012 
14013 static void
14014 fixpos(NODE *node, NODE *orig)
14015 {
14016     if (!node) return;
14017     if (!orig) return;
14018     if (orig == (NODE*)1) return;
14019     nd_set_line(node, nd_line(orig));
14020 }
14021 
14022 static void
14023 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14024 {
14025     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14026 }
14027 #define parser_warning(node, mesg) parser_warning(parser, node, mesg)
14028 
14029 static void
14030 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14031 {
14032     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14033 }
14034 #define parser_warn(node, mesg) parser_warn(parser, node, mesg)
14035 
14036 static NODE*
14037 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14038 {
14039     NODE *end, *h = head, *nd;
14040 
14041     if (tail == 0) return head;
14042 
14043     if (h == 0) return tail;
14044     switch (nd_type(h)) {
14045       case NODE_LIT:
14046       case NODE_STR:
14047       case NODE_SELF:
14048       case NODE_TRUE:
14049       case NODE_FALSE:
14050       case NODE_NIL:
14051         parser_warning(h, "unused literal ignored");
14052         return tail;
14053       default:
14054         h = end = NEW_BLOCK(head);
14055         end->nd_end = end;
14056         fixpos(end, head);
14057         head = end;
14058         break;
14059       case NODE_BLOCK:
14060         end = h->nd_end;
14061         break;
14062     }
14063 
14064     nd = end->nd_head;
14065     switch (nd_type(nd)) {
14066       case NODE_RETURN:
14067       case NODE_BREAK:
14068       case NODE_NEXT:
14069       case NODE_REDO:
14070       case NODE_RETRY:
14071         if (RTEST(ruby_verbose)) {
14072             parser_warning(nd, "statement not reached");
14073         }
14074         break;
14075 
14076       default:
14077         break;
14078     }
14079 
14080     if (nd_type(tail) != NODE_BLOCK) {
14081         tail = NEW_BLOCK(tail);
14082         tail->nd_end = tail;
14083     }
14084     end->nd_next = tail;
14085     h->nd_end = tail->nd_end;
14086     return head;
14087 }
14088 
14089 /* append item to the list */
14090 static NODE*
14091 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14092 {
14093     NODE *last;
14094 
14095     if (list == 0) return NEW_LIST(item);
14096     if (list->nd_next) {
14097         last = list->nd_next->nd_end;
14098     }
14099     else {
14100         last = list;
14101     }
14102 
14103     list->nd_alen += 1;
14104     last->nd_next = NEW_LIST(item);
14105     list->nd_next->nd_end = last->nd_next;
14106     return list;
14107 }
14108 
14109 /* concat two lists */
14110 static NODE*
14111 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14112 {
14113     NODE *last;
14114 
14115     if (head->nd_next) {
14116         last = head->nd_next->nd_end;
14117     }
14118     else {
14119         last = head;
14120     }
14121 
14122     head->nd_alen += tail->nd_alen;
14123     last->nd_next = tail;
14124     if (tail->nd_next) {
14125         head->nd_next->nd_end = tail->nd_next->nd_end;
14126     }
14127     else {
14128         head->nd_next->nd_end = tail;
14129     }
14130 
14131     return head;
14132 }
14133 
14134 static int
14135 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14136 {
14137     if (NIL_P(tail)) return 1;
14138     if (!rb_enc_compatible(head, tail)) {
14139         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14140                       rb_enc_name(rb_enc_get(head)),
14141                       rb_enc_name(rb_enc_get(tail)));
14142         rb_str_resize(head, 0);
14143         rb_str_resize(tail, 0);
14144         return 0;
14145     }
14146     rb_str_buf_append(head, tail);
14147     return 1;
14148 }
14149 
14150 /* concat two string literals */
14151 static NODE *
14152 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14153 {
14154     enum node_type htype;
14155 
14156     if (!head) return tail;
14157     if (!tail) return head;
14158 
14159     htype = nd_type(head);
14160     if (htype == NODE_EVSTR) {
14161         NODE *node = NEW_DSTR(Qnil);
14162         head = list_append(node, head);
14163     }
14164     switch (nd_type(tail)) {
14165       case NODE_STR:
14166         if (htype == NODE_STR) {
14167             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
14168               error:
14169                 rb_gc_force_recycle((VALUE)head);
14170                 rb_gc_force_recycle((VALUE)tail);
14171                 return 0;
14172             }
14173             rb_gc_force_recycle((VALUE)tail);
14174         }
14175         else {
14176             list_append(head, tail);
14177         }
14178         break;
14179 
14180       case NODE_DSTR:
14181         if (htype == NODE_STR) {
14182             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14183                 goto error;
14184             tail->nd_lit = head->nd_lit;
14185             rb_gc_force_recycle((VALUE)head);
14186             head = tail;
14187         }
14188         else if (NIL_P(tail->nd_lit)) {
14189             head->nd_alen += tail->nd_alen - 1;
14190             head->nd_next->nd_end->nd_next = tail->nd_next;
14191             head->nd_next->nd_end = tail->nd_next->nd_end;
14192             rb_gc_force_recycle((VALUE)tail);
14193         }
14194         else {
14195             nd_set_type(tail, NODE_ARRAY);
14196             tail->nd_head = NEW_STR(tail->nd_lit);
14197             list_concat(head, tail);
14198         }
14199         break;
14200 
14201       case NODE_EVSTR:
14202         if (htype == NODE_STR) {
14203             nd_set_type(head, NODE_DSTR);
14204             head->nd_alen = 1;
14205         }
14206         list_append(head, tail);
14207         break;
14208     }
14209     return head;
14210 }
14211 
14212 static NODE *
14213 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14214 {
14215     if (nd_type(node) == NODE_EVSTR) {
14216         node = list_append(NEW_DSTR(Qnil), node);
14217     }
14218     return node;
14219 }
14220 
14221 static NODE *
14222 new_evstr_gen(struct parser_params *parser, NODE *node)
14223 {
14224     NODE *head = node;
14225 
14226     if (node) {
14227         switch (nd_type(node)) {
14228           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14229             return node;
14230         }
14231     }
14232     return NEW_EVSTR(head);
14233 }
14234 
14235 static NODE *
14236 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14237 {
14238     value_expr(recv);
14239     value_expr(arg1);
14240     return NEW_CALL(recv, id, NEW_LIST(arg1));
14241 }
14242 
14243 static NODE *
14244 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14245 {
14246     value_expr(recv);
14247     return NEW_CALL(recv, id, 0);
14248 }
14249 
14250 static NODE*
14251 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14252 {
14253     value_expr(node1);
14254     value_expr(node2);
14255     if (node1) {
14256         switch (nd_type(node1)) {
14257           case NODE_DREGX:
14258           case NODE_DREGX_ONCE:
14259             return NEW_MATCH2(node1, node2);
14260 
14261           case NODE_LIT:
14262             if (TYPE(node1->nd_lit) == T_REGEXP) {
14263                 return NEW_MATCH2(node1, node2);
14264             }
14265         }
14266     }
14267 
14268     if (node2) {
14269         switch (nd_type(node2)) {
14270           case NODE_DREGX:
14271           case NODE_DREGX_ONCE:
14272             return NEW_MATCH3(node2, node1);
14273 
14274           case NODE_LIT:
14275             if (TYPE(node2->nd_lit) == T_REGEXP) {
14276                 return NEW_MATCH3(node2, node1);
14277             }
14278         }
14279     }
14280 
14281     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14282 }
14283 
14284 static NODE*
14285 gettable_gen(struct parser_params *parser, ID id)
14286 {
14287     if (id == keyword_self) {
14288         return NEW_SELF();
14289     }
14290     else if (id == keyword_nil) {
14291         return NEW_NIL();
14292     }
14293     else if (id == keyword_true) {
14294         return NEW_TRUE();
14295     }
14296     else if (id == keyword_false) {
14297         return NEW_FALSE();
14298     }
14299     else if (id == keyword__FILE__) {
14300         return NEW_STR(rb_external_str_new_with_enc(ruby_sourcefile, strlen(ruby_sourcefile),
14301                                                     rb_filesystem_encoding()));
14302     }
14303     else if (id == keyword__LINE__) {
14304         return NEW_LIT(INT2FIX(ruby_sourceline));
14305     }
14306     else if (id == keyword__ENCODING__) {
14307         return NEW_LIT(rb_enc_from_encoding(parser->enc));
14308     }
14309     else if (is_local_id(id)) {
14310         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14311         if (local_id(id)) return NEW_LVAR(id);
14312         /* method call without arguments */
14313         return NEW_VCALL(id);
14314     }
14315     else if (is_global_id(id)) {
14316         return NEW_GVAR(id);
14317     }
14318     else if (is_instance_id(id)) {
14319         return NEW_IVAR(id);
14320     }
14321     else if (is_const_id(id)) {
14322         return NEW_CONST(id);
14323     }
14324     else if (is_class_id(id)) {
14325         return NEW_CVAR(id);
14326     }
14327     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14328     return 0;
14329 }
14330 #endif /* !RIPPER */
14331 
14332 #ifdef RIPPER
14333 static VALUE
14334 assignable_gen(struct parser_params *parser, VALUE lhs)
14335 #else
14336 static NODE*
14337 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14338 #endif
14339 {
14340 #ifdef RIPPER
14341     ID id = get_id(lhs);
14342 # define assignable_result(x) get_value(lhs)
14343 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14344 #else
14345 # define assignable_result(x) x
14346 #endif
14347     if (!id) return assignable_result(0);
14348     if (id == keyword_self) {
14349         yyerror("Can't change the value of self");
14350     }
14351     else if (id == keyword_nil) {
14352         yyerror("Can't assign to nil");
14353     }
14354     else if (id == keyword_true) {
14355         yyerror("Can't assign to true");
14356     }
14357     else if (id == keyword_false) {
14358         yyerror("Can't assign to false");
14359     }
14360     else if (id == keyword__FILE__) {
14361         yyerror("Can't assign to __FILE__");
14362     }
14363     else if (id == keyword__LINE__) {
14364         yyerror("Can't assign to __LINE__");
14365     }
14366     else if (id == keyword__ENCODING__) {
14367         yyerror("Can't assign to __ENCODING__");
14368     }
14369     else if (is_local_id(id)) {
14370         if (dyna_in_block()) {
14371             if (dvar_curr(id)) {
14372                 return assignable_result(NEW_DASGN_CURR(id, val));
14373             }
14374             else if (dvar_defined(id)) {
14375                 return assignable_result(NEW_DASGN(id, val));
14376             }
14377             else if (local_id(id)) {
14378                 return assignable_result(NEW_LASGN(id, val));
14379             }
14380             else {
14381                 dyna_var(id);
14382                 return assignable_result(NEW_DASGN_CURR(id, val));
14383             }
14384         }
14385         else {
14386             if (!local_id(id)) {
14387                 local_var(id);
14388             }
14389             return assignable_result(NEW_LASGN(id, val));
14390         }
14391     }
14392     else if (is_global_id(id)) {
14393         return assignable_result(NEW_GASGN(id, val));
14394     }
14395     else if (is_instance_id(id)) {
14396         return assignable_result(NEW_IASGN(id, val));
14397     }
14398     else if (is_const_id(id)) {
14399         if (!in_def && !in_single)
14400             return assignable_result(NEW_CDECL(id, val, 0));
14401         yyerror("dynamic constant assignment");
14402     }
14403     else if (is_class_id(id)) {
14404         return assignable_result(NEW_CVASGN(id, val));
14405     }
14406     else {
14407         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14408     }
14409     return assignable_result(0);
14410 #undef assignable_result
14411 #undef parser_yyerror
14412 }
14413 
14414 static ID
14415 shadowing_lvar_gen(struct parser_params *parser, ID name)
14416 {
14417     ID uscore;
14418 
14419     CONST_ID(uscore, "_");
14420     if (uscore == name) return name;
14421     if (dyna_in_block()) {
14422         if (dvar_curr(name)) {
14423             yyerror("duplicated argument name");
14424         }
14425         else if (dvar_defined(name) || local_id(name)) {
14426             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14427             vtable_add(lvtbl->vars, name);
14428         }
14429     }
14430     else {
14431         if (local_id(name)) {
14432             yyerror("duplicated argument name");
14433         }
14434     }
14435     return name;
14436 }
14437 
14438 static void
14439 new_bv_gen(struct parser_params *parser, ID name)
14440 {
14441     if (!name) return;
14442     if (!is_local_id(name)) {
14443         compile_error(PARSER_ARG "invalid local variable - %s",
14444                       rb_id2name(name));
14445         return;
14446     }
14447     shadowing_lvar(name);
14448     dyna_var(name);
14449 }
14450 
14451 #ifndef RIPPER
14452 static NODE *
14453 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14454 {
14455     if (recv && nd_type(recv) == NODE_SELF)
14456         recv = (NODE *)1;
14457     return NEW_ATTRASGN(recv, tASET, idx);
14458 }
14459 
14460 static void
14461 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14462 {
14463     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14464         compile_error(PARSER_ARG "both block arg and actual block given");
14465     }
14466 }
14467 
14468 ID
14469 rb_id_attrset(ID id)
14470 {
14471     id &= ~ID_SCOPE_MASK;
14472     id |= ID_ATTRSET;
14473     return id;
14474 }
14475 
14476 static NODE *
14477 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14478 {
14479     if (recv && nd_type(recv) == NODE_SELF)
14480         recv = (NODE *)1;
14481     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14482 }
14483 
14484 static void
14485 rb_backref_error_gen(struct parser_params *parser, NODE *node)
14486 {
14487     switch (nd_type(node)) {
14488       case NODE_NTH_REF:
14489         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14490         break;
14491       case NODE_BACK_REF:
14492         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14493         break;
14494     }
14495 }
14496 
14497 static NODE *
14498 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14499 {
14500     if (!node2) return node1;
14501     switch (nd_type(node1)) {
14502       case NODE_BLOCK_PASS:
14503         if (node1->nd_head)
14504             node1->nd_head = arg_concat(node1->nd_head, node2);
14505         else
14506             node1->nd_head = NEW_LIST(node2);
14507         return node1;
14508       case NODE_ARGSPUSH:
14509         if (nd_type(node2) != NODE_ARRAY) break;
14510         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14511         nd_set_type(node1, NODE_ARGSCAT);
14512         return node1;
14513       case NODE_ARGSCAT:
14514         if (nd_type(node2) != NODE_ARRAY ||
14515             nd_type(node1->nd_body) != NODE_ARRAY) break;
14516         node1->nd_body = list_concat(node1->nd_body, node2);
14517         return node1;
14518     }
14519     return NEW_ARGSCAT(node1, node2);
14520 }
14521 
14522 static NODE *
14523 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14524 {
14525     if (!node1) return NEW_LIST(node2);
14526     switch (nd_type(node1))  {
14527       case NODE_ARRAY:
14528         return list_append(node1, node2);
14529       case NODE_BLOCK_PASS:
14530         node1->nd_head = arg_append(node1->nd_head, node2);
14531         return node1;
14532       case NODE_ARGSPUSH:
14533         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14534         nd_set_type(node1, NODE_ARGSCAT);
14535         return node1;
14536     }
14537     return NEW_ARGSPUSH(node1, node2);
14538 }
14539 
14540 static NODE *
14541 splat_array(NODE* node)
14542 {
14543     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14544     if (nd_type(node) == NODE_ARRAY) return node;
14545     return 0;
14546 }
14547 
14548 static NODE *
14549 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14550 {
14551     if (!lhs) return 0;
14552 
14553     switch (nd_type(lhs)) {
14554       case NODE_GASGN:
14555       case NODE_IASGN:
14556       case NODE_IASGN2:
14557       case NODE_LASGN:
14558       case NODE_DASGN:
14559       case NODE_DASGN_CURR:
14560       case NODE_MASGN:
14561       case NODE_CDECL:
14562       case NODE_CVASGN:
14563         lhs->nd_value = rhs;
14564         break;
14565 
14566       case NODE_ATTRASGN:
14567       case NODE_CALL:
14568         lhs->nd_args = arg_append(lhs->nd_args, rhs);
14569         break;
14570 
14571       default:
14572         /* should not happen */
14573         break;
14574     }
14575 
14576     return lhs;
14577 }
14578 
14579 static int
14580 value_expr_gen(struct parser_params *parser, NODE *node)
14581 {
14582     int cond = 0;
14583 
14584     if (!node) {
14585         rb_warning0("empty expression");
14586     }
14587     while (node) {
14588         switch (nd_type(node)) {
14589           case NODE_DEFN:
14590           case NODE_DEFS:
14591             parser_warning(node, "void value expression");
14592             return FALSE;
14593 
14594           case NODE_RETURN:
14595           case NODE_BREAK:
14596           case NODE_NEXT:
14597           case NODE_REDO:
14598           case NODE_RETRY:
14599             if (!cond) yyerror("void value expression");
14600             /* or "control never reach"? */
14601             return FALSE;
14602 
14603           case NODE_BLOCK:
14604             while (node->nd_next) {
14605                 node = node->nd_next;
14606             }
14607             node = node->nd_head;
14608             break;
14609 
14610           case NODE_BEGIN:
14611             node = node->nd_body;
14612             break;
14613 
14614           case NODE_IF:
14615             if (!node->nd_body) {
14616                 node = node->nd_else;
14617                 break;
14618             }
14619             else if (!node->nd_else) {
14620                 node = node->nd_body;
14621                 break;
14622             }
14623             if (!value_expr(node->nd_body)) return FALSE;
14624             node = node->nd_else;
14625             break;
14626 
14627           case NODE_AND:
14628           case NODE_OR:
14629             cond = 1;
14630             node = node->nd_2nd;
14631             break;
14632 
14633           default:
14634             return TRUE;
14635         }
14636     }
14637 
14638     return TRUE;
14639 }
14640 
14641 static void
14642 void_expr_gen(struct parser_params *parser, NODE *node)
14643 {
14644     const char *useless = 0;
14645 
14646     if (!RTEST(ruby_verbose)) return;
14647 
14648     if (!node) return;
14649     switch (nd_type(node)) {
14650       case NODE_CALL:
14651         switch (node->nd_mid) {
14652           case '+':
14653           case '-':
14654           case '*':
14655           case '/':
14656           case '%':
14657           case tPOW:
14658           case tUPLUS:
14659           case tUMINUS:
14660           case '|':
14661           case '^':
14662           case '&':
14663           case tCMP:
14664           case '>':
14665           case tGEQ:
14666           case '<':
14667           case tLEQ:
14668           case tEQ:
14669           case tNEQ:
14670             useless = rb_id2name(node->nd_mid);
14671             break;
14672         }
14673         break;
14674 
14675       case NODE_LVAR:
14676       case NODE_DVAR:
14677       case NODE_GVAR:
14678       case NODE_IVAR:
14679       case NODE_CVAR:
14680       case NODE_NTH_REF:
14681       case NODE_BACK_REF:
14682         useless = "a variable";
14683         break;
14684       case NODE_CONST:
14685         useless = "a constant";
14686         break;
14687       case NODE_LIT:
14688       case NODE_STR:
14689       case NODE_DSTR:
14690       case NODE_DREGX:
14691       case NODE_DREGX_ONCE:
14692         useless = "a literal";
14693         break;
14694       case NODE_COLON2:
14695       case NODE_COLON3:
14696         useless = "::";
14697         break;
14698       case NODE_DOT2:
14699         useless = "..";
14700         break;
14701       case NODE_DOT3:
14702         useless = "...";
14703         break;
14704       case NODE_SELF:
14705         useless = "self";
14706         break;
14707       case NODE_NIL:
14708         useless = "nil";
14709         break;
14710       case NODE_TRUE:
14711         useless = "true";
14712         break;
14713       case NODE_FALSE:
14714         useless = "false";
14715         break;
14716       case NODE_DEFINED:
14717         useless = "defined?";
14718         break;
14719     }
14720 
14721     if (useless) {
14722         int line = ruby_sourceline;
14723 
14724         ruby_sourceline = nd_line(node);
14725         rb_warnS("useless use of %s in void context", useless);
14726         ruby_sourceline = line;
14727     }
14728 }
14729 
14730 static void
14731 void_stmts_gen(struct parser_params *parser, NODE *node)
14732 {
14733     if (!RTEST(ruby_verbose)) return;
14734     if (!node) return;
14735     if (nd_type(node) != NODE_BLOCK) return;
14736 
14737     for (;;) {
14738         if (!node->nd_next) return;
14739         void_expr0(node->nd_head);
14740         node = node->nd_next;
14741     }
14742 }
14743 
14744 static NODE *
14745 remove_begin(NODE *node)
14746 {
14747     NODE **n = &node, *n1 = node;
14748     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
14749         *n = n1 = n1->nd_body;
14750     }
14751     return node;
14752 }
14753 
14754 static void
14755 reduce_nodes_gen(struct parser_params *parser, NODE **body)
14756 {
14757     NODE *node = *body;
14758 
14759     if (!node) {
14760         *body = NEW_NIL();
14761         return;
14762     }
14763 #define subnodes(n1, n2) \
14764     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
14765      (!node->n2) ? (body = &node->n1, 1) : \
14766      (reduce_nodes(&node->n1), body = &node->n2, 1))
14767 
14768     while (node) {
14769         int newline = (int)(node->flags & NODE_FL_NEWLINE);
14770         switch (nd_type(node)) {
14771           end:
14772           case NODE_NIL:
14773             *body = 0;
14774             return;
14775           case NODE_RETURN:
14776             *body = node = node->nd_stts;
14777             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14778             continue;
14779           case NODE_BEGIN:
14780             *body = node = node->nd_body;
14781             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14782             continue;
14783           case NODE_BLOCK:
14784             body = &node->nd_end->nd_head;
14785             break;
14786           case NODE_IF:
14787             if (subnodes(nd_body, nd_else)) break;
14788             return;
14789           case NODE_CASE:
14790             body = &node->nd_body;
14791             break;
14792           case NODE_WHEN:
14793             if (!subnodes(nd_body, nd_next)) goto end;
14794             break;
14795           case NODE_ENSURE:
14796             if (!subnodes(nd_head, nd_resq)) goto end;
14797             break;
14798           case NODE_RESCUE:
14799             if (!subnodes(nd_head, nd_resq)) goto end;
14800             break;
14801           default:
14802             return;
14803         }
14804         node = *body;
14805         if (newline && node) node->flags |= NODE_FL_NEWLINE;
14806     }
14807 
14808 #undef subnodes
14809 }
14810 
14811 static int
14812 assign_in_cond(struct parser_params *parser, NODE *node)
14813 {
14814     switch (nd_type(node)) {
14815       case NODE_MASGN:
14816         yyerror("multiple assignment in conditional");
14817         return 1;
14818 
14819       case NODE_LASGN:
14820       case NODE_DASGN:
14821       case NODE_DASGN_CURR:
14822       case NODE_GASGN:
14823       case NODE_IASGN:
14824         break;
14825 
14826       default:
14827         return 0;
14828     }
14829 
14830     if (!node->nd_value) return 1;
14831     switch (nd_type(node->nd_value)) {
14832       case NODE_LIT:
14833       case NODE_STR:
14834       case NODE_NIL:
14835       case NODE_TRUE:
14836       case NODE_FALSE:
14837         /* reports always */
14838         parser_warn(node->nd_value, "found = in conditional, should be ==");
14839         return 1;
14840 
14841       case NODE_DSTR:
14842       case NODE_XSTR:
14843       case NODE_DXSTR:
14844       case NODE_EVSTR:
14845       case NODE_DREGX:
14846       default:
14847         break;
14848     }
14849     return 1;
14850 }
14851 
14852 static void
14853 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14854 {
14855     if (!e_option_supplied(parser)) parser_warn(node, str);
14856 }
14857 
14858 static void
14859 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14860 {
14861     if (!e_option_supplied(parser)) parser_warning(node, str);
14862 }
14863 
14864 static void
14865 fixup_nodes(NODE **rootnode)
14866 {
14867     NODE *node, *next, *head;
14868 
14869     for (node = *rootnode; node; node = next) {
14870         enum node_type type;
14871         VALUE val;
14872 
14873         next = node->nd_next;
14874         head = node->nd_head;
14875         rb_gc_force_recycle((VALUE)node);
14876         *rootnode = next;
14877         switch (type = nd_type(head)) {
14878           case NODE_DOT2:
14879           case NODE_DOT3:
14880             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
14881                                type == NODE_DOT3);
14882             rb_gc_force_recycle((VALUE)head->nd_beg);
14883             rb_gc_force_recycle((VALUE)head->nd_end);
14884             nd_set_type(head, NODE_LIT);
14885             head->nd_lit = val;
14886             break;
14887           default:
14888             break;
14889         }
14890     }
14891 }
14892 
14893 static NODE *cond0(struct parser_params*,NODE*);
14894 
14895 static NODE*
14896 range_op(struct parser_params *parser, NODE *node)
14897 {
14898     enum node_type type;
14899 
14900     if (node == 0) return 0;
14901 
14902     type = nd_type(node);
14903     value_expr(node);
14904     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
14905         warn_unless_e_option(parser, node, "integer literal in conditional range");
14906         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
14907     }
14908     return cond0(parser, node);
14909 }
14910 
14911 static int
14912 literal_node(NODE *node)
14913 {
14914     if (!node) return 1;        /* same as NODE_NIL */
14915     switch (nd_type(node)) {
14916       case NODE_LIT:
14917       case NODE_STR:
14918       case NODE_DSTR:
14919       case NODE_EVSTR:
14920       case NODE_DREGX:
14921       case NODE_DREGX_ONCE:
14922       case NODE_DSYM:
14923         return 2;
14924       case NODE_TRUE:
14925       case NODE_FALSE:
14926       case NODE_NIL:
14927         return 1;
14928     }
14929     return 0;
14930 }
14931 
14932 static NODE*
14933 cond0(struct parser_params *parser, NODE *node)
14934 {
14935     if (node == 0) return 0;
14936     assign_in_cond(parser, node);
14937 
14938     switch (nd_type(node)) {
14939       case NODE_DSTR:
14940       case NODE_EVSTR:
14941       case NODE_STR:
14942         rb_warn0("string literal in condition");
14943         break;
14944 
14945       case NODE_DREGX:
14946       case NODE_DREGX_ONCE:
14947         warning_unless_e_option(parser, node, "regex literal in condition");
14948         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
14949 
14950       case NODE_AND:
14951       case NODE_OR:
14952         node->nd_1st = cond0(parser, node->nd_1st);
14953         node->nd_2nd = cond0(parser, node->nd_2nd);
14954         break;
14955 
14956       case NODE_DOT2:
14957       case NODE_DOT3:
14958         node->nd_beg = range_op(parser, node->nd_beg);
14959         node->nd_end = range_op(parser, node->nd_end);
14960         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
14961         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
14962         if (!e_option_supplied(parser)) {
14963             int b = literal_node(node->nd_beg);
14964             int e = literal_node(node->nd_end);
14965             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
14966                 parser_warn(node, "range literal in condition");
14967             }
14968         }
14969         break;
14970 
14971       case NODE_DSYM:
14972         parser_warning(node, "literal in condition");
14973         break;
14974 
14975       case NODE_LIT:
14976         if (TYPE(node->nd_lit) == T_REGEXP) {
14977             warn_unless_e_option(parser, node, "regex literal in condition");
14978             nd_set_type(node, NODE_MATCH);
14979         }
14980         else {
14981             parser_warning(node, "literal in condition");
14982         }
14983       default:
14984         break;
14985     }
14986     return node;
14987 }
14988 
14989 static NODE*
14990 cond_gen(struct parser_params *parser, NODE *node)
14991 {
14992     if (node == 0) return 0;
14993     return cond0(parser, node);
14994 }
14995 
14996 static NODE*
14997 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
14998 {
14999     value_expr(left);
15000     if (left && (enum node_type)nd_type(left) == type) {
15001         NODE *node = left, *second;
15002         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15003             node = second;
15004         }
15005         node->nd_2nd = NEW_NODE(type, second, right, 0);
15006         return left;
15007     }
15008     return NEW_NODE(type, left, right, 0);
15009 }
15010 
15011 static void
15012 no_blockarg(struct parser_params *parser, NODE *node)
15013 {
15014     if (node && nd_type(node) == NODE_BLOCK_PASS) {
15015         compile_error(PARSER_ARG "block argument should not be given");
15016     }
15017 }
15018 
15019 static NODE *
15020 ret_args_gen(struct parser_params *parser, NODE *node)
15021 {
15022     if (node) {
15023         no_blockarg(parser, node);
15024         if (nd_type(node) == NODE_ARRAY) {
15025             if (node->nd_next == 0) {
15026                 node = node->nd_head;
15027             }
15028             else {
15029                 nd_set_type(node, NODE_VALUES);
15030             }
15031         }
15032     }
15033     return node;
15034 }
15035 
15036 static NODE *
15037 new_yield_gen(struct parser_params *parser, NODE *node)
15038 {
15039     long state = Qtrue;
15040 
15041     if (node) {
15042         no_blockarg(parser, node);
15043         if (node && nd_type(node) == NODE_SPLAT) {
15044             state = Qtrue;
15045         }
15046     }
15047     else {
15048         state = Qfalse;
15049     }
15050     return NEW_YIELD(node, state);
15051 }
15052 
15053 static NODE*
15054 negate_lit(NODE *node)
15055 {
15056     switch (TYPE(node->nd_lit)) {
15057       case T_FIXNUM:
15058         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15059         break;
15060       case T_BIGNUM:
15061         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15062         break;
15063       case T_FLOAT:
15064         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15065         break;
15066       default:
15067         break;
15068     }
15069     return node;
15070 }
15071 
15072 static NODE *
15073 arg_blk_pass(NODE *node1, NODE *node2)
15074 {
15075     if (node2) {
15076         node2->nd_head = node1;
15077         return node2;
15078     }
15079     return node1;
15080 }
15081 
15082 static NODE*
15083 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
15084 {
15085     int saved_line = ruby_sourceline;
15086     NODE *node;
15087     NODE *i1, *i2 = 0;
15088 
15089     node = NEW_ARGS(m ? m->nd_plen : 0, o);
15090     i1 = m ? m->nd_next : 0;
15091     node->nd_next = NEW_ARGS_AUX(r, b);
15092 
15093     if (p) {
15094         i2 = p->nd_next;
15095         node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
15096     }
15097     else if (i1) {
15098         node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
15099     }
15100     if (i1 || i2) {
15101         node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
15102     }
15103     ruby_sourceline = saved_line;
15104     return node;
15105 }
15106 #endif /* !RIPPER */
15107 
15108 static void
15109 local_push_gen(struct parser_params *parser, int inherit_dvars)
15110 {
15111     struct local_vars *local;
15112 
15113     local = ALLOC(struct local_vars);
15114     local->prev = lvtbl;
15115     local->args = vtable_alloc(0);
15116     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15117     lvtbl = local;
15118 }
15119 
15120 static void
15121 local_pop_gen(struct parser_params *parser)
15122 {
15123     struct local_vars *local = lvtbl->prev;
15124     vtable_free(lvtbl->args);
15125     vtable_free(lvtbl->vars);
15126     xfree(lvtbl);
15127     lvtbl = local;
15128 }
15129 
15130 #ifndef RIPPER
15131 static ID*
15132 vtable_tblcpy(ID *buf, const struct vtable *src)
15133 {
15134     int i, cnt = vtable_size(src);
15135 
15136     if (cnt > 0) {
15137         buf[0] = cnt;
15138         for (i = 0; i < cnt; i++) {
15139             buf[i] = src->tbl[i];
15140         }
15141         return buf;
15142     }
15143     return 0;
15144 }
15145 
15146 static ID*
15147 local_tbl_gen(struct parser_params *parser)
15148 {
15149     int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15150     ID *buf;
15151 
15152     if (cnt <= 0) return 0;
15153     buf = ALLOC_N(ID, cnt + 1);
15154     vtable_tblcpy(buf+1, lvtbl->args);
15155     vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15156     buf[0] = cnt;
15157     return buf;
15158 }
15159 #endif
15160 
15161 static int
15162 arg_var_gen(struct parser_params *parser, ID id)
15163 {
15164     vtable_add(lvtbl->args, id);
15165     return vtable_size(lvtbl->args) - 1;
15166 }
15167 
15168 static int
15169 local_var_gen(struct parser_params *parser, ID id)
15170 {
15171     vtable_add(lvtbl->vars, id);
15172     return vtable_size(lvtbl->vars) - 1;
15173 }
15174 
15175 static int
15176 local_id_gen(struct parser_params *parser, ID id)
15177 {
15178     struct vtable *vars, *args;
15179 
15180     vars = lvtbl->vars;
15181     args = lvtbl->args;
15182 
15183     while (vars && POINTER_P(vars->prev)) {
15184         vars = vars->prev;
15185         args = args->prev;
15186     }
15187 
15188     if (vars && vars->prev == DVARS_INHERIT) {
15189         return rb_local_defined(id);
15190     }
15191     else {
15192         return (vtable_included(args, id) ||
15193                 vtable_included(vars, id));
15194     }
15195 }
15196 
15197 static const struct vtable *
15198 dyna_push_gen(struct parser_params *parser)
15199 {
15200     lvtbl->args = vtable_alloc(lvtbl->args);
15201     lvtbl->vars = vtable_alloc(lvtbl->vars);
15202     return lvtbl->args;
15203 }
15204 
15205 static void
15206 dyna_pop_1(struct parser_params *parser)
15207 {
15208     struct vtable *tmp;
15209 
15210     tmp = lvtbl->args;
15211     lvtbl->args = lvtbl->args->prev;
15212     vtable_free(tmp);
15213     tmp = lvtbl->vars;
15214     lvtbl->vars = lvtbl->vars->prev;
15215     vtable_free(tmp);
15216 }
15217 
15218 static void
15219 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15220 {
15221     while (lvtbl->args != lvargs) {
15222         dyna_pop_1(parser);
15223         if (!lvtbl->args) {
15224             struct local_vars *local = lvtbl->prev;
15225             xfree(lvtbl);
15226             lvtbl = local;
15227         }
15228     }
15229     dyna_pop_1(parser);
15230 }
15231 
15232 static int
15233 dyna_in_block_gen(struct parser_params *parser)
15234 {
15235     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15236 }
15237 
15238 static int
15239 dvar_defined_gen(struct parser_params *parser, ID id)
15240 {
15241     struct vtable *vars, *args;
15242 
15243     args = lvtbl->args;
15244     vars = lvtbl->vars;
15245 
15246     while (POINTER_P(vars)) {
15247         if (vtable_included(args, id)) {
15248             return 1;
15249         }
15250         if (vtable_included(vars, id)) {
15251             return 1;
15252         }
15253         args = args->prev;
15254         vars = vars->prev;
15255     }
15256 
15257     if (vars == DVARS_INHERIT) {
15258         return rb_dvar_defined(id);
15259     }
15260 
15261     return 0;
15262 }
15263 
15264 static int
15265 dvar_curr_gen(struct parser_params *parser, ID id)
15266 {
15267     return (vtable_included(lvtbl->args, id) ||
15268             vtable_included(lvtbl->vars, id));
15269 }
15270 
15271 #ifndef RIPPER
15272 VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
15273 VALUE rb_reg_check_preprocess(VALUE);
15274 
15275 static void
15276 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
15277 {
15278     int c = RE_OPTION_ENCODING_IDX(options);
15279 
15280     if (c) {
15281         int opt, idx;
15282         rb_char_to_option_kcode(c, &opt, &idx);
15283         if (idx != ENCODING_GET(str) &&
15284             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15285             goto error;
15286         }
15287         ENCODING_SET(str, idx);
15288     }
15289     else if (RE_OPTION_ENCODING_NONE(options)) {
15290         if (!ENCODING_IS_ASCII8BIT(str) &&
15291             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15292             c = 'n';
15293             goto error;
15294         }
15295         rb_enc_associate(str, rb_ascii8bit_encoding());
15296     }
15297     else if (parser->enc == rb_usascii_encoding()) {
15298         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15299             /* raise in re.c */
15300             rb_enc_associate(str, rb_usascii_encoding());
15301         }
15302         else {
15303             rb_enc_associate(str, rb_ascii8bit_encoding());
15304         }
15305     }
15306     return;
15307 
15308   error:
15309     compile_error(PARSER_ARG
15310         "regexp encoding option '%c' differs from source encoding '%s'",
15311         c, rb_enc_name(rb_enc_get(str)));
15312 }
15313 
15314 static int
15315 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
15316 {
15317     VALUE err;
15318     reg_fragment_setenc(str, options);
15319     err = rb_reg_check_preprocess(str);
15320     if (err != Qnil) {
15321         err = rb_obj_as_string(err);
15322         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15323         RB_GC_GUARD(err);
15324         return 0;
15325     }
15326     return 1;
15327 }
15328 
15329 typedef struct {
15330     struct parser_params* parser;
15331     rb_encoding *enc;
15332     NODE *succ_block;
15333     NODE *fail_block;
15334     int num;
15335 } reg_named_capture_assign_t;
15336 
15337 static int
15338 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
15339           int back_num, int *back_refs, OnigRegex regex, void *arg0)
15340 {
15341     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
15342     struct parser_params* parser = arg->parser;
15343     rb_encoding *enc = arg->enc;
15344     long len = name_end - name;
15345     const char *s = (const char *)name;
15346     ID var;
15347 
15348     arg->num++;
15349 
15350     if (arg->succ_block == 0) {
15351         arg->succ_block = NEW_BEGIN(0);
15352         arg->fail_block = NEW_BEGIN(0);
15353     }
15354 
15355     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15356         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15357         !rb_enc_symname2_p(s, len, enc)) {
15358         return ST_CONTINUE;
15359     }
15360     var = rb_intern3(s, len, enc);
15361     if (dvar_defined(var) || local_id(var)) {
15362         rb_warningS("named capture conflicts a local variable - %s",
15363                     rb_id2name(var));
15364     }
15365     arg->succ_block = block_append(arg->succ_block,
15366         newline_node(node_assign(assignable(var,0),
15367             NEW_CALL(
15368               gettable(rb_intern("$~")),
15369               idAREF,
15370               NEW_LIST(NEW_LIT(ID2SYM(var))))
15371             )));
15372     arg->fail_block = block_append(arg->fail_block,
15373         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
15374     return ST_CONTINUE;
15375 }
15376 
15377 static NODE *
15378 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
15379 {
15380     reg_named_capture_assign_t arg;
15381 
15382     arg.parser = parser;
15383     arg.enc = rb_enc_get(regexp);
15384     arg.succ_block = 0;
15385     arg.fail_block = 0;
15386     arg.num = 0;
15387     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
15388 
15389     if (arg.num == 0)
15390         return match;
15391 
15392     return
15393         block_append(
15394             newline_node(match),
15395             NEW_IF(gettable(rb_intern("$~")),
15396                 block_append(
15397                     newline_node(arg.succ_block),
15398                     newline_node(
15399                         NEW_CALL(
15400                           gettable(rb_intern("$~")),
15401                           rb_intern("begin"),
15402                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15403                 block_append(
15404                     newline_node(arg.fail_block),
15405                     newline_node(
15406                         NEW_LIT(Qnil)))));
15407 }
15408 
15409 static VALUE
15410 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15411 {
15412     VALUE re;
15413     VALUE err;
15414 
15415     reg_fragment_setenc(str, options);
15416     err = rb_errinfo();
15417     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
15418     if (NIL_P(re)) {
15419         ID mesg = rb_intern("mesg");
15420         VALUE m = rb_attr_get(rb_errinfo(), mesg);
15421         rb_set_errinfo(err);
15422         if (!NIL_P(err)) {
15423             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15424         }
15425         else {
15426             compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
15427         }
15428         return Qnil;
15429     }
15430     return re;
15431 }
15432 
15433 void
15434 rb_gc_mark_parser(void)
15435 {
15436 }
15437 
15438 NODE*
15439 rb_parser_append_print(VALUE vparser, NODE *node)
15440 {
15441     NODE *prelude = 0;
15442     NODE *scope = node;
15443     struct parser_params *parser;
15444 
15445     if (!node) return node;
15446 
15447     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15448 
15449     node = node->nd_body;
15450 
15451     if (nd_type(node) == NODE_PRELUDE) {
15452         prelude = node;
15453         node = node->nd_body;
15454     }
15455 
15456     node = block_append(node,
15457                         NEW_FCALL(rb_intern("print"),
15458                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
15459     if (prelude) {
15460         prelude->nd_body = node;
15461         scope->nd_body = prelude;
15462     }
15463     else {
15464         scope->nd_body = node;
15465     }
15466 
15467     return scope;
15468 }
15469 
15470 NODE *
15471 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15472 {
15473     NODE *prelude = 0;
15474     NODE *scope = node;
15475     struct parser_params *parser;
15476 
15477     if (!node) return node;
15478 
15479     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15480 
15481     node = node->nd_body;
15482 
15483     if (nd_type(node) == NODE_PRELUDE) {
15484         prelude = node;
15485         node = node->nd_body;
15486     }
15487     if (split) {
15488         node = block_append(NEW_GASGN(rb_intern("$F"),
15489                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
15490                                                rb_intern("split"), 0)),
15491                             node);
15492     }
15493     if (chop) {
15494         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15495                                      rb_intern("chop!"), 0), node);
15496     }
15497 
15498     node = NEW_OPT_N(node);
15499 
15500     if (prelude) {
15501         prelude->nd_body = node;
15502         scope->nd_body = prelude;
15503     }
15504     else {
15505         scope->nd_body = node;
15506     }
15507 
15508     return scope;
15509 }
15510 
15511 static const struct {
15512     ID token;
15513     const char *name;
15514 } op_tbl[] = {
15515     {tDOT2,     ".."},
15516     {tDOT3,     "..."},
15517     {'+',       "+(binary)"},
15518     {'-',       "-(binary)"},
15519     {tPOW,      "**"},
15520     {tUPLUS,    "+@"},
15521     {tUMINUS,   "-@"},
15522     {tCMP,      "<=>"},
15523     {tGEQ,      ">="},
15524     {tLEQ,      "<="},
15525     {tEQ,       "=="},
15526     {tEQQ,      "==="},
15527     {tNEQ,      "!="},
15528     {tMATCH,    "=~"},
15529     {tNMATCH,   "!~"},
15530     {tAREF,     "[]"},
15531     {tASET,     "[]="},
15532     {tLSHFT,    "<<"},
15533     {tRSHFT,    ">>"},
15534     {tCOLON2,   "::"},
15535 };
15536 
15537 #define op_tbl_count numberof(op_tbl)
15538 
15539 #ifndef ENABLE_SELECTOR_NAMESPACE
15540 #define ENABLE_SELECTOR_NAMESPACE 0
15541 #endif
15542 
15543 static struct symbols {
15544     ID last_id;
15545     st_table *sym_id;
15546     st_table *id_str;
15547 #if ENABLE_SELECTOR_NAMESPACE
15548     st_table *ivar2_id;
15549     st_table *id_ivar2;
15550 #endif
15551     VALUE op_sym[tLAST_TOKEN];
15552 } global_symbols = {tLAST_ID};
15553 
15554 static const struct st_hash_type symhash = {
15555     rb_str_hash_cmp,
15556     rb_str_hash,
15557 };
15558 
15559 #if ENABLE_SELECTOR_NAMESPACE
15560 struct ivar2_key {
15561     ID id;
15562     VALUE klass;
15563 };
15564 
15565 static int
15566 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15567 {
15568     if (key1->id == key2->id && key1->klass == key2->klass) {
15569         return 0;
15570     }
15571     return 1;
15572 }
15573 
15574 static int
15575 ivar2_hash(struct ivar2_key *key)
15576 {
15577     return (key->id << 8) ^ (key->klass >> 2);
15578 }
15579 
15580 static const struct st_hash_type ivar2_hash_type = {
15581     ivar2_cmp,
15582     ivar2_hash,
15583 };
15584 #endif
15585 
15586 void
15587 Init_sym(void)
15588 {
15589     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15590     global_symbols.id_str = st_init_numtable_with_size(1000);
15591 #if ENABLE_SELECTOR_NAMESPACE
15592     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15593     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15594 #endif
15595 
15596     Init_id();
15597 }
15598 
15599 void
15600 rb_gc_mark_symbols(void)
15601 {
15602     rb_mark_tbl(global_symbols.id_str);
15603     rb_gc_mark_locations(global_symbols.op_sym,
15604                          global_symbols.op_sym + tLAST_TOKEN);
15605 }
15606 #endif /* !RIPPER */
15607 
15608 static ID
15609 internal_id_gen(struct parser_params *parser)
15610 {
15611     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
15612     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
15613     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
15614 }
15615 
15616 #ifndef RIPPER
15617 static int
15618 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
15619 {
15620     int mb = 0;
15621 
15622     if (m >= e) return 0;
15623     switch (*m) {
15624       case '~': case '*': case '$': case '?': case '!': case '@':
15625       case '/': case '\\': case ';': case ',': case '.': case '=':
15626       case ':': case '<': case '>': case '\"':
15627       case '&': case '`': case '\'': case '+':
15628       case '0':
15629         ++m;
15630         break;
15631       case '-':
15632         ++m;
15633         if (m < e && is_identchar(m, e, enc)) {
15634             if (!ISASCII(*m)) mb = 1;
15635             m += rb_enc_mbclen(m, e, enc);
15636         }
15637         break;
15638       default:
15639         if (!rb_enc_isdigit(*m, enc)) return 0;
15640         do {
15641             if (!ISASCII(*m)) mb = 1;
15642             ++m;
15643         } while (m < e && rb_enc_isdigit(*m, enc));
15644     }
15645     return m == e ? mb + 1 : 0;
15646 }
15647 
15648 int
15649 rb_symname_p(const char *name)
15650 {
15651     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
15652 }
15653 
15654 int
15655 rb_enc_symname_p(const char *name, rb_encoding *enc)
15656 {
15657     return rb_enc_symname2_p(name, strlen(name), enc);
15658 }
15659 
15660 int
15661 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
15662 {
15663     const char *m = name;
15664     const char *e = m + len;
15665     int localid = FALSE;
15666 
15667     if (!m) return FALSE;
15668     switch (*m) {
15669       case '\0':
15670         return FALSE;
15671 
15672       case '$':
15673         if (is_special_global_name(++m, e, enc)) return TRUE;
15674         goto id;
15675 
15676       case '@':
15677         if (*++m == '@') ++m;
15678         goto id;
15679 
15680       case '<':
15681         switch (*++m) {
15682           case '<': ++m; break;
15683           case '=': if (*++m == '>') ++m; break;
15684           default: break;
15685         }
15686         break;
15687 
15688       case '>':
15689         switch (*++m) {
15690           case '>': case '=': ++m; break;
15691         }
15692         break;
15693 
15694       case '=':
15695         switch (*++m) {
15696           case '~': ++m; break;
15697           case '=': if (*++m == '=') ++m; break;
15698           default: return FALSE;
15699         }
15700         break;
15701 
15702       case '*':
15703         if (*++m == '*') ++m;
15704         break;
15705 
15706       case '+': case '-':
15707         if (*++m == '@') ++m;
15708         break;
15709 
15710       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
15711         ++m;
15712         break;
15713 
15714       case '[':
15715         if (*++m != ']') return FALSE;
15716         if (*++m == '=') ++m;
15717         break;
15718 
15719       case '!':
15720         switch (*++m) {
15721           case '\0': return TRUE;
15722           case '=': case '~': ++m; break;
15723           default: return FALSE;
15724         }
15725         break;
15726 
15727       default:
15728         localid = !rb_enc_isupper(*m, enc);
15729       id:
15730         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
15731             return FALSE;
15732         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
15733         if (localid) {
15734             switch (*m) {
15735               case '!': case '?': case '=': ++m;
15736             }
15737         }
15738         break;
15739     }
15740     return m == e;
15741 }
15742 
15743 static ID
15744 register_symid(ID id, const char *name, long len, rb_encoding *enc)
15745 {
15746     VALUE str = rb_enc_str_new(name, len, enc);
15747     OBJ_FREEZE(str);
15748     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
15749     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
15750     return id;
15751 }
15752 
15753 ID
15754 rb_intern3(const char *name, long len, rb_encoding *enc)
15755 {
15756     const char *m = name;
15757     const char *e = m + len;
15758     unsigned char c;
15759     VALUE str;
15760     ID id;
15761     long last;
15762     int mb;
15763     st_data_t data;
15764     struct RString fake_str;
15765     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED|FL_FREEZE;
15766     fake_str.basic.klass = rb_cString;
15767     fake_str.as.heap.len = len;
15768     fake_str.as.heap.ptr = (char *)name;
15769     fake_str.as.heap.aux.capa = len;
15770     str = (VALUE)&fake_str;
15771     rb_enc_associate(str, enc);
15772 
15773     if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
15774         rb_raise(rb_eEncodingError, "invalid encoding symbol");
15775     }
15776 
15777     if (st_lookup(global_symbols.sym_id, str, &data))
15778         return (ID)data;
15779 
15780     if (rb_cString && !rb_enc_asciicompat(enc)) {
15781         id = ID_JUNK;
15782         goto new_id;
15783     }
15784     last = len-1;
15785     id = 0;
15786     switch (*m) {
15787       case '$':
15788         id |= ID_GLOBAL;
15789         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
15790             if (!--mb) enc = rb_ascii8bit_encoding();
15791             goto new_id;
15792         }
15793         break;
15794       case '@':
15795         if (m[1] == '@') {
15796             m++;
15797             id |= ID_CLASS;
15798         }
15799         else {
15800             id |= ID_INSTANCE;
15801         }
15802         m++;
15803         break;
15804       default:
15805         c = m[0];
15806         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
15807             /* operators */
15808             int i;
15809 
15810             if (len == 1) {
15811                 id = c;
15812                 goto id_register;
15813             }
15814             for (i = 0; i < op_tbl_count; i++) {
15815                 if (*op_tbl[i].name == *m &&
15816                     strcmp(op_tbl[i].name, m) == 0) {
15817                     id = op_tbl[i].token;
15818                     goto id_register;
15819                 }
15820             }
15821         }
15822 
15823         if (m[last] == '=') {
15824             /* attribute assignment */
15825             id = rb_intern3(name, last, enc);
15826             if (id > tLAST_TOKEN && !is_attrset_id(id)) {
15827                 enc = rb_enc_get(rb_id2str(id));
15828                 id = rb_id_attrset(id);
15829                 goto id_register;
15830             }
15831             id = ID_ATTRSET;
15832         }
15833         else if (rb_enc_isupper(m[0], enc)) {
15834             id = ID_CONST;
15835         }
15836         else {
15837             id = ID_LOCAL;
15838         }
15839         break;
15840     }
15841     mb = 0;
15842     if (!rb_enc_isdigit(*m, enc)) {
15843         while (m <= name + last && is_identchar(m, e, enc)) {
15844             if (ISASCII(*m)) {
15845                 m++;
15846             }
15847             else {
15848                 mb = 1;
15849                 m += rb_enc_mbclen(m, e, enc);
15850             }
15851         }
15852     }
15853     if (m - name < len) id = ID_JUNK;
15854     if (enc != rb_usascii_encoding()) {
15855         /*
15856          * this clause makes sense only when called from other than
15857          * rb_intern_str() taking care of code-range.
15858          */
15859         if (!mb) {
15860             for (; m <= name + len; ++m) {
15861                 if (!ISASCII(*m)) goto mbstr;
15862             }
15863             enc = rb_usascii_encoding();
15864         }
15865       mbstr:;
15866     }
15867   new_id:
15868     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
15869         if (len > 20) {
15870             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
15871                      name);
15872         }
15873         else {
15874             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
15875                      (int)len, name);
15876         }
15877     }
15878     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
15879   id_register:
15880     return register_symid(id, name, len, enc);
15881 }
15882 
15883 ID
15884 rb_intern2(const char *name, long len)
15885 {
15886     return rb_intern3(name, len, rb_usascii_encoding());
15887 }
15888 
15889 #undef rb_intern
15890 ID
15891 rb_intern(const char *name)
15892 {
15893     return rb_intern2(name, strlen(name));
15894 }
15895 
15896 ID
15897 rb_intern_str(VALUE str)
15898 {
15899     rb_encoding *enc;
15900     ID id;
15901 
15902     if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
15903         enc = rb_usascii_encoding();
15904     }
15905     else {
15906         enc = rb_enc_get(str);
15907     }
15908     id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
15909     RB_GC_GUARD(str);
15910     return id;
15911 }
15912 
15913 VALUE
15914 rb_id2str(ID id)
15915 {
15916     st_data_t data;
15917 
15918     if (id < tLAST_TOKEN) {
15919         int i = 0;
15920 
15921         if (id < INT_MAX && rb_ispunct((int)id)) {
15922             VALUE str = global_symbols.op_sym[i = (int)id];
15923             if (!str) {
15924                 char name[2];
15925                 name[0] = (char)id;
15926                 name[1] = 0;
15927                 str = rb_usascii_str_new(name, 1);
15928                 OBJ_FREEZE(str);
15929                 global_symbols.op_sym[i] = str;
15930             }
15931             return str;
15932         }
15933         for (i = 0; i < op_tbl_count; i++) {
15934             if (op_tbl[i].token == id) {
15935                 VALUE str = global_symbols.op_sym[i];
15936                 if (!str) {
15937                     str = rb_usascii_str_new2(op_tbl[i].name);
15938                     OBJ_FREEZE(str);
15939                     global_symbols.op_sym[i] = str;
15940                 }
15941                 return str;
15942             }
15943         }
15944     }
15945 
15946     if (st_lookup(global_symbols.id_str, id, &data)) {
15947         VALUE str = (VALUE)data;
15948         if (RBASIC(str)->klass == 0)
15949             RBASIC(str)->klass = rb_cString;
15950         return str;
15951     }
15952 
15953     if (is_attrset_id(id)) {
15954         ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
15955         VALUE str;
15956 
15957         while (!(str = rb_id2str(id2))) {
15958             if (!is_local_id(id2)) return 0;
15959             id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
15960         }
15961         str = rb_str_dup(str);
15962         rb_str_cat(str, "=", 1);
15963         rb_intern_str(str);
15964         if (st_lookup(global_symbols.id_str, id, &data)) {
15965             VALUE str = (VALUE)data;
15966             if (RBASIC(str)->klass == 0)
15967                 RBASIC(str)->klass = rb_cString;
15968             return str;
15969         }
15970     }
15971     return 0;
15972 }
15973 
15974 const char *
15975 rb_id2name(ID id)
15976 {
15977     VALUE str = rb_id2str(id);
15978 
15979     if (!str) return 0;
15980     return RSTRING_PTR(str);
15981 }
15982 
15983 static int
15984 symbols_i(VALUE sym, ID value, VALUE ary)
15985 {
15986     rb_ary_push(ary, ID2SYM(value));
15987     return ST_CONTINUE;
15988 }
15989 
15990 /*
15991  *  call-seq:
15992  *     Symbol.all_symbols    => array
15993  *
15994  *  Returns an array of all the symbols currently in Ruby's symbol
15995  *  table.
15996  *
15997  *     Symbol.all_symbols.size    #=> 903
15998  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
15999  *                                     :chown, :EOFError, :$;, :String,
16000  *                                     :LOCK_SH, :"setuid?", :$<,
16001  *                                     :default_proc, :compact, :extend,
16002  *                                     :Tms, :getwd, :$=, :ThreadGroup,
16003  *                                     :wait2, :$>]
16004  */
16005 
16006 VALUE
16007 rb_sym_all_symbols(void)
16008 {
16009     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
16010 
16011     st_foreach(global_symbols.sym_id, symbols_i, ary);
16012     return ary;
16013 }
16014 
16015 int
16016 rb_is_const_id(ID id)
16017 {
16018     return is_const_id(id);
16019 }
16020 
16021 int
16022 rb_is_class_id(ID id)
16023 {
16024     return is_class_id(id);
16025 }
16026 
16027 int
16028 rb_is_instance_id(ID id)
16029 {
16030     return is_instance_id(id);
16031 }
16032 
16033 int
16034 rb_is_local_id(ID id)
16035 {
16036     return is_local_id(id);
16037 }
16038 
16039 int
16040 rb_is_junk_id(ID id)
16041 {
16042     return is_junk_id(id);
16043 }
16044 
16045 #endif /* !RIPPER */
16046 
16047 static void
16048 parser_initialize(struct parser_params *parser)
16049 {
16050     parser->eofp = Qfalse;
16051 
16052     parser->parser_lex_strterm = 0;
16053     parser->parser_cond_stack = 0;
16054     parser->parser_cmdarg_stack = 0;
16055     parser->parser_class_nest = 0;
16056     parser->parser_paren_nest = 0;
16057     parser->parser_lpar_beg = 0;
16058     parser->parser_in_single = 0;
16059     parser->parser_in_def = 0;
16060     parser->parser_in_defined = 0;
16061     parser->parser_compile_for_eval = 0;
16062     parser->parser_cur_mid = 0;
16063     parser->parser_tokenbuf = NULL;
16064     parser->parser_tokidx = 0;
16065     parser->parser_toksiz = 0;
16066     parser->parser_heredoc_end = 0;
16067     parser->parser_command_start = TRUE;
16068     parser->parser_deferred_nodes = 0;
16069     parser->parser_lex_pbeg = 0;
16070     parser->parser_lex_p = 0;
16071     parser->parser_lex_pend = 0;
16072     parser->parser_lvtbl = 0;
16073     parser->parser_ruby__end__seen = 0;
16074     parser->parser_ruby_sourcefile = 0;
16075 #ifndef RIPPER
16076     parser->is_ripper = 0;
16077     parser->parser_eval_tree_begin = 0;
16078     parser->parser_eval_tree = 0;
16079 #else
16080     parser->is_ripper = 1;
16081     parser->parser_ruby_sourcefile_string = Qnil;
16082     parser->delayed = Qnil;
16083 
16084     parser->result = Qnil;
16085     parser->parsing_thread = Qnil;
16086     parser->toplevel_p = TRUE;
16087 #endif
16088 #ifdef YYMALLOC
16089     parser->heap = NULL;
16090 #endif
16091     parser->enc = rb_usascii_encoding();
16092 }
16093 
16094 #ifdef RIPPER
16095 #define parser_mark ripper_parser_mark
16096 #define parser_free ripper_parser_free
16097 #endif
16098 
16099 static void
16100 parser_mark(void *ptr)
16101 {
16102     struct parser_params *p = (struct parser_params*)ptr;
16103 
16104     rb_gc_mark((VALUE)p->parser_lex_strterm);
16105     rb_gc_mark((VALUE)p->parser_deferred_nodes);
16106     rb_gc_mark(p->parser_lex_input);
16107     rb_gc_mark(p->parser_lex_lastline);
16108     rb_gc_mark(p->parser_lex_nextline);
16109 #ifndef RIPPER
16110     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
16111     rb_gc_mark((VALUE)p->parser_eval_tree) ;
16112     rb_gc_mark(p->debug_lines);
16113 #else
16114     rb_gc_mark(p->parser_ruby_sourcefile_string);
16115     rb_gc_mark(p->delayed);
16116     rb_gc_mark(p->value);
16117     rb_gc_mark(p->result);
16118     rb_gc_mark(p->parsing_thread);
16119 #endif
16120 #ifdef YYMALLOC
16121     rb_gc_mark((VALUE)p->heap);
16122 #endif
16123 }
16124 
16125 static void
16126 parser_free(void *ptr)
16127 {
16128     struct parser_params *p = (struct parser_params*)ptr;
16129     struct local_vars *local, *prev;
16130 
16131     if (p->parser_tokenbuf) {
16132         xfree(p->parser_tokenbuf);
16133     }
16134     for (local = p->parser_lvtbl; local; local = prev) {
16135         if (local->vars) xfree(local->vars);
16136         prev = local->prev;
16137         xfree(local);
16138     }
16139 #ifndef RIPPER
16140     xfree(p->parser_ruby_sourcefile);
16141 #endif
16142     xfree(p);
16143 }
16144 
16145 static size_t
16146 parser_memsize(const void *ptr)
16147 {
16148     struct parser_params *p = (struct parser_params*)ptr;
16149     struct local_vars *local;
16150     size_t size = sizeof(*p);
16151 
16152     if (!ptr) return 0;
16153     size += p->parser_toksiz;
16154     for (local = p->parser_lvtbl; local; local = local->prev) {
16155         size += sizeof(*local);
16156         if (local->vars) size += local->vars->capa * sizeof(ID);
16157     }
16158 #ifndef RIPPER
16159     if (p->parser_ruby_sourcefile) {
16160         size += strlen(p->parser_ruby_sourcefile) + 1;
16161     }
16162 #endif
16163     return size;
16164 }
16165 
16166 static const rb_data_type_t parser_data_type = {
16167     "parser",
16168     parser_mark,
16169     parser_free,
16170     parser_memsize,
16171 };
16172 
16173 VALUE rb_parser_get_yydebug(VALUE);
16174 VALUE rb_parser_set_yydebug(VALUE, VALUE);
16175 
16176 #ifndef RIPPER
16177 #undef rb_reserved_word
16178 
16179 const struct kwtable *
16180 rb_reserved_word(const char *str, unsigned int len)
16181 {
16182     return reserved_word(str, len);
16183 }
16184 
16185 static struct parser_params *
16186 parser_new(void)
16187 {
16188     struct parser_params *p;
16189 
16190     p = ALLOC_N(struct parser_params, 1);
16191     MEMZERO(p, struct parser_params, 1);
16192     parser_initialize(p);
16193     return p;
16194 }
16195 
16196 VALUE
16197 rb_parser_new(void)
16198 {
16199     struct parser_params *p = parser_new();
16200 
16201     return TypedData_Wrap_Struct(0, &parser_data_type, p);
16202 }
16203 
16204 /*
16205  *  call-seq:
16206  *    ripper#end_seen?   -> Boolean
16207  *
16208  *  Return if parsed source ended by +\_\_END\_\_+.
16209  *  This number starts from 1.
16210  */
16211 VALUE
16212 rb_parser_end_seen_p(VALUE vparser)
16213 {
16214     struct parser_params *parser;
16215 
16216     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16217     return ruby__end__seen ? Qtrue : Qfalse;
16218 }
16219 
16220 /*
16221  *  call-seq:
16222  *    ripper#encoding   -> encoding
16223  *
16224  *  Return encoding of the source.
16225  */
16226 VALUE
16227 rb_parser_encoding(VALUE vparser)
16228 {
16229     struct parser_params *parser;
16230 
16231     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16232     return rb_enc_from_encoding(parser->enc);
16233 }
16234 
16235 /*
16236  *  call-seq:
16237  *    ripper.yydebug   -> true or false
16238  *
16239  *  Get yydebug.
16240  */
16241 VALUE
16242 rb_parser_get_yydebug(VALUE self)
16243 {
16244     struct parser_params *parser;
16245 
16246     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16247     return yydebug ? Qtrue : Qfalse;
16248 }
16249 
16250 /*
16251  *  call-seq:
16252  *    ripper.yydebug = flag
16253  *
16254  *  Set yydebug.
16255  */
16256 VALUE
16257 rb_parser_set_yydebug(VALUE self, VALUE flag)
16258 {
16259     struct parser_params *parser;
16260 
16261     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16262     yydebug = RTEST(flag);
16263     return flag;
16264 }
16265 
16266 #ifdef YYMALLOC
16267 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16268 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16269 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16270                            (n)->u3.cnt = (c), (p))
16271 
16272 void *
16273 rb_parser_malloc(struct parser_params *parser, size_t size)
16274 {
16275     size_t cnt = HEAPCNT(1, size);
16276     NODE *n = NEWHEAP();
16277     void *ptr = xmalloc(size);
16278 
16279     return ADD2HEAP(n, cnt, ptr);
16280 }
16281 
16282 void *
16283 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16284 {
16285     size_t cnt = HEAPCNT(nelem, size);
16286     NODE *n = NEWHEAP();
16287     void *ptr = xcalloc(nelem, size);
16288 
16289     return ADD2HEAP(n, cnt, ptr);
16290 }
16291 
16292 void *
16293 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16294 {
16295     NODE *n;
16296     size_t cnt = HEAPCNT(1, size);
16297 
16298     if (ptr && (n = parser->heap) != NULL) {
16299         do {
16300             if (n->u1.node == ptr) {
16301                 n->u1.node = ptr = xrealloc(ptr, size);
16302                 if (n->u3.cnt) n->u3.cnt = cnt;
16303                 return ptr;
16304             }
16305         } while ((n = n->u2.node) != NULL);
16306     }
16307     n = NEWHEAP();
16308     ptr = xrealloc(ptr, size);
16309     return ADD2HEAP(n, cnt, ptr);
16310 }
16311 
16312 void
16313 rb_parser_free(struct parser_params *parser, void *ptr)
16314 {
16315     NODE **prev = &parser->heap, *n;
16316 
16317     while ((n = *prev) != NULL) {
16318         if (n->u1.node == ptr) {
16319             *prev = n->u2.node;
16320             rb_gc_force_recycle((VALUE)n);
16321             break;
16322         }
16323         prev = &n->u2.node;
16324     }
16325     xfree(ptr);
16326 }
16327 #endif
16328 #endif
16329 
16330 #ifdef RIPPER
16331 #ifdef RIPPER_DEBUG
16332 extern int rb_is_pointer_to_heap(VALUE);
16333 
16334 /* :nodoc: */
16335 static VALUE
16336 ripper_validate_object(VALUE self, VALUE x)
16337 {
16338     if (x == Qfalse) return x;
16339     if (x == Qtrue) return x;
16340     if (x == Qnil) return x;
16341     if (x == Qundef)
16342         rb_raise(rb_eArgError, "Qundef given");
16343     if (FIXNUM_P(x)) return x;
16344     if (SYMBOL_P(x)) return x;
16345     if (!rb_is_pointer_to_heap(x))
16346         rb_raise(rb_eArgError, "invalid pointer: %p", x);
16347     switch (TYPE(x)) {
16348       case T_STRING:
16349       case T_OBJECT:
16350       case T_ARRAY:
16351       case T_BIGNUM:
16352       case T_FLOAT:
16353         return x;
16354       case T_NODE:
16355         if (nd_type(x) != NODE_LASGN) {
16356             rb_raise(rb_eArgError, "NODE given: %p", x);
16357         }
16358         return ((NODE *)x)->nd_rval;
16359       default:
16360         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16361                  x, rb_obj_classname(x));
16362     }
16363     return x;
16364 }
16365 #endif
16366 
16367 #define validate(x) (x = get_value(x))
16368 
16369 static VALUE
16370 ripper_dispatch0(struct parser_params *parser, ID mid)
16371 {
16372     return rb_funcall(parser->value, mid, 0);
16373 }
16374 
16375 static VALUE
16376 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16377 {
16378     validate(a);
16379     return rb_funcall(parser->value, mid, 1, a);
16380 }
16381 
16382 static VALUE
16383 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16384 {
16385     validate(a);
16386     validate(b);
16387     return rb_funcall(parser->value, mid, 2, a, b);
16388 }
16389 
16390 static VALUE
16391 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16392 {
16393     validate(a);
16394     validate(b);
16395     validate(c);
16396     return rb_funcall(parser->value, mid, 3, a, b, c);
16397 }
16398 
16399 static VALUE
16400 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16401 {
16402     validate(a);
16403     validate(b);
16404     validate(c);
16405     validate(d);
16406     return rb_funcall(parser->value, mid, 4, a, b, c, d);
16407 }
16408 
16409 static VALUE
16410 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16411 {
16412     validate(a);
16413     validate(b);
16414     validate(c);
16415     validate(d);
16416     validate(e);
16417     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16418 }
16419 
16420 static const struct kw_assoc {
16421     ID id;
16422     const char *name;
16423 } keyword_to_name[] = {
16424     {keyword_class,     "class"},
16425     {keyword_module,    "module"},
16426     {keyword_def,       "def"},
16427     {keyword_undef,     "undef"},
16428     {keyword_begin,     "begin"},
16429     {keyword_rescue,    "rescue"},
16430     {keyword_ensure,    "ensure"},
16431     {keyword_end,       "end"},
16432     {keyword_if,        "if"},
16433     {keyword_unless,    "unless"},
16434     {keyword_then,      "then"},
16435     {keyword_elsif,     "elsif"},
16436     {keyword_else,      "else"},
16437     {keyword_case,      "case"},
16438     {keyword_when,      "when"},
16439     {keyword_while,     "while"},
16440     {keyword_until,     "until"},
16441     {keyword_for,       "for"},
16442     {keyword_break,     "break"},
16443     {keyword_next,      "next"},
16444     {keyword_redo,      "redo"},
16445     {keyword_retry,     "retry"},
16446     {keyword_in,        "in"},
16447     {keyword_do,        "do"},
16448     {keyword_do_cond,   "do"},
16449     {keyword_do_block,  "do"},
16450     {keyword_return,    "return"},
16451     {keyword_yield,     "yield"},
16452     {keyword_super,     "super"},
16453     {keyword_self,      "self"},
16454     {keyword_nil,       "nil"},
16455     {keyword_true,      "true"},
16456     {keyword_false,     "false"},
16457     {keyword_and,       "and"},
16458     {keyword_or,        "or"},
16459     {keyword_not,       "not"},
16460     {modifier_if,       "if"},
16461     {modifier_unless,   "unless"},
16462     {modifier_while,    "while"},
16463     {modifier_until,    "until"},
16464     {modifier_rescue,   "rescue"},
16465     {keyword_alias,     "alias"},
16466     {keyword_defined,   "defined?"},
16467     {keyword_BEGIN,     "BEGIN"},
16468     {keyword_END,       "END"},
16469     {keyword__LINE__,   "__LINE__"},
16470     {keyword__FILE__,   "__FILE__"},
16471     {keyword__ENCODING__, "__ENCODING__"},
16472     {0, NULL}
16473 };
16474 
16475 static const char*
16476 keyword_id_to_str(ID id)
16477 {
16478     const struct kw_assoc *a;
16479 
16480     for (a = keyword_to_name; a->id; a++) {
16481         if (a->id == id)
16482             return a->name;
16483     }
16484     return NULL;
16485 }
16486 
16487 #undef ripper_id2sym
16488 static VALUE
16489 ripper_id2sym(ID id)
16490 {
16491     const char *name;
16492     char buf[8];
16493 
16494     if (id <= 256) {
16495         buf[0] = (char)id;
16496         buf[1] = '\0';
16497         return ID2SYM(rb_intern2(buf, 1));
16498     }
16499     if ((name = keyword_id_to_str(id))) {
16500         return ID2SYM(rb_intern(name));
16501     }
16502     switch (id) {
16503       case tOROP:
16504         name = "||";
16505         break;
16506       case tANDOP:
16507         name = "&&";
16508         break;
16509       default:
16510         name = rb_id2name(id);
16511         if (!name) {
16512             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16513         }
16514         return ID2SYM(id);
16515     }
16516     return ID2SYM(rb_intern(name));
16517 }
16518 
16519 static ID
16520 ripper_get_id(VALUE v)
16521 {
16522     NODE *nd;
16523     if (!RB_TYPE_P(v, T_NODE)) return 0;
16524     nd = (NODE *)v;
16525     if (nd_type(nd) != NODE_LASGN) return 0;
16526     return nd->nd_vid;
16527 }
16528 
16529 static VALUE
16530 ripper_get_value(VALUE v)
16531 {
16532     NODE *nd;
16533     if (v == Qundef) return Qnil;
16534     if (!RB_TYPE_P(v, T_NODE)) return v;
16535     nd = (NODE *)v;
16536     if (nd_type(nd) != NODE_LASGN) return Qnil;
16537     return nd->nd_rval;
16538 }
16539 
16540 static void
16541 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16542 {
16543     VALUE str;
16544     va_list args;
16545 
16546     va_start(args, fmt);
16547     str = rb_vsprintf(fmt, args);
16548     va_end(args);
16549     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16550 }
16551 
16552 static void
16553 ripper_warn0(struct parser_params *parser, const char *fmt)
16554 {
16555     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16556 }
16557 
16558 static void
16559 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16560 {
16561     rb_funcall(parser->value, rb_intern("warn"), 2,
16562                STR_NEW2(fmt), INT2NUM(a));
16563 }
16564 
16565 #if 0
16566 static void
16567 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16568 {
16569     rb_funcall(parser->value, rb_intern("warn"), 2,
16570                STR_NEW2(fmt), STR_NEW2(str));
16571 }
16572 #endif
16573 
16574 static void
16575 ripper_warning0(struct parser_params *parser, const char *fmt)
16576 {
16577     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16578 }
16579 
16580 static void
16581 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16582 {
16583     rb_funcall(parser->value, rb_intern("warning"), 2,
16584                STR_NEW2(fmt), STR_NEW2(str));
16585 }
16586 
16587 static VALUE
16588 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16589 {
16590     return rb_funcall(src, ripper_id_gets, 0);
16591 }
16592 
16593 static VALUE
16594 ripper_s_allocate(VALUE klass)
16595 {
16596     struct parser_params *p;
16597     VALUE self;
16598 
16599     p = ALLOC_N(struct parser_params, 1);
16600     MEMZERO(p, struct parser_params, 1);
16601     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16602     p->value = self;
16603     return self;
16604 }
16605 
16606 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16607 
16608 /*
16609  *  call-seq:
16610  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
16611  *
16612  *  Create a new Ripper object.
16613  *  _src_ must be a String, an IO, or an Object which has #gets method.
16614  *
16615  *  This method does not starts parsing.
16616  *  See also Ripper#parse and Ripper.parse.
16617  */
16618 static VALUE
16619 ripper_initialize(int argc, VALUE *argv, VALUE self)
16620 {
16621     struct parser_params *parser;
16622     VALUE src, fname, lineno;
16623 
16624     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16625     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
16626     if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
16627         parser->parser_lex_gets = ripper_lex_get_generic;
16628     }
16629     else {
16630         StringValue(src);
16631         parser->parser_lex_gets = lex_get_str;
16632     }
16633     parser->parser_lex_input = src;
16634     parser->eofp = Qfalse;
16635     if (NIL_P(fname)) {
16636         fname = STR_NEW2("(ripper)");
16637     }
16638     else {
16639         StringValue(fname);
16640     }
16641     parser_initialize(parser);
16642 
16643     parser->parser_ruby_sourcefile_string = fname;
16644     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
16645     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
16646 
16647     return Qnil;
16648 }
16649 
16650 extern VALUE rb_thread_pass(void);
16651 
16652 struct ripper_args {
16653     struct parser_params *parser;
16654     int argc;
16655     VALUE *argv;
16656 };
16657 
16658 static VALUE
16659 ripper_parse0(VALUE parser_v)
16660 {
16661     struct parser_params *parser;
16662 
16663     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16664     parser_prepare(parser);
16665     ripper_yyparse((void*)parser);
16666     return parser->result;
16667 }
16668 
16669 static VALUE
16670 ripper_ensure(VALUE parser_v)
16671 {
16672     struct parser_params *parser;
16673 
16674     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16675     parser->parsing_thread = Qnil;
16676     return Qnil;
16677 }
16678 
16679 /*
16680  *  call-seq:
16681  *    ripper#parse
16682  *
16683  *  Start parsing and returns the value of the root action.
16684  */
16685 static VALUE
16686 ripper_parse(VALUE self)
16687 {
16688     struct parser_params *parser;
16689 
16690     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16691     if (!ripper_initialized_p(parser)) {
16692         rb_raise(rb_eArgError, "method called for uninitialized object");
16693     }
16694     if (!NIL_P(parser->parsing_thread)) {
16695         if (parser->parsing_thread == rb_thread_current())
16696             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
16697         else
16698             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
16699     }
16700     parser->parsing_thread = rb_thread_current();
16701     rb_ensure(ripper_parse0, self, ripper_ensure, self);
16702 
16703     return parser->result;
16704 }
16705 
16706 /*
16707  *  call-seq:
16708  *    ripper#column   -> Integer
16709  *
16710  *  Return column number of current parsing line.
16711  *  This number starts from 0.
16712  */
16713 static VALUE
16714 ripper_column(VALUE self)
16715 {
16716     struct parser_params *parser;
16717     long col;
16718 
16719     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16720     if (!ripper_initialized_p(parser)) {
16721         rb_raise(rb_eArgError, "method called for uninitialized object");
16722     }
16723     if (NIL_P(parser->parsing_thread)) return Qnil;
16724     col = parser->tokp - parser->parser_lex_pbeg;
16725     return LONG2NUM(col);
16726 }
16727 
16728 /*
16729  *  call-seq:
16730  *    ripper#filename   -> String
16731  *
16732  *  Return current parsing filename.
16733  */
16734 static VALUE
16735 ripper_filename(VALUE self)
16736 {
16737     struct parser_params *parser;
16738 
16739     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16740     if (!ripper_initialized_p(parser)) {
16741         rb_raise(rb_eArgError, "method called for uninitialized object");
16742     }
16743     return parser->parser_ruby_sourcefile_string;
16744 }
16745 
16746 /*
16747  *  call-seq:
16748  *    ripper#lineno   -> Integer
16749  *
16750  *  Return line number of current parsing line.
16751  *  This number starts from 1.
16752  */
16753 static VALUE
16754 ripper_lineno(VALUE self)
16755 {
16756     struct parser_params *parser;
16757 
16758     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16759     if (!ripper_initialized_p(parser)) {
16760         rb_raise(rb_eArgError, "method called for uninitialized object");
16761     }
16762     if (NIL_P(parser->parsing_thread)) return Qnil;
16763     return INT2NUM(parser->parser_ruby_sourceline);
16764 }
16765 
16766 #ifdef RIPPER_DEBUG
16767 /* :nodoc: */
16768 static VALUE
16769 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
16770 {
16771     StringValue(msg);
16772     if (obj == Qundef) {
16773         rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
16774     }
16775     return Qnil;
16776 }
16777 
16778 /* :nodoc: */
16779 static VALUE
16780 ripper_value(VALUE self, VALUE obj)
16781 {
16782     return ULONG2NUM(obj);
16783 }
16784 #endif
16785 
16786 void
16787 Init_ripper(void)
16788 {
16789     VALUE Ripper;
16790 
16791     Ripper = rb_define_class("Ripper", rb_cObject);
16792     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
16793     rb_define_alloc_func(Ripper, ripper_s_allocate);
16794     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
16795     rb_define_method(Ripper, "parse", ripper_parse, 0);
16796     rb_define_method(Ripper, "column", ripper_column, 0);
16797     rb_define_method(Ripper, "filename", ripper_filename, 0);
16798     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
16799     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
16800     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
16801     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
16802     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
16803 #ifdef RIPPER_DEBUG
16804     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
16805     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
16806     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
16807 #endif
16808 
16809     ripper_id_gets = rb_intern("gets");
16810     ripper_init_eventids1(Ripper);
16811     ripper_init_eventids2(Ripper);
16812     /* ensure existing in symbol table */
16813     rb_intern("||");
16814     rb_intern("&&");
16815 }
16816 #endif /* RIPPER */
16817 
16818 

Generated on Thu Sep 8 2011 03:50:37 for Ruby by  doxygen 1.7.1